create-ailk 0.1.0 → 0.2.0

package/templates/apps/api/src/services/__tests__/project-listing-flow.test.ts

@@ -0,0 +1,475 @@
+/**
+ * @file project-listing-flow.test.ts
+ * @description Unit tests for the approve-time projection (#5001 AC1/AC2/AC3):
+ * the template default's `questions` block becomes a `FlowDefinition` with the
+ * six-category step order and a live `WaitlistExperiment` keyed `{slug}`, the
+ * row's `experimentId` is written back, the thank-you shows the confirmation
+ * line and never the tier, and two different listings carry the same scoring
+ * RULE over their own option values (#5036 D4).
+ *
+ * The configs the projection builds are asserted against the REAL
+ * `flowConfigSchema` / `waitlistExperimentConfigSchema` as they arrive at the
+ * (mocked) Prisma upsert, so a projection that could not actually persist
+ * fails here rather than at approve time.
+ *
+ * External dependency boundaries mocked: @working-theory/database (auto-mock
+ * via `../../lib/__mocks__/prisma.ts`), plus the same
+ * `@working-theory/email` / `@working-theory/license` / `../aeo-score.js`
+ * boundary mocks `waitlist-experiments.test.ts` uses — this service composes
+ * `upsertFlowDefinition` from `flow-engine.ts`, whose import chain reaches all
+ * three.
+ */
+// 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", () => ({
+  sendLeadNotification: jest.fn().mockResolvedValue({ ok: true, messageId: "msg-test" }),
+  sendDeliverableEmail: jest.fn().mockResolvedValue({ ok: true, messageId: "msg-deliverable-test" }),
+}));
+
+jest.mock("@working-theory/license", () => ({
+  checkLicense: jest.fn().mockResolvedValue({
+    tier: "free",
+    plan: null,
+    features: [],
+    expiresAt: null,
+    revoked: false,
+  }),
+}));
+
+// eslint-disable-next-line no-restricted-syntax -- aeo-score.ts is a network boundary (external crawl), same class as the DB mock above
+jest.mock("../aeo-score.js", () => ({
+  scoreUrl: jest.fn(),
+  loadExampleScore: jest.fn(),
+  resolveScoreBudgetMs: () => 6000,
+}));
+
+import { buildListingDiagnosticScoring } from "@working-theory/database/flows/listing-diagnostic";
+import {
+  flowConfigSchema,
+  projectListingQuestionsSchema,
+  waitlistExperimentConfigSchema,
+  type FlowConfig,
+  type ProjectListingQuestions,
+} from "@working-theory/validation";
+
+import { prisma } from "../../lib/prisma.js";
+import {
+  generateListingFlow,
+  listingAnswerLabels,
+  listingWaitlistKey,
+  type ListingFlowSource,
+} from "../project-listing-flow";
+
+const SITE_ID = "site-abc";
+
+/**
+ * The template default (#4998's `projectListingQuestionsSchema`): Q2's
+ * founder options terminated by the fixed `just-curious` bail-out, Q3/Q4 at
+ * four founder options each, Q5's three fixed urgency values, Q6's four fixed
+ * bands, Q7 wording only, no extras.
+ */
+const TEMPLATE_DEFAULT: ProjectListingQuestions = projectListingQuestionsSchema.parse({
+  q2: {
+    prompt: "What brings you here?",
+    options: [
+      { value: "shipping-now", label: "I'm shipping something now" },
+      { value: "planning", label: "I'm planning a build" },
+      { value: "just-curious", label: "Just curious" },
+    ],
+  },
+  q3: {
+    prompt: "How painful is this problem today?",
+    options: [
+      { value: "none", label: "Not a problem" },
+      { value: "mild", label: "Mildly annoying" },
+      { value: "real", label: "A real drag" },
+      { value: "blocking", label: "It's blocking me" },
+    ],
+  },
+  q4: {
+    prompt: "How close is this to what you need?",
+    options: [
+      { value: "off", label: "Not what I need" },
+      { value: "adjacent", label: "Adjacent" },
+      { value: "close", label: "Close" },
+      { value: "exact", label: "Exactly it" },
+    ],
+  },
+  q5: {
+    prompt: "When would you use this?",
+    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 we should know?" },
+  extras: [],
+});
+
+function listing(overrides: Partial<ListingFlowSource> = {}): ListingFlowSource {
+  return {
+    id: "prjl_1",
+    siteId: SITE_ID,
+    slug: "orbit-notes",
+    name: "Orbit Notes",
+    oneLiner: "Meeting notes that file themselves.",
+    questions: TEMPLATE_DEFAULT,
+    ...overrides,
+  };
+}
+
+/** The `FlowConfig` handed to `flowDefinition.upsert`, as it was persisted. */
+function upsertedFlow(): FlowConfig {
+  const call = (prisma.flowDefinition.upsert as jest.Mock).mock.calls[0]?.[0];
+  return call.create.config as FlowConfig;
+}
+
+/** The experiment config handed to `waitlistExperiment.upsert`. */
+function upsertedExperiment(): Record<string, unknown> {
+  const call = (prisma.waitlistExperiment.upsert as jest.Mock).mock.calls[0]?.[0];
+  return call.create.config as Record<string, unknown>;
+}
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  process.env.DATABASE_URL = "postgres://test";
+  (prisma.flowDefinition.upsert as jest.Mock).mockResolvedValue({ id: "flow_1" });
+  (prisma.waitlistExperiment.upsert as jest.Mock).mockResolvedValue({ id: "wlexp_1" });
+  (prisma.projectListing.update as jest.Mock).mockResolvedValue({ id: "prjl_1" });
+});
+
+describe("generateListingFlow — the flow (#5001 AC1)", () => {
+  // #5036 D6d: the write-back is the experiment's KEY, and the key IS the
+  // listing's slug (`buildExperimentConfig`). Storing the id meant a reader
+  // going from a listing to its `WaitlistScore` rows had to fetch the
+  // experiment first purely to learn that key; storing the key is one hop and
+  // the same string on both sides of the join.
+  it("writes a servable flow, a live experiment, and the row's experimentKey", async () => {
+    const result = await generateListingFlow(listing());
+
+    expect(result).toEqual({
+      ok: true,
+      flowSlug: "orbit-notes",
+      experimentKey: "orbit-notes",
+    });
+    expect(prisma.projectListing.update).toHaveBeenCalledWith({
+      where: { id: "prjl_1" },
+      data: { experimentKey: "orbit-notes" },
+    });
+    expect(
+      (prisma.flowDefinition.upsert as jest.Mock).mock.calls[0]?.[0].where,
+    ).toEqual({ siteId_slug: { siteId: SITE_ID, slug: "orbit-notes" } });
+    expect(
+      (prisma.waitlistExperiment.upsert as jest.Mock).mock.calls[0]?.[0].where,
+    ).toEqual({ siteId_key: { siteId: SITE_ID, key: "orbit-notes" } });
+  });
+
+  it("declares the six-category step order, then the confirmation", async () => {
+    await generateListingFlow(listing());
+
+    expect(upsertedFlow().steps.map((s) => s.key)).toEqual([
+      "contact",
+      "segment",
+      "problem",
+      "fit",
+      "urgency",
+      "price",
+      "open",
+      "done",
+    ]);
+  });
+
+  it("appends an extras step only when the row carries extras", async () => {
+    const questions = projectListingQuestionsSchema.parse({
+      ...TEMPLATE_DEFAULT,
+      extras: [
+        {
+          prompt: "Which stack?",
+          options: [
+            { value: "a", label: "TypeScript" },
+            { value: "b", label: "Python" },
+          ],
+        },
+      ],
+    });
+
+    await generateListingFlow(listing({ questions }));
+
+    const steps = upsertedFlow().steps;
+    expect(steps.map((s) => s.key)).toEqual([
+      "contact",
+      "segment",
+      "problem",
+      "fit",
+      "urgency",
+      "price",
+      "open",
+      "extras",
+      "done",
+    ]);
+    const extras = steps.find((s) => s.key === "extras");
+    expect(extras?.type).toBe("field");
+    if (extras?.type !== "field") throw new Error("extras step must be a field step");
+    expect(extras.fields.map((f) => f.name)).toEqual(["extra_1"]);
+    expect(extras.fields[0]?.options?.map((o) => o.value)).toEqual(["x1:0of2", "x1:1of2"]);
+  });
+
+  it("renders a scored question under the founder's OWN values, in order (#5036 D4)", async () => {
+    await generateListingFlow(listing());
+
+    const problem = upsertedFlow().steps.find((s) => s.key === "problem");
+    if (problem?.type !== "field") throw new Error("problem step must be a field step");
+    expect(problem.fields[0]?.options).toEqual([
+      { value: "none", label: { en: "Not a problem" } },
+      { value: "mild", label: { en: "Mildly annoying" } },
+      { value: "real", label: { en: "A real drag" } },
+      { value: "blocking", label: { en: "It's blocking me" } },
+    ]);
+  });
+
+  it("keeps Q2's founder values and pins `just-curious` LAST", async () => {
+    await generateListingFlow(listing());
+
+    const segment = upsertedFlow().steps.find((s) => s.key === "segment");
+    if (segment?.type !== "field") throw new Error("segment step must be a field step");
+    const values = segment.fields[0]?.options?.map((o) => o.value) ?? [];
+    expect(values).toEqual(["shipping-now", "planning", "just-curious"]);
+    expect(values[values.length - 1]).toBe("just-curious");
+  });
+
+  it("makes Q7 an optional textarea", async () => {
+    await generateListingFlow(listing());
+
+    const open = upsertedFlow().steps.find((s) => s.key === "open");
+    if (open?.type !== "field") throw new Error("open step must be a field step");
+    expect(open.fields[0]?.inputType).toBe("textarea");
+    expect(open.fields[0]?.required).toBeUndefined();
+  });
+
+  it("binds the flow to its experiment so completion scores", async () => {
+    await generateListingFlow(listing());
+
+    expect(upsertedFlow().experiment).toEqual({
+      key: "orbit-notes",
+      waitlist: "listing_orbit_notes",
+    });
+  });
+
+  it("persists a config that validates against flowConfigSchema", async () => {
+    await generateListingFlow(listing());
+
+    expect(flowConfigSchema.safeParse(upsertedFlow()).success).toBe(true);
+  });
+});
+
+describe("generateListingFlow — the thank-you (#5001 AC2)", () => {
+  it("shows the confirmation line and the founder's own line, never the tier", async () => {
+    await generateListingFlow(listing());
+
+    const flow = upsertedFlow();
+    const done = flow.steps[flow.steps.length - 1];
+    expect(done?.type).toBe("message");
+    expect(done?.copy).toEqual({
+      title: { en: "You're on the Orbit Notes waitlist" },
+      body: { en: "Meeting notes that file themselves." },
+    });
+
+    // No tier vocabulary anywhere on the visitor's path, and no thankYou /
+    // deliverables block that could route one in.
+    const serialized = JSON.stringify(flow);
+    for (const tier of ["now", "soon", "later", "curious"]) {
+      expect(serialized).not.toContain(`"${tier}"`);
+    }
+    expect(flow.thankYou).toBeUndefined();
+    expect(flow.deliverables).toBeUndefined();
+    expect(flow.scoring).toBeUndefined();
+  });
+
+  it("omits the body when the founder's line is blank", async () => {
+    await generateListingFlow(listing({ oneLiner: "   " }));
+
+    const flow = upsertedFlow();
+    const done = flow.steps[flow.steps.length - 1];
+    expect(done?.copy).toEqual({ title: { en: "You're on the Orbit Notes waitlist" } });
+  });
+});
+
+describe("generateListingFlow — the experiment (#5001 AC1/AC3)", () => {
+  it("is a live, qualifying experiment keyed by the listing slug", async () => {
+    await generateListingFlow(listing());
+
+    const config = upsertedExperiment();
+    expect(config.key).toBe("orbit-notes");
+    expect(config.mode).toBe("qualifying");
+    expect(config.status).toBe("live");
+    expect(config.waitlists).toEqual([
+      { key: "listing_orbit_notes", flowSlug: "orbit-notes" },
+    ]);
+  });
+
+  it("carries the register the shared rule builds for THIS listing", async () => {
+    await generateListingFlow(listing());
+
+    // Deep, not identity: `upsertWaitlistExperiment` persists Zod's parsed
+    // clone, so the register arrives as a structural copy of what
+    // `buildListingDiagnosticScoring` returns for this row's questions.
+    expect(upsertedExperiment().scoring).toEqual(
+      buildListingDiagnosticScoring(TEMPLATE_DEFAULT),
+    );
+  });
+
+  it("declares each scored question's OWN options in the question set (#5036 D4)", async () => {
+    await generateListingFlow(listing());
+
+    const questionSet = upsertedExperiment().questionSet as {
+      questions: { id: string; options?: { value: string }[] }[];
+    };
+    const q3 = questionSet.questions.find((q) => q.id === "q3");
+    expect(q3?.options?.map((o) => o.value)).toEqual(["none", "mild", "real", "blocking"]);
+
+    // Which is what makes the weights keys legal at the config level — the
+    // finite `q{n}:{i}of{k}` value universe the old shared constant forced
+    // the question set to declare is gone.
+    const scoring = upsertedExperiment().scoring as {
+      points: { question: string; weights: Record<string, number> }[];
+    };
+    expect(scoring.points.find((p) => p.question === "q3")?.weights).toEqual({
+      none: 0,
+      mild: 1,
+      real: 2,
+      blocking: 3,
+    });
+  });
+
+  it("persists a config that validates against waitlistExperimentConfigSchema", async () => {
+    await generateListingFlow(listing());
+
+    const parsed = waitlistExperimentConfigSchema.safeParse(upsertedExperiment());
+    expect(parsed.success).toBe(true);
+  });
+
+  it("gives two DIFFERENT listings the same scoring RULE (AC3, #5036 D4)", async () => {
+    await generateListingFlow(listing());
+    const first = upsertedExperiment().scoring as Record<string, unknown>;
+
+    jest.clearAllMocks();
+    (prisma.flowDefinition.upsert as jest.Mock).mockResolvedValue({ id: "flow_2" });
+    (prisma.waitlistExperiment.upsert as jest.Mock).mockResolvedValue({ id: "wlexp_2" });
+    (prisma.projectListing.update as jest.Mock).mockResolvedValue({ id: "prjl_2" });
+
+    // A second listing with DIFFERENT wording AND a different Q3 arity.
+    const otherQuestions = projectListingQuestionsSchema.parse({
+      ...TEMPLATE_DEFAULT,
+      q3: {
+        prompt: "How badly does this hurt?",
+        options: [
+          { value: "x", label: "Not at all" },
+          { value: "y", label: "Somewhat" },
+          { value: "z", label: "Badly" },
+        ],
+      },
+    });
+    await generateListingFlow(
+      listing({ id: "prjl_2", slug: "ledger-lite", name: "Ledger Lite", questions: otherQuestions }),
+    );
+
+    const second = upsertedExperiment().scoring as Record<string, unknown>;
+
+    // Same shape, same ladder, same 0-12 range — only the founder-authored
+    // Q3/Q4 weight KEYS differ, because since #5036 D4 those keys are the
+    // founder's own option values rather than positional tokens.
+    expect(second.scores).toEqual(first.scores);
+    expect(second.tiers).toEqual(first.tiers);
+    expect(second.default).toEqual(first.default);
+    const names = (s: Record<string, unknown>) =>
+      (s.points as { name: string }[]).map((p) => p.name);
+    expect(names(second)).toEqual(names(first));
+    const weights = (s: Record<string, unknown>, question: string) =>
+      (s.points as { question: string; weights: Record<string, number> }[]).find(
+        (p) => p.question === question,
+      )?.weights;
+    expect(weights(second, "q5")).toEqual(weights(first, "q5"));
+    expect(weights(second, "q6")).toEqual(weights(first, "q6"));
+    expect(weights(second, "q3")).toEqual({ x: 0, y: 2, z: 3 });
+    expect(weights(second, "q3")).not.toEqual(weights(first, "q3"));
+  });
+});
+
+describe("generateListingFlow — idempotency + failure", () => {
+  it("re-approving upserts the same keys and rewrites the same experimentKey", async () => {
+    await generateListingFlow(listing());
+    await generateListingFlow(listing());
+
+    const flowCalls = (prisma.flowDefinition.upsert as jest.Mock).mock.calls;
+    const experimentCalls = (prisma.waitlistExperiment.upsert as jest.Mock).mock.calls;
+    expect(flowCalls).toHaveLength(2);
+    expect(flowCalls[0]?.[0]).toEqual(flowCalls[1]?.[0]);
+    expect(experimentCalls[0]?.[0]).toEqual(experimentCalls[1]?.[0]);
+    expect(prisma.projectListing.update).toHaveBeenNthCalledWith(2, {
+      where: { id: "prjl_1" },
+      data: { experimentKey: "orbit-notes" },
+    });
+  });
+
+  it("refuses a slug the flow grammar rejects, and writes nothing", async () => {
+    // A listing slug may carry a doubled hyphen (#4998's `^[a-z0-9-]{3,48}$`);
+    // `flowSlugSchema` may not.
+    const result = await generateListingFlow(listing({ slug: "orbit--notes" }));
+
+    expect(result.ok).toBe(false);
+    if (result.ok) throw new Error("expected a rejected slug");
+    expect(result.error.kind).toBe("invalid_input");
+    expect(prisma.waitlistExperiment.upsert).not.toHaveBeenCalled();
+    expect(prisma.projectListing.update).not.toHaveBeenCalled();
+  });
+});
+
+describe("listingWaitlistKey", () => {
+  it("prefixes so a digit-leading slug still yields a legal identifier", () => {
+    expect(listingWaitlistKey("3d-printer")).toBe("listing_3d_printer");
+  });
+});
+
+describe("listingAnswerLabels — the CSV's inverse", () => {
+  it("maps every emitted value back to the founder's own wording", () => {
+    const labels = listingAnswerLabels(TEMPLATE_DEFAULT);
+
+    // Q2-Q6 are all plain value->label now: the flow renders the founder's
+    // own values, so the inverse is their own option list read backwards.
+    expect(labels.q3?.blocking).toBe("It's blocking me");
+    expect(labels.q5?.urgent).toBe("Right away");
+    expect(labels.q6?.critical).toBe("Whatever it takes");
+    expect(labels.q2?.["just-curious"]).toBe("Just curious");
+  });
+
+  it("keeps the positional encoding for the unscored extras", () => {
+    const questions = projectListingQuestionsSchema.parse({
+      ...TEMPLATE_DEFAULT,
+      extras: [
+        {
+          prompt: "Which stack?",
+          options: [
+            { value: "a", label: "TypeScript" },
+            { value: "b", label: "Python" },
+          ],
+        },
+      ],
+    });
+
+    expect(listingAnswerLabels(questions).extra_1).toEqual({
+      "x1:0of2": "TypeScript",
+      "x1:1of2": "Python",
+    });
+  });
+});