M2: the full job lifecycle — chat, hiring, geocoding, quotes, bookings, reviews

Closes the funnel. Before this the product could match two people and then stopped: `quotes`, `bookings` and `reviews` had tables and state machines and nothing that wrote a row, the entry deck's right swipe was wired to an empty handler, and every address resolved to the city centre. Jobs tab and chat - message router: thread, send, markRead, unreadTotal. A thread is a MATCH, not a job — one job with three interested pros is three private conversations. - Current/Past segments derived from ACTIVE_JOB_STATUSES, job detail listing the pros who accepted, and the conversation itself with attachments. Hiring from the deck - A right swipe on the entry deck opened nothing. It now resolves "which job?" through a sheet — sign in, pick an open job, or post one — and calls the same deck.swipe the per-job deck does, so the open-request cap and row lock apply exactly once. Swipes are vetoable so closing the sheet returns the card. Geocoding - ST_Distance and ST_DWithin rank and filter every deck, and both operands were placeholders. Addresses now resolve through Mapbox (permanent=true, which is what licenses storing the coordinates), the server resolves points rather than trusting client-supplied lat/lng, and every stored point records how it was obtained. A `city`-precision base cannot reach the verification queue. Quote -> booking -> review - The commercial chain, minus payments. Accepting a quote is the only place a booking is created; confirming completion is what unlocks reviews and moves the pro's completed_jobs. - Reviews publish double-blind with no sweeper: each is written with published_at already set to its embargo deadline and every read filters published_at <= now(), so it publishes itself. The second review pulls both forward. A silent counterparty cannot bury a bad review by never replying. State machine changes, both deliberate - booked -> matched: a cancelled booking is not a cancelled job. - scheduled -> awaiting_confirmation: in_progress is optional, so a pro who never tapped Start can still say the work is done. Test suite - api tests ran files in parallel against one database and failed roughly one run in three on whichever file lost the race. Serialised, and three fixtures that grabbed "the first client" pinned to the seeded accounts. Also includes work from a parallel session: admin verification queue, pro public profile and reviews read path, notification sending, denormalised stats recompute, search, and observability. 318 tests passing; typecheck and lint clean across 7 packages. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-21 06:29:59 -04:00
parent 8f3509d1dd
commit 974e312534
115 changed files with 19994 additions and 569 deletions
@@ -0,0 +1,146 @@
+/**
+ * Integration test — runs against a live seeded database.
+ *
+ *   pnpm services:up && pnpm db:migrate && pnpm db:seed
+ *   pnpm --filter @linkder/db test
+ *
+ * Search is a second door onto the same supply as the deck, so the test that
+ * matters most is the parity one: a pro who can be found here must be a pro who
+ * could be swiped there. That invariant is why `eligiblePro()` exists.
+ */
+import { config } from 'dotenv';
+import { sql } from 'drizzle-orm';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+
+config({ path: '../../.env' });
+
+const { closePool, db } = await import('../src/client');
+const { searchPros } = await import('../src/queries/search');
+const { getShowcaseDeck } = await import('../src/queries/deck');
+
+/** The seed places every pro relative to this point. */
+const CENTRE = { lat: 41.3874, lng: 2.1686 };
+
+let plumberId: string;
+
+beforeAll(async () => {
+  const [plumber] = await db.execute<{ id: string }>(
+    sql`SELECT id FROM categories WHERE slug = 'plumber' LIMIT 1`,
+  );
+  if (!plumber) throw new Error('plumber category missing from seed');
+  plumberId = plumber.id;
+
+  // Seeded skills are empty, so text search has nothing to match until we give
+  // one pro something to find. Marc Oliveras is 800 m from the centre.
+  await db.execute(sql`
+    UPDATE pro_profiles SET skills = ARRAY['Underfloor heating', 'Emergency callouts']
+     WHERE user_id = (SELECT id FROM users WHERE name = 'Marc Oliveras')
+  `);
+});
+
+afterAll(async () => {
+  await db.execute(sql`
+    UPDATE pro_profiles SET skills = '{}'::text[]
+     WHERE user_id = (SELECT id FROM users WHERE name = 'Marc Oliveras')
+  `);
+  await closePool();
+});
+
+describe('searchPros', () => {
+  it('returns eligible pros with no query at all', async () => {
+    const results = await searchPros(db, { ...CENTRE, limit: 50 });
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it('never returns anyone the shop window would not show', async () => {
+    // The parity invariant. If these two ever disagree, one surface has become
+    // the way around the other.
+    const found = await searchPros(db, { ...CENTRE, limit: 50 });
+    const showcase = await getShowcaseDeck(db, { ...CENTRE, limit: 100 });
+    const shownIds = new Set(showcase.map((c) => c.proId));
+
+    for (const pro of found) {
+      expect(shownIds.has(pro.proId)).toBe(true);
+    }
+  });
+
+  it('excludes the unverified, the away and the too-far', async () => {
+    const names = (await searchPros(db, { ...CENTRE, limit: 50 })).map((p) => p.name);
+    expect(names).not.toContain('Unverified Ulla');
+    expect(names).not.toContain('Away Arnau');
+    expect(names).not.toContain('Pau Ribas'); // 22 km out, 5 km radius
+  });
+
+  it('matches a skill', async () => {
+    const names = (await searchPros(db, { ...CENTRE, q: 'underfloor', limit: 50 })).map(
+      (p) => p.name,
+    );
+    expect(names).toContain('Marc Oliveras');
+    expect(names).not.toContain('Laia Mestre'); // an electrician with no such skill
+  });
+
+  it('matches a trade name', async () => {
+    const results = await searchPros(db, { ...CENTRE, q: 'electrician', limit: 50 });
+    expect(results.length).toBeGreaterThan(0);
+    expect(results.every((p) => p.categories.includes('Electrician'))).toBe(true);
+  });
+
+  it('matches a pro by name', async () => {
+    const names = (await searchPros(db, { ...CENTRE, q: 'oliveras', limit: 50 })).map((p) => p.name);
+    expect(names).toEqual(['Marc Oliveras']);
+  });
+
+  it('treats wildcards as literal characters', async () => {
+    // Without escaping, '%' matches everyone and the filter looks broken.
+    const results = await searchPros(db, { ...CENTRE, q: '%', limit: 50 });
+    expect(results).toHaveLength(0);
+  });
+
+  it('narrows to one trade', async () => {
+    const results = await searchPros(db, { ...CENTRE, categoryId: plumberId, limit: 50 });
+    expect(results.length).toBeGreaterThan(0);
+    expect(results.every((p) => p.categories.includes('Plumber'))).toBe(true);
+  });
+
+  it("honours the searcher's own distance limit", async () => {
+    const near = await searchPros(db, { ...CENTRE, maxDistanceM: 3_000, limit: 50 });
+    expect(near.every((p) => p.distanceM <= 3_000)).toBe(true);
+    expect(near.map((p) => p.name)).not.toContain('Marta Vidal'); // 9.1 km out
+  });
+
+  it('sorts by distance, price and rating', async () => {
+    const nearest = await searchPros(db, { ...CENTRE, sort: 'nearest', limit: 50 });
+    for (let i = 1; i < nearest.length; i++) {
+      expect(nearest[i]!.distanceM).toBeGreaterThanOrEqual(nearest[i - 1]!.distanceM);
+    }
+
+    const cheapest = await searchPros(db, { ...CENTRE, sort: 'price', limit: 50 });
+    for (let i = 1; i < cheapest.length; i++) {
+      expect(cheapest[i]!.hourlyRateCents).toBeGreaterThanOrEqual(cheapest[i - 1]!.hourlyRateCents);
+    }
+
+    const rated = await searchPros(db, { ...CENTRE, sort: 'rating', limit: 50 });
+    const scored = rated.filter((p) => p.ratingAvg !== null);
+    for (let i = 1; i < scored.length; i++) {
+      expect(scored[i]!.ratingAvg!).toBeLessThanOrEqual(scored[i - 1]!.ratingAvg!);
+    }
+    // Unrated pros sort last rather than being read as zero.
+    const firstUnrated = rated.findIndex((p) => p.ratingAvg === null);
+    if (firstUnrated !== -1) {
+      expect(rated.slice(firstUnrated).every((p) => p.ratingAvg === null)).toBe(true);
+    }
+  });
+
+  it('excludes the unrated from a rating floor', async () => {
+    const results = await searchPros(db, { ...CENTRE, minRating: 4.5, limit: 50 });
+    expect(results.every((p) => p.ratingAvg !== null && p.ratingAvg >= 4.5)).toBe(true);
+  });
+
+  it('honours a price ceiling and the limit', async () => {
+    const cheap = await searchPros(db, { ...CENTRE, maxHourlyRateCents: 3_000, limit: 50 });
+    expect(cheap.every((p) => p.hourlyRateCents <= 3_000)).toBe(true);
+
+    const two = await searchPros(db, { ...CENTRE, limit: 2 });
+    expect(two).toHaveLength(2);
+  });
+});