create-ailk 0.1.0 → 0.2.0

package/templates/apps/api/src/routes/project-listings/__tests__/structured-address.test.ts

@@ -0,0 +1,467 @@
+/**
+ * @file structured-address.test.ts
+ *
+ * THE ACCEPTANCE GATE for the structured founder address (#5279).
+ *
+ * The application collected a whole business address in ONE free-text box.
+ * It now renders a fieldset, and the payload field `address` became a UNION:
+ * the legacy display STRING or the structured PARTS. The row keeps `address`
+ * as the single-line DISPLAY string and gains six nullable part columns
+ * beside it, which the server writes — and composes the display line from —
+ * in `draftUpdateData`.
+ *
+ * Two properties carry this change, and both look fine when broken, which is
+ * why they each get a test that fails when they are:
+ *
+ *   1. The parts arrive as PARTS. A patch carrying the structured object must
+ *      land six DISTINCT column values, not one concatenated string in
+ *      `address` with the columns left null. A service that quietly stringified
+ *      the object would produce a row that reads correctly on the listing page
+ *      and has silently thrown away the split the fieldset exists to capture.
+ *
+ *   2. A legacy free-text address round-trips CHARACTER-FOR-CHARACTER with its
+ *      parts null. Nothing may ever split an existing `address` into parts:
+ *      address parsing guesses, and a wrong guess silently corrupts the party
+ *      identification the listing's privacy notice points at (#5036 D6), with
+ *      nothing on the row to mark it as invented. A null part is honest; a
+ *      guessed one is not.
+ *
+ * Same harness as `configured-application.test.ts` and `drafts.test.ts`: real
+ * routes, real services, mocked `lib/prisma.js` over a small in-memory row
+ * store, `routeLead` running for real against a per-test temp path.
+ */
+
+// eslint-disable-next-line no-restricted-syntax -- prisma is a DB boundary; __mocks__/prisma.ts activates the auto-mock
+jest.mock("../../../lib/prisma.js");
+
+jest.mock("@working-theory/email", () => ({
+  sendLeadNotification: jest.fn().mockResolvedValue({ ok: true, messageId: "msg-test" }),
+}));
+
+jest.mock("@working-theory/license", () => ({
+  checkLicense: jest.fn().mockResolvedValue({
+    tier: "free",
+    plan: null,
+    features: [],
+    expiresAt: null,
+    revoked: false,
+  }),
+}));
+
+import Fastify from "fastify";
+import type { FastifyInstance } from "fastify";
+
+import { setupLeadFileEnv } from "../../../__tests__/factories/lead-fixture";
+import { prisma } from "../../../lib/prisma.js";
+import { patchProjectListingDraftRoute } from "../patch-draft.js";
+import { startProjectListingRoute } from "../start.js";
+import { submitProjectListingRoute } from "../submit.js";
+
+// ─── Fixtures ───────────────────────────────────────────────────────────────
+
+const SITE_ID = "site-1";
+const SITE_KEY = "pk-site-1";
+
+const opt = (value: string, label: string) => ({ value, label });
+
+const VALID_QUESTIONS = {
+  q2: {
+    prompt: "Why are you here?",
+    options: [opt("scale", "Scaling my team"), opt("just-curious", "Just curious")],
+  },
+  q3: { prompt: "Stage?", options: [opt("a", "A"), opt("b", "B"), opt("c", "C")] },
+  q4: { prompt: "Team size?", options: [opt("a", "A"), opt("b", "B"), opt("c", "C")] },
+  q5: {
+    prompt: "Urgency?",
+    options: [opt("urgent", "Now"), opt("planning", "Soon"), opt("exploring", "Someday")],
+  },
+  q6: {
+    prompt: "Pain?",
+    options: [
+      opt("low", "Low"),
+      opt("medium", "Medium"),
+      opt("high", "High"),
+      opt("critical", "Critical"),
+    ],
+  },
+  q7: { prompt: "Anything else?" },
+  extras: [],
+};
+
+const START_PAYLOAD = {
+  siteKey: SITE_KEY,
+  founderName: "Ada Founder",
+  founderEmail: "ada@example.com",
+  consent: true,
+};
+
+/** Everything the ten steps after step one collect, minus the address. */
+const APPLICATION_WITHOUT_ADDRESS = {
+  name: "My Project",
+  headline: "Ten words or fewer for the tile title here",
+  oneLiner: "A short sentence describing what the project does for its people.",
+  problem: "The problem is real and this describes it.",
+  product: "wireframes",
+  commitment: "part-time",
+  teamComposition: "co-founders",
+  faqs: [
+    { question: "Q one?", answer: "A one." },
+    { question: "Q two?", answer: "A two." },
+    { question: "Q three?", answer: "A three." },
+  ],
+  questions: VALID_QUESTIONS,
+};
+
+/** What `AddressFieldset` posts — six controls under six fixed keys. */
+const ADDRESS_PARTS = {
+  addressLine1: "221B Baker Street",
+  addressLine2: "Flat B",
+  city: "London",
+  region: "Greater London",
+  postalCode: "NW1 6XE",
+  country: "GB",
+};
+
+/**
+ * The display line the SERVER must compose from `ADDRESS_PARTS` — the parts
+ * in reading order, joined with ", ". Written out literally rather than by
+ * calling `composeAddressLine`, so a change to the joiner fails this test
+ * instead of travelling through it.
+ */
+const COMPOSED_ADDRESS_LINE =
+  "221B Baker Street, Flat B, London, Greater London, NW1 6XE, GB";
+
+/**
+ * An address a founder typed into the ONE free-text box, before #5279. It is
+ * not in the composed order, its parts are not separable by any rule, and
+ * nothing may ever try: it is here to be returned unchanged.
+ */
+const LEGACY_ADDRESS_LINE =
+  "221B Baker Street, Marylebone, London NW1 6XE, United Kingdom";
+
+// ─── The in-memory row store the Prisma mock is backed by ───────────────────
+
+type Row = Record<string, unknown>;
+
+let rows: Row[];
+let nextId: number;
+
+function matches(row: Row, where: Record<string, unknown>): boolean {
+  return Object.entries(where).every(([key, value]) => {
+    if (key === "OR") {
+      return (value as Record<string, unknown>[]).some((clause) => matches(row, clause));
+    }
+    if (value !== null && typeof value === "object" && !(value instanceof Date)) {
+      const clause = value as Record<string, unknown>;
+      if ("in" in clause) return (clause["in"] as unknown[]).includes(row[key]);
+      if ("not" in clause) return row[key] !== clause["not"];
+      if ("gt" in clause) return (row[key] as Date) > (clause["gt"] as Date);
+      if ("startsWith" in clause) {
+        return (
+          typeof row[key] === "string" &&
+          (row[key] as string).startsWith(clause["startsWith"] as string)
+        );
+      }
+    }
+    return row[key] === value;
+  });
+}
+
+function installStore(): void {
+  rows = [];
+  nextId = 1;
+
+  (prisma.lead.create as jest.Mock).mockImplementation(() =>
+    Promise.resolve({ id: `lead_00000000-0000-7000-8000-00000000000${nextId}` }),
+  );
+
+  (prisma.siteListingConfig.findUnique as jest.Mock).mockImplementation(
+    ({ where }: { where: { siteId?: string; publicKey?: string } }) => {
+      if (where.publicKey !== undefined) {
+        return Promise.resolve(where.publicKey === SITE_KEY ? { siteId: SITE_ID } : null);
+      }
+      // No config row — the platform defaults, which collect `address`.
+      return Promise.resolve(null);
+    },
+  );
+
+  // #5275 — the grant write `start` makes after the row. Append-only; it only
+  // needs to resolve here (drafts.test.ts asserts on what it is called with).
+  (prisma.consentGrant.createMany as jest.Mock).mockImplementation(
+    ({ data }: { data: Row[] }) => Promise.resolve({ count: data.length }),
+  );
+
+  // #5275 — `start` writes the row and its grant in one interactive
+  // transaction; the mock hands the same store-backed client through.
+  (prisma.$transaction as jest.Mock).mockImplementation(
+    async (fn: (tx: typeof prisma) => Promise<unknown>) => fn(prisma),
+  );
+
+  (prisma.projectListing.create as jest.Mock).mockImplementation(({ data }: { data: Row }) => {
+    const now = new Date();
+    const row: Row = {
+      id: `prjl_00000000-0000-7000-8000-00000000000${nextId++}`,
+      slug: null,
+      name: null,
+      oneLiner: null,
+      problem: null,
+      url: null,
+      product: null,
+      commitment: null,
+      teamComposition: null,
+      faqs: null,
+      anythingElse: null,
+      address: null,
+      // #5279 — a freshly-started draft has no parts, exactly like every row
+      // written before the columns existed.
+      addressLine1: null,
+      addressLine2: null,
+      addressCity: null,
+      addressRegion: null,
+      addressPostalCode: null,
+      addressCountry: null,
+      questions: null,
+      founderCompany: null,
+      leadId: null,
+      headline: null,
+      logoMarkUrl: null,
+      logoWordmarkUrl: null,
+      featured: false,
+      decidedAt: null,
+      decidedBy: null,
+      issueUrl: null,
+      experimentKey: null,
+      windowEndsAt: null,
+      createdAt: now,
+      updatedAt: now,
+      ...data,
+    };
+    rows.push(row);
+    return Promise.resolve(row);
+  });
+
+  (prisma.projectListing.findFirst as jest.Mock).mockImplementation(
+    ({ where }: { where: Record<string, unknown> }) =>
+      Promise.resolve(rows.find((row) => matches(row, where)) ?? null),
+  );
+
+  (prisma.projectListing.findMany as jest.Mock).mockImplementation(
+    ({ where }: { where: Record<string, unknown> }) =>
+      Promise.resolve(rows.filter((row) => matches(row, where))),
+  );
+
+  (prisma.projectListing.update as jest.Mock).mockImplementation(
+    ({ where, data }: { where: Record<string, unknown>; data: Row }) => {
+      const row = rows.find((r) => matches(r, where));
+      Object.assign(row!, data, { updatedAt: new Date() });
+      return Promise.resolve(row);
+    },
+  );
+
+  (prisma.projectListing.updateMany as jest.Mock).mockImplementation(
+    ({ where, data }: { where: Record<string, unknown>; data: Row }) => {
+      const matched = rows.filter((r) => matches(r, where));
+      matched.forEach((r) => Object.assign(r, data, { updatedAt: new Date() }));
+      return Promise.resolve({ count: matched.length });
+    },
+  );
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+const bearer = (token: string) => ({ authorization: `Bearer ${token}` });
+
+async function buildApp(): Promise<FastifyInstance> {
+  const app = Fastify();
+  await app.register(startProjectListingRoute);
+  await app.register(patchProjectListingDraftRoute);
+  await app.register(submitProjectListingRoute);
+  await app.ready();
+  return app;
+}
+
+async function startDraft(
+  app: FastifyInstance,
+): Promise<{ id: string; resumeToken: string }> {
+  const res = await app.inject({
+    method: "POST",
+    url: "/v1/project-listings",
+    payload: START_PAYLOAD,
+  });
+  expect(res.statusCode).toBe(201);
+  return (res.json() as { data: { id: string; resumeToken: string } }).data;
+}
+
+const patch = (
+  app: FastifyInstance,
+  draft: { id: string; resumeToken: string },
+  payload: Record<string, unknown>,
+) =>
+  app.inject({
+    method: "PATCH",
+    url: `/v1/project-listings/drafts/${draft.id}`,
+    headers: bearer(draft.resumeToken),
+    payload,
+  });
+
+const submit = (app: FastifyInstance, draft: { id: string; resumeToken: string }) =>
+  app.inject({
+    method: "POST",
+    url: `/v1/project-listings/drafts/${draft.id}/submit`,
+    headers: bearer(draft.resumeToken),
+  });
+
+const storedRow = (id: string): Row => {
+  const row = rows.find((r) => r["id"] === id);
+  expect(row).toBeDefined();
+  return row!;
+};
+
+const draftBody = (res: { json: () => unknown }) =>
+  (res.json() as { data: Record<string, unknown> }).data;
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+
+describe("the structured founder address (#5279)", () => {
+  setupLeadFileEnv("project-listing-structured-address");
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+    installStore();
+    app = await buildApp();
+  });
+
+  afterEach(async () => {
+    await app.close();
+  });
+
+  describe("the parts arrive as PARTS, and the server composes the display line", () => {
+    it("stores six DISTINCT column values, not one concatenated string", async () => {
+      const draft = await startDraft(app);
+
+      const res = await patch(app, draft, { address: ADDRESS_PARTS });
+
+      expect(res.statusCode).toBe(200);
+
+      // The column-level half. Each part is in its OWN column — a service that
+      // stringified the object would leave every one of these null and this
+      // test is the thing that notices.
+      const row = storedRow(draft.id);
+      expect(row["addressLine1"]).toBe("221B Baker Street");
+      expect(row["addressLine2"]).toBe("Flat B");
+      expect(row["addressCity"]).toBe("London");
+      expect(row["addressRegion"]).toBe("Greater London");
+      expect(row["addressPostalCode"]).toBe("NW1 6XE");
+      expect(row["addressCountry"]).toBe("GB");
+
+      // The display half. `address` is DERIVED here and only here — the parts
+      // in reading order, joined with ", ".
+      expect(row["address"]).toBe(COMPOSED_ADDRESS_LINE);
+    });
+
+    it("answers the save with the composed line AND the parts, separably", async () => {
+      const draft = await startDraft(app);
+
+      const body = draftBody(await patch(app, draft, { address: ADDRESS_PARTS }));
+
+      expect(body["address"]).toBe(COMPOSED_ADDRESS_LINE);
+      expect(body["addressParts"]).toEqual(ADDRESS_PARTS);
+    });
+
+    it("omits the blank addressLine2 from both the columns and the composed line", async () => {
+      const draft = await startDraft(app);
+      const { addressLine2: _line2, ...withoutLine2 } = ADDRESS_PARTS;
+
+      const body = draftBody(await patch(app, draft, { address: withoutLine2 }));
+
+      expect(storedRow(draft.id)["addressLine2"]).toBeNull();
+      expect(body["address"]).toBe("221B Baker Street, London, Greater London, NW1 6XE, GB");
+      expect(body["addressParts"]).toEqual(withoutLine2);
+    });
+
+    it("a composed address submits, and reaches the row as the display line", async () => {
+      const draft = await startDraft(app);
+      await patch(app, draft, { ...APPLICATION_WITHOUT_ADDRESS, address: ADDRESS_PARTS });
+
+      const res = await submit(app, draft);
+
+      expect(res.statusCode).toBe(200);
+      expect(storedRow(draft.id)["address"]).toBe(COMPOSED_ADDRESS_LINE);
+      expect(storedRow(draft.id)["addressCountry"]).toBe("GB");
+    });
+
+    it("refuses parts that are not a whole address, rather than storing half of one", async () => {
+      const draft = await startDraft(app);
+      const { city: _city, ...incomplete } = ADDRESS_PARTS;
+
+      const res = await patch(app, draft, { address: incomplete });
+
+      expect(res.statusCode).toBe(400);
+      expect(storedRow(draft.id)["addressLine1"]).toBeNull();
+      expect(storedRow(draft.id)["address"]).toBeNull();
+    });
+  });
+
+  describe("a legacy free-text address round-trips unchanged, with its parts null", () => {
+    // The load-bearing guard. Nothing may split an existing `address` into
+    // parts — a wrong split silently corrupts the party identification the
+    // listing's privacy notice points at, and a null part is honest where a
+    // guessed one is not.
+    it("comes back CHARACTER-FOR-CHARACTER from a save, with addressParts null", async () => {
+      const draft = await startDraft(app);
+
+      const body = draftBody(await patch(app, draft, { address: LEGACY_ADDRESS_LINE }));
+
+      expect(body["address"]).toBe(LEGACY_ADDRESS_LINE);
+      expect(body["addressParts"]).toBeNull();
+    });
+
+    it("leaves EVERY part column untouched — a plain string writes none of them", async () => {
+      const draft = await startDraft(app);
+
+      await patch(app, draft, { address: LEGACY_ADDRESS_LINE });
+
+      const row = storedRow(draft.id);
+      expect(row["address"]).toBe(LEGACY_ADDRESS_LINE);
+      for (const column of [
+        "addressLine1",
+        "addressLine2",
+        "addressCity",
+        "addressRegion",
+        "addressPostalCode",
+        "addressCountry",
+      ]) {
+        expect(row[column]).toBeNull();
+      }
+    });
+
+    it("submits exactly as it did before #5279, and the stored line is unchanged", async () => {
+      const draft = await startDraft(app);
+      await patch(app, draft, {
+        ...APPLICATION_WITHOUT_ADDRESS,
+        address: LEGACY_ADDRESS_LINE,
+      });
+
+      const res = await submit(app, draft);
+
+      expect(res.statusCode).toBe(200);
+      expect(storedRow(draft.id)["address"]).toBe(LEGACY_ADDRESS_LINE);
+      expect(storedRow(draft.id)["addressLine1"]).toBeNull();
+    });
+
+    // A row written before #5279 holds a line and six nulls. Overwriting the
+    // line with a NEW line must not start inventing parts for it either.
+    it("re-patching a legacy line with another legacy line still writes no parts", async () => {
+      const draft = await startDraft(app);
+      await patch(app, draft, { address: LEGACY_ADDRESS_LINE });
+
+      await patch(app, draft, { address: "1 Example Street, Exampleton, EX1 2AM" });
+
+      const row = storedRow(draft.id);
+      expect(row["address"]).toBe("1 Example Street, Exampleton, EX1 2AM");
+      expect(row["addressCity"]).toBeNull();
+      expect(row["addressCountry"]).toBeNull();
+    });
+  });
+});