create-ailk 0.1.0 → 0.2.0

package/templates/apps/api/src/services/__tests__/listing-csv-sweep.test.ts

@@ -0,0 +1,560 @@
+/**
+ * @file listing-csv-sweep.test.ts
+ * @description Unit tests for the weekly founder-CSV sweep (#5001 AC4): one
+ * CSV per live listing carrying only the signups that landed after the
+ * previous send, stored as a `DeliverableAsset`, granted to the founder's own
+ * `Lead`, and emailed as a `/v1/deliverables/:grantId` capability link — with
+ * a listing that has no new signups sending nothing, a second run after a
+ * send sending nothing, and one failing listing never stopping the next.
+ *
+ * External dependency boundaries mocked: @working-theory/database (auto-mock
+ * via `../../lib/__mocks__/prisma.ts`) and @working-theory/email (the Resend
+ * boundary — `sendDeliverableEmail` is the send this sweep performs).
+ */
+// eslint-disable-next-line no-restricted-syntax -- prisma is a DB boundary; __mocks__/prisma.ts activates the auto-mock (Jest requires explicit call for local files)
+jest.mock("../../lib/prisma.js");
+
+jest.mock("@working-theory/email", () => ({
+  sendDeliverableEmail: jest.fn().mockResolvedValue({ ok: true, messageId: "msg-csv" }),
+}));
+
+import { sendDeliverableEmail } from "@working-theory/email";
+import { projectListingQuestionsSchema } from "@working-theory/validation";
+
+import { prisma } from "../../lib/prisma.js";
+import { LISTING_CSV_COLUMNS, runListingCsvSweep } from "../listing-csv-sweep";
+
+const SITE_ID = "site-abc";
+const NOW = new Date("2026-09-07T09:00:00.000Z");
+
+const QUESTIONS = projectListingQuestionsSchema.parse({
+  q2: {
+    prompt: "What brings you here?",
+    options: [
+      { value: "shipping-now", label: "I'm shipping something now" },
+      { value: "just-curious", label: "Just curious" },
+    ],
+  },
+  q3: {
+    prompt: "How painful is this?",
+    options: [
+      { value: "a", label: "Not a problem" },
+      { value: "b", label: "Mildly annoying" },
+      { value: "c", label: "A real drag" },
+      { value: "d", label: "It's blocking me" },
+    ],
+  },
+  q4: {
+    prompt: "How close is this?",
+    options: [
+      { value: "a", label: "Not what I need" },
+      { value: "b", label: "Adjacent" },
+      { value: "c", label: "Close" },
+      { value: "d", label: "Exactly it" },
+    ],
+  },
+  q5: {
+    prompt: "When?",
+    options: [
+      { value: "urgent", label: "Right away" },
+      { value: "planning", label: "Next quarter" },
+      { value: "exploring", label: "Just looking" },
+    ],
+  },
+  q6: {
+    prompt: "What would you pay?",
+    options: [
+      { value: "low", label: "Nothing yet" },
+      { value: "medium", label: "A little" },
+      { value: "high", label: "A real budget" },
+      { value: "critical", label: "Whatever it takes" },
+    ],
+  },
+  q7: { prompt: "Anything else?" },
+  extras: [],
+});
+
+const ORBIT = {
+  id: "prjl_orbit",
+  siteId: SITE_ID,
+  leadId: "lead_founder_orbit",
+  slug: "orbit-notes",
+  name: "Orbit Notes",
+  founderEmail: "founder@orbit.example",
+  // #5036 D6d: the listing stores the experiment's KEY — the same string
+  // `WaitlistScore.experimentKey` holds — so the sweep reads it straight off
+  // the row. The `WaitlistExperiment.findFirst` hop that translated an id into
+  // that key is gone, and with it the fixture's id -> key map.
+  experimentKey: "orbit-notes",
+  questions: QUESTIONS,
+};
+
+const LEDGER = {
+  id: "prjl_ledger",
+  siteId: SITE_ID,
+  leadId: "lead_founder_ledger",
+  slug: "ledger-lite",
+  name: "Ledger Lite",
+  founderEmail: "founder@ledger.example",
+  experimentKey: "ledger-lite",
+  questions: QUESTIONS,
+};
+
+/** One signup: a WaitlistScore row plus the completed FlowSession beside it. */
+type Signup = {
+  leadId: string;
+  tier: string;
+  createdAt: Date;
+  email: string;
+  state: Record<string, unknown>;
+};
+
+const SIGNUP_A: Signup = {
+  leadId: "lead_a",
+  tier: "now",
+  createdAt: new Date("2026-09-05T10:00:00.000Z"),
+  email: "ada@example.com",
+  state: {
+    name: "Ada",
+    email: "ada@example.com",
+    q2: "shipping-now",
+    q3: "d",
+    q4: "d",
+    q5: "urgent",
+    q6: "critical",
+    q7: "Ship it, please",
+  },
+};
+
+const SIGNUP_B: Signup = {
+  leadId: "lead_b",
+  tier: "curious",
+  createdAt: new Date("2026-09-06T10:00:00.000Z"),
+  email: "bo@example.com",
+  state: {
+    name: "Bo",
+    email: "bo@example.com",
+    q2: "just-curious",
+    q3: "a",
+    q4: "a",
+    q5: "exploring",
+    q6: "low",
+    q7: "",
+  },
+};
+
+/** A listing row as the sweep selects it — `experimentKey` is nullable. */
+type ListingFixtureRow = Omit<typeof ORBIT, "experimentKey"> & {
+  experimentKey: string | null;
+};
+
+type Fixture = {
+  listings: ListingFixtureRow[];
+  /** listingId -> the last send's `sentAt`, when one exists. */
+  lastSends: Record<string, Date>;
+  /** experiment key -> the signups scored under it. */
+  signups: Record<string, Signup[]>;
+};
+
+/** Drive the shared prisma mock from one declarative fixture. */
+function install(fixture: Fixture): void {
+  (prisma.projectListing.findMany as jest.Mock).mockResolvedValue(fixture.listings);
+
+  (prisma.listingCsvSend.findFirst as jest.Mock).mockImplementation(
+    async ({ where }: { where: { listingId: string } }) => {
+      const sentAt = fixture.lastSends[where.listingId];
+      return sentAt ? { sentAt } : null;
+    },
+  );
+
+  (prisma.waitlistScore.findMany as jest.Mock).mockImplementation(
+    async ({
+      where,
+    }: {
+      where: { experimentKey: string; createdAt?: { gt: Date } };
+    }) => {
+      const all = fixture.signups[where.experimentKey] ?? [];
+      const after = where.createdAt?.gt;
+      return all
+        .filter((s) => (after ? s.createdAt > after : true))
+        .map((s) => ({ leadId: s.leadId, tier: s.tier, createdAt: s.createdAt }));
+    },
+  );
+
+  (prisma.flowSession.findMany as jest.Mock).mockImplementation(
+    async ({ where }: { where: { leadId: { in: string[] } } }) => {
+      const wanted = new Set(where.leadId.in);
+      return Object.values(fixture.signups)
+        .flat()
+        .filter((s) => wanted.has(s.leadId))
+        .map((s) => ({ leadId: s.leadId, email: s.email, state: s.state }));
+    },
+  );
+
+  (prisma.deliverableAsset.upsert as jest.Mock).mockImplementation(
+    async ({ where }: { where: { siteId_key: { key: string } } }) => ({
+      id: `dasset_${where.siteId_key.key}`,
+    }),
+  );
+  (prisma.deliverableGrant.create as jest.Mock).mockImplementation(
+    async ({ data }: { data: { assetId: string } }) => ({
+      id: `dgrant_${data.assetId}`,
+    }),
+  );
+  (prisma.listingCsvSend.create as jest.Mock).mockResolvedValue({ id: "lcsv_1" });
+}
+
+/** The CSV bytes handed to `deliverableAsset.upsert` for one asset key. */
+function csvFor(key: string): string {
+  const call = (prisma.deliverableAsset.upsert as jest.Mock).mock.calls.find(
+    (c) => c[0].where.siteId_key.key === key,
+  );
+  if (!call) throw new Error(`no asset upserted for key "${key}"`);
+  return (call[0].create.bytes as Buffer).toString("utf8");
+}
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  (sendDeliverableEmail as jest.Mock).mockResolvedValue({ ok: true, messageId: "msg-csv" });
+  process.env.DATABASE_URL = "postgres://test";
+  process.env.AILK_DELIVERABLE_EMAIL_FROM = "hello@ailk.test";
+  process.env.AILK_PUBLIC_API_URL = "https://api.test";
+});
+
+afterEach(() => {
+  delete process.env.AILK_DELIVERABLE_EMAIL_FROM;
+  delete process.env.AILK_PUBLIC_API_URL;
+});
+
+describe("runListingCsvSweep — two listings, one with new rows (#5001 AC4)", () => {
+  beforeEach(() => {
+    install({
+      listings: [ORBIT, LEDGER],
+      lastSends: {},
+      signups: { "orbit-notes": [SIGNUP_A, SIGNUP_B], "ledger-lite": [] },
+    });
+  });
+
+  it("sends exactly one email, for the listing that has signups", async () => {
+    const result = await runListingCsvSweep({ now: NOW });
+
+    expect(result).toEqual({
+      ok: true,
+      summary: { scanned: 2, sent: 1, skipped: 1, failed: 0 },
+    });
+    expect(sendDeliverableEmail).toHaveBeenCalledTimes(1);
+    expect((sendDeliverableEmail as jest.Mock).mock.calls[0][0]).toMatchObject({
+      to: "founder@orbit.example",
+      fromAddress: "hello@ailk.test",
+      subject: "Your Orbit Notes waitlist, week of 2026-09-07",
+      downloadLink: "https://api.test/v1/deliverables/dgrant_dasset_listing-orbit-notes-2026-09-07",
+    });
+  });
+
+  it("stores the CSV under `listing-{slug}-{yyyy-mm-dd}` as text/csv", async () => {
+    await runListingCsvSweep({ now: NOW });
+
+    const call = (prisma.deliverableAsset.upsert as jest.Mock).mock.calls[0][0];
+    expect(call.where).toEqual({
+      siteId_key: { siteId: SITE_ID, key: "listing-orbit-notes-2026-09-07" },
+    });
+    expect(call.create).toMatchObject({
+      siteId: SITE_ID,
+      contentType: "text/csv",
+      filename: "orbit-notes-waitlist-2026-09-07.csv",
+    });
+    expect(call.create.size).toBe((call.create.bytes as Buffer).byteLength);
+  });
+
+  it("grants the asset to the FOUNDER's own lead", async () => {
+    await runListingCsvSweep({ now: NOW });
+
+    expect(prisma.deliverableGrant.create).toHaveBeenCalledTimes(1);
+    expect((prisma.deliverableGrant.create as jest.Mock).mock.calls[0][0].data).toEqual({
+      siteId: SITE_ID,
+      assetId: "dasset_listing-orbit-notes-2026-09-07",
+      leadId: "lead_founder_orbit",
+      sessionId: "prjl_orbit",
+    });
+  });
+
+  it("writes the declared columns, one row per signup, in the founder's own wording", async () => {
+    await runListingCsvSweep({ now: NOW });
+
+    const lines = csvFor("listing-orbit-notes-2026-09-07").trimEnd().split("\n");
+    expect(lines[0]).toBe(LISTING_CSV_COLUMNS.join(","));
+    expect(lines).toHaveLength(3);
+    expect(lines[1]).toBe(
+      [
+        "2026-09-05T10:00:00.000Z",
+        "ada@example.com",
+        "Ada",
+        "now",
+        "I'm shipping something now",
+        "It's blocking me",
+        "Exactly it",
+        "Right away",
+        "Whatever it takes",
+        '"Ship it, please"', // quoted — the field carries the separator
+        "",
+        "",
+        "",
+      ].join(","),
+    );
+    expect(lines[2]).toContain("curious");
+    expect(lines[2]).toContain("Just curious");
+    expect(lines[2]).toContain("Not a problem");
+  });
+
+  it("stamps the send with its row count and grant", async () => {
+    await runListingCsvSweep({ now: NOW });
+
+    expect(prisma.listingCsvSend.create).toHaveBeenCalledTimes(1);
+    expect((prisma.listingCsvSend.create as jest.Mock).mock.calls[0][0].data).toEqual({
+      listingId: "prjl_orbit",
+      sentAt: NOW,
+      rowCount: 2,
+      grantId: "dgrant_dasset_listing-orbit-notes-2026-09-07",
+    });
+  });
+
+  it("writes nothing at all for the listing with no new signups", async () => {
+    await runListingCsvSweep({ now: NOW });
+
+    const assetKeys = (prisma.deliverableAsset.upsert as jest.Mock).mock.calls.map(
+      (c) => c[0].where.siteId_key.key,
+    );
+    expect(assetKeys).toEqual(["listing-orbit-notes-2026-09-07"]);
+    const stampedListings = (prisma.listingCsvSend.create as jest.Mock).mock.calls.map(
+      (c) => c[0].data.listingId,
+    );
+    expect(stampedListings).toEqual(["prjl_orbit"]);
+  });
+});
+
+describe("runListingCsvSweep — the watermark", () => {
+  it("a second run after a send sends nothing", async () => {
+    install({
+      listings: [ORBIT],
+      lastSends: {},
+      signups: { "orbit-notes": [SIGNUP_A, SIGNUP_B] },
+    });
+
+    const first = await runListingCsvSweep({ now: NOW });
+    expect(first).toEqual({ ok: true, summary: { scanned: 1, sent: 1, skipped: 0, failed: 0 } });
+
+    // The stamp the first run wrote is now the watermark.
+    const stamp = (prisma.listingCsvSend.create as jest.Mock).mock.calls[0][0].data;
+    jest.clearAllMocks();
+    install({
+      listings: [ORBIT],
+      lastSends: { prjl_orbit: stamp.sentAt as Date },
+      signups: { "orbit-notes": [SIGNUP_A, SIGNUP_B] },
+    });
+
+    const second = await runListingCsvSweep({ now: new Date("2026-09-14T09:00:00.000Z") });
+    expect(second).toEqual({ ok: true, summary: { scanned: 1, sent: 0, skipped: 1, failed: 0 } });
+    expect(sendDeliverableEmail).not.toHaveBeenCalled();
+    expect(prisma.listingCsvSend.create).not.toHaveBeenCalled();
+  });
+
+  it("carries only the signups newer than the last send", async () => {
+    install({
+      listings: [ORBIT],
+      // Between SIGNUP_A (Sep 5) and SIGNUP_B (Sep 6).
+      lastSends: { prjl_orbit: new Date("2026-09-05T12:00:00.000Z") },
+      signups: { "orbit-notes": [SIGNUP_A, SIGNUP_B] },
+    });
+
+    await runListingCsvSweep({ now: NOW });
+
+    const lines = csvFor("listing-orbit-notes-2026-09-07").trimEnd().split("\n");
+    expect(lines).toHaveLength(2);
+    expect(lines[1]).toContain("bo@example.com");
+    expect(lines[1]).not.toContain("ada@example.com");
+    expect((prisma.listingCsvSend.create as jest.Mock).mock.calls[0][0].data.rowCount).toBe(1);
+  });
+
+  it("leaves the watermark alone when the send fails, so next week keeps the rows", async () => {
+    install({
+      listings: [ORBIT],
+      lastSends: {},
+      signups: { "orbit-notes": [SIGNUP_A] },
+    });
+    (sendDeliverableEmail as jest.Mock).mockResolvedValue({
+      ok: false,
+      error: { kind: "send_failed", message: "resend is down" },
+    });
+
+    const result = await runListingCsvSweep({ now: NOW });
+
+    expect(result).toEqual({ ok: true, summary: { scanned: 1, sent: 0, skipped: 0, failed: 1 } });
+    expect(prisma.listingCsvSend.create).not.toHaveBeenCalled();
+  });
+});
+
+describe("runListingCsvSweep — isolation + guards", () => {
+  it("a failing listing does not block the next", async () => {
+    install({
+      listings: [ORBIT, LEDGER],
+      lastSends: {},
+      signups: { "orbit-notes": [SIGNUP_A], "ledger-lite": [SIGNUP_B] },
+    });
+    // The FIRST listing's asset write blows up; the second must still send.
+    (prisma.deliverableAsset.upsert as jest.Mock).mockImplementationOnce(async () => {
+      throw new Error("bytea write failed");
+    });
+
+    const result = await runListingCsvSweep({ now: NOW });
+
+    expect(result).toEqual({ ok: true, summary: { scanned: 2, sent: 1, skipped: 0, failed: 1 } });
+    expect(sendDeliverableEmail).toHaveBeenCalledTimes(1);
+    expect((sendDeliverableEmail as jest.Mock).mock.calls[0][0].to).toBe(
+      "founder@ledger.example",
+    );
+  });
+
+  it("skips a listing whose diagnostic has not been generated yet", async () => {
+    install({
+      listings: [{ ...ORBIT, experimentKey: null }],
+      lastSends: {},
+      signups: {},
+    });
+
+    const result = await runListingCsvSweep({ now: NOW });
+
+    expect(result).toEqual({ ok: true, summary: { scanned: 1, sent: 0, skipped: 1, failed: 0 } });
+    expect(sendDeliverableEmail).not.toHaveBeenCalled();
+  });
+
+  // A `draft` row carries no Lead, no slug and no name, and every application
+  // field is nullable at rest (#5036 D1). Such a row should never be `active`,
+  // but the CSV is a founder-facing send keyed on all three, so the sweep
+  // skips it rather than mailing a half-formed export.
+  it.each(["leadId", "slug", "name"])(
+    "skips a listing whose %s is null instead of exporting a half-formed CSV",
+    async (nulled) => {
+      install({
+        listings: [{ ...ORBIT, [nulled]: null }],
+        lastSends: {},
+        signups: { "orbit-notes": [SIGNUP_A] },
+      });
+
+      const result = await runListingCsvSweep({ now: NOW });
+
+      expect(result).toEqual({ ok: true, summary: { scanned: 1, sent: 0, skipped: 1, failed: 0 } });
+      expect(sendDeliverableEmail).not.toHaveBeenCalled();
+      expect(prisma.listingCsvSend.create).not.toHaveBeenCalled();
+    },
+  );
+
+  it("selects only `active` listings", async () => {
+    install({
+      listings: [],
+      lastSends: {},
+      signups: {},
+    });
+
+    await runListingCsvSweep({ now: NOW, siteId: SITE_ID });
+
+    expect((prisma.projectListing.findMany as jest.Mock).mock.calls[0][0].where).toEqual({
+      status: "active",
+      OR: [{ featured: true }, { windowEndsAt: { gt: NOW } }],
+      siteId: SITE_ID,
+    });
+  });
+
+  // #5033 — `closed` became a COMPUTED state, so the stored status alone is
+  // no longer the whole filter. This sweep mails a founder a CSV of their
+  // signups' answers; it must stop at the same moment the public read starts
+  // reading the listing as closed, or an expired listing keeps exporting
+  // signup data on every run forever. The migration also rewrites every
+  // historically `closed` row to `active` with a past window, so without this
+  // predicate the first run after deploy would re-enrol all of them.
+  //
+  // #5036 D6b narrowed the null-window arm. It used to be `windowEndsAt: null`
+  // — "a row with no window is still in scope". That is now true only of a
+  // FEATURED row, which is not a time-boxed experiment and never closes. A
+  // NON-featured active row with no window is a data error that
+  // `computeListingStatus` reads as `closed`, and this filter has to agree
+  // with it rather than keep mailing a founder's signup data out of a row
+  // nothing bounds.
+  it("excludes a listing whose window has elapsed, and keeps a FEATURED one with no window at all", async () => {
+    await runListingCsvSweep({ now: NOW, siteId: SITE_ID });
+
+    const { where } = (prisma.projectListing.findMany as jest.Mock).mock.calls[0][0];
+    expect(where.OR).toEqual([{ featured: true }, { windowEndsAt: { gt: NOW } }]);
+    // The old null-window arm would have re-enrolled every unbounded row.
+    expect(where.OR).not.toContainEqual({ windowEndsAt: null });
+  });
+
+  it("sends nothing, and stamps nothing, with no from-address configured", async () => {
+    delete process.env.AILK_DELIVERABLE_EMAIL_FROM;
+    delete process.env.AILK_LEAD_NOTIFICATION_FROM;
+    install({
+      listings: [ORBIT],
+      lastSends: {},
+      signups: { "orbit-notes": [SIGNUP_A] },
+    });
+
+    const result = await runListingCsvSweep({ now: NOW });
+
+    expect(result).toEqual({ ok: true, summary: { scanned: 1, sent: 0, skipped: 1, failed: 0 } });
+    expect(sendDeliverableEmail).not.toHaveBeenCalled();
+    expect(prisma.listingCsvSend.create).not.toHaveBeenCalled();
+  });
+
+  it("degrades to a structured error when the database is not configured", async () => {
+    delete process.env.DATABASE_URL;
+
+    const result = await runListingCsvSweep({ now: NOW });
+
+    expect(result).toEqual({
+      ok: false,
+      error: { kind: "flows_not_configured", message: "Flows are not configured." },
+    });
+  });
+});
+
+describe("runListingCsvSweep — CSV rendering", () => {
+  it("quotes separators and neutralises a spreadsheet formula in free text", async () => {
+    install({
+      listings: [ORBIT],
+      lastSends: {},
+      signups: {
+        "orbit-notes": [
+          {
+            ...SIGNUP_A,
+            state: {
+              ...SIGNUP_A.state,
+              name: 'Ada "The Shipper", Lovelace',
+              q7: "=HYPERLINK(\"https://evil.example\")",
+            },
+          },
+        ],
+      },
+    });
+
+    await runListingCsvSweep({ now: NOW });
+
+    const csv = csvFor("listing-orbit-notes-2026-09-07");
+    expect(csv).toContain('"Ada ""The Shipper"", Lovelace"');
+    expect(csv).toContain("'=HYPERLINK(");
+  });
+
+  it("leaves an unmapped answer value verbatim rather than blank", async () => {
+    install({
+      listings: [ORBIT],
+      lastSends: {},
+      signups: {
+        // A value the founder has since removed from their Q3 — no label
+        // maps it any more.
+        "orbit-notes": [{ ...SIGNUP_A, state: { ...SIGNUP_A.state, q3: "retired" } }],
+      },
+    });
+
+    await runListingCsvSweep({ now: NOW });
+
+    expect(csvFor("listing-orbit-notes-2026-09-07")).toContain("retired");
+  });
+});