create-ailk 0.15.0 → 0.17.0

package/templates/apps/api/src/services/__tests__/lead-routing.test.ts

@@ -33,8 +33,12 @@ import * as fs from "fs/promises";
 import * as os from "os";
 import * as path from "path";
 
+import { logger } from "@working-theory/observability";
+
+import { MOCK_PERSON_ID } from "../../lib/__mocks__/prisma.js";
 import { prisma } from "../../lib/prisma.js";
 import { routeLead } from "../lead-routing";
+import * as personService from "../person";
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 const sourceMeta = {
@@ -946,3 +950,292 @@ describe("#7869 — routeLead with an idempotency key", () => {
     expect(result).toMatchObject({ ok: true, persisted: "file" });
   });
 });
+
+// ─── #852 D6 — every submitted lead carries its Person ──────────────────────
+//
+// The Person step runs through the shared mock's `person` delegate, whose
+// `findFirst` default resolves one fixed Person (`MOCK_PERSON_ID`). Lead
+// capture is a never-gate surface: an unstorable address or a failed step
+// writes the lead with `personId: null` and changes nothing else.
+describe("#852 — the lead's Person (AC-3)", () => {
+  const ENV_KEYS = [
+    "DATABASE_URL",
+    "NODE_ENV",
+    "AILK_LEAD_NOTIFICATION_TO",
+    "AILK_LEAD_NOTIFICATION_FROM",
+  ] as const;
+  let saved: Partial<Record<(typeof ENV_KEYS)[number], string | undefined>>;
+  const LEAD_ID = "lead_00000000-0000-7000-8000-000000000852";
+  const createData = () =>
+    jest.mocked(prisma.lead.create).mock.calls[0]?.[0].data as Record<string, unknown>;
+  const personDelegate = () => ({
+    findFirst: jest.mocked(prisma.person.findFirst),
+    createMany: jest.mocked(prisma.person.createMany),
+    updateMany: jest.mocked(prisma.person.updateMany),
+  });
+  const personCalls = () =>
+    Object.values(personDelegate()).reduce((n, fn) => n + fn.mock.calls.length, 0);
+  let warn: jest.SpyInstance;
+  let error: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    saved = {};
+    for (const k of ENV_KEYS) saved[k] = process.env[k];
+    process.env.DATABASE_URL = "postgres://stub";
+    delete process.env.NODE_ENV;
+    process.env.AILK_LEAD_NOTIFICATION_TO = "owner@example.com";
+    process.env.AILK_LEAD_NOTIFICATION_FROM = "noreply@example.com";
+    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: LEAD_ID });
+    mockSendLeadNotification.mockResolvedValue({ ok: true, messageId: "msg-852" });
+    warn = jest.spyOn(logger, "warn").mockImplementation(() => undefined as never);
+    error = jest.spyOn(logger, "error").mockImplementation(() => undefined as never);
+  });
+
+  afterEach(() => {
+    for (const k of ENV_KEYS) {
+      if (saved[k] === undefined) delete process.env[k];
+      else process.env[k] = saved[k];
+    }
+    warn.mockRestore();
+    error.mockRestore();
+  });
+
+  it("a submit writes the Person findOrCreatePerson returned for (siteId, email)", async () => {
+    const result = await routeLead(
+      { ...leadInput, email: "Test@Example.com", payload: { name: "Tess", message: "hi" } },
+      sourceMeta,
+    );
+
+    expect(result).toMatchObject({ ok: true, id: LEAD_ID, persisted: "db" });
+    expect(personDelegate()["findFirst"]).toHaveBeenCalledWith(
+      expect.objectContaining({ where: { workspaceId: "site-abc", email: "test@example.com" } }),
+    );
+    expect(createData()).toEqual(expect.objectContaining({ personId: MOCK_PERSON_ID }));
+  });
+
+  it("subscribe and callback make no person call", async () => {
+    (prisma.subscriber.create as jest.Mock).mockResolvedValue({ id: "subscr_x" });
+    (prisma.callback.create as jest.Mock).mockResolvedValue({ id: "callbk_x" });
+    await routeLead(subscribeInput, sourceMeta);
+    await routeLead(callbackInput, sourceMeta);
+    expect(personCalls()).toBe(0);
+  });
+
+  it("an invalid_email Person result writes the lead with personId: null and one person-skipped warn with no email", async () => {
+    // `leadInputSchema`'s email check refuses most unstorable addresses before
+    // this step, so the Person result is stubbed to reach the branch.
+    jest
+      .spyOn(personService, "findOrCreatePerson")
+      .mockResolvedValueOnce({ ok: false, error: { kind: "invalid_email" } });
+    const result = await routeLead(leadInput, sourceMeta);
+
+    expect(result).toMatchObject({ ok: true, id: LEAD_ID, persisted: "db" });
+    expect(createData()).toEqual(expect.objectContaining({ personId: null }));
+    const skipped = warn.mock.calls.filter(([fields]) => (fields as { event?: string }).event === "person-skipped");
+    expect(skipped).toHaveLength(1);
+    expect(skipped[0]![0]).toEqual({ event: "person-skipped", kind: "invalid_email", siteId: "site-abc" });
+    expect(JSON.stringify(warn.mock.calls)).not.toContain("example.com");
+  });
+
+  it("an internal_error Person result is the same never-gate path as a throwing delegate", async () => {
+    jest
+      .spyOn(personService, "findOrCreatePerson")
+      .mockResolvedValueOnce({ ok: false, error: { kind: "internal_error" } });
+    const result = await routeLead(leadInput, sourceMeta);
+
+    expect(result).toMatchObject({ ok: true, id: LEAD_ID, persisted: "db" });
+    expect(createData()).toEqual(expect.objectContaining({ personId: null }));
+    expect(error.mock.calls.map(([fields]) => fields)).toContainEqual({
+      event: "person-failed",
+      siteId: "site-abc",
+    });
+  });
+
+  it("a Person step that fails writes the lead with personId: null, logs person-failed with no email, and answers like a successful capture", async () => {
+    const ok = await routeLead(leadInput, sourceMeta);
+    jest.mocked(prisma.lead.create).mockClear();
+    mockSendLeadNotification.mockClear();
+    personDelegate()["findFirst"]!.mockRejectedValueOnce(new Error("relation \"people\" does not exist"));
+
+    const failed = await routeLead(leadInput, sourceMeta);
+
+    expect(failed).toEqual(ok);
+    expect(failed).toMatchObject({ ok: true, id: LEAD_ID, persisted: "db", email: { ok: true } });
+    expect(createData()).toEqual(expect.objectContaining({ personId: null }));
+    const lines = error.mock.calls.filter(([fields]) => (fields as { event?: string }).event === "person-failed");
+    expect(lines).toHaveLength(1);
+    expect(lines[0]![0]).toEqual({ event: "person-failed", siteId: "site-abc" });
+    expect(JSON.stringify(error.mock.calls)).not.toContain("test@example.com");
+  });
+});
+
+// ─── #7877 D10 — a spoke's checkout lead sets the Person's plan (AC-5) ──────
+//
+// The plan step runs only after this request's own `lead.create`, for a LIVE,
+// paid checkout lead a registered spoke's server posted with the session id
+// as its key. Every other lead makes no plan call; a failing plan step never
+// changes the lead's result.
+describe("#7877 — the checkout lead sets the plan (AC-5)", () => {
+  const ENV_KEYS = [
+    "DATABASE_URL",
+    "NODE_ENV",
+    "AILK_LEAD_NOTIFICATION_TO",
+    "AILK_LEAD_NOTIFICATION_FROM",
+  ] as const;
+  let saved: Partial<Record<(typeof ENV_KEYS)[number], string | undefined>>;
+  const LEAD_ID = "lead_00000000-0000-7000-8000-000000007877";
+  const WS = "wksp_00000000-0000-7000-8000-000000007877";
+  const KEY = "cs_live_a1B2c3"; // gitleaks:allow -- a synthetic Checkout Session id shape (#7877 AC-5), not a credential
+  const spokeMeta = { ...sourceMeta, viaSpoke: true };
+  const checkoutLead = {
+    kind: "submit" as const,
+    siteId: WS,
+    source: "web",
+    email: "cleo@x.io",
+    payload: { site: "wendi", page: "checkout", offering: "wendi_retainer" } as Record<string, unknown>,
+  };
+  let setPlan: jest.SpyInstance;
+  let info: jest.SpyInstance;
+  let error: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    saved = {};
+    for (const k of ENV_KEYS) saved[k] = process.env[k];
+    process.env.DATABASE_URL = "postgres://stub";
+    delete process.env.NODE_ENV;
+    process.env.AILK_LEAD_NOTIFICATION_TO = "owner@example.com";
+    process.env.AILK_LEAD_NOTIFICATION_FROM = "noreply@example.com";
+    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: LEAD_ID });
+    (prisma.lead.findUnique as jest.Mock).mockResolvedValue(null);
+    mockSendLeadNotification.mockResolvedValue({ ok: true, messageId: "msg-7877" });
+    setPlan = jest.spyOn(personService, "setPersonPlanOffering").mockResolvedValue("set");
+    info = jest.spyOn(logger, "info").mockImplementation(() => undefined as never);
+    error = jest.spyOn(logger, "error").mockImplementation(() => undefined as never);
+  });
+
+  afterEach(() => {
+    for (const k of ENV_KEYS) {
+      if (saved[k] === undefined) delete process.env[k];
+      else process.env[k] = saved[k];
+    }
+    setPlan.mockRestore();
+    info.mockRestore();
+    error.mockRestore();
+  });
+
+  const planLines = () =>
+    [...info.mock.calls, ...error.mock.calls]
+      .map(([fields]) => fields as Record<string, unknown>)
+      .filter((fields) => fields.event === "checkout-plan");
+
+  it("a live spoke checkout lead sets the plan to the offering minus the <site>_ prefix", async () => {
+    const result = await routeLead(checkoutLead, spokeMeta, { idempotencyKey: KEY });
+    expect(result).toMatchObject({ ok: true, id: LEAD_ID, persisted: "db" });
+    expect(setPlan).toHaveBeenCalledTimes(1);
+    expect(setPlan).toHaveBeenCalledWith(WS, MOCK_PERSON_ID, "retainer");
+    expect(planLines()).toEqual([{ event: "checkout-plan", outcome: "set", siteId: WS }]);
+  });
+
+  it("a bare slug offering is taken as it is", async () => {
+    await routeLead(
+      { ...checkoutLead, payload: { ...checkoutLead.payload, offering: "retainer" } },
+      spokeMeta,
+      { idempotencyKey: KEY },
+    );
+    expect(setPlan).toHaveBeenCalledWith(WS, MOCK_PERSON_ID, "retainer");
+  });
+
+  it("a positive integer amountTotal still qualifies", async () => {
+    await routeLead(
+      { ...checkoutLead, payload: { ...checkoutLead.payload, amountTotal: 4900 } },
+      spokeMeta,
+      { idempotencyKey: KEY },
+    );
+    expect(setPlan).toHaveBeenCalledTimes(1);
+  });
+
+  it.each([
+    ["an anonymous lead (viaSpoke false)", checkoutLead, sourceMeta, KEY],
+    ["a test-mode session key", checkoutLead, spokeMeta, "cs_test_a1B2c3"],
+    [
+      "amountTotal 0",
+      { ...checkoutLead, payload: { ...checkoutLead.payload, amountTotal: 0 } },
+      spokeMeta,
+      KEY,
+    ],
+    [
+      "a negative amountTotal",
+      { ...checkoutLead, payload: { ...checkoutLead.payload, amountTotal: -5 } },
+      spokeMeta,
+      KEY,
+    ],
+    ["a key that is not a session id", checkoutLead, spokeMeta, "abcdefghijklmnop"],
+    ["no key", checkoutLead, spokeMeta, undefined],
+    ["source contact", { ...checkoutLead, source: "contact" }, spokeMeta, KEY],
+    [
+      "page contact",
+      { ...checkoutLead, payload: { ...checkoutLead.payload, page: "contact" } },
+      spokeMeta,
+      KEY,
+    ],
+    [
+      "a numeric offering",
+      { ...checkoutLead, payload: { ...checkoutLead.payload, offering: 42 } },
+      spokeMeta,
+      KEY,
+    ],
+  ] as const)("no plan call for %s", async (_label, input, meta, key) => {
+    const result = await routeLead(
+      input as typeof checkoutLead,
+      meta,
+      key === undefined ? {} : { idempotencyKey: key },
+    );
+    expect(result).toMatchObject({ ok: true, persisted: "db" });
+    expect(setPlan).not.toHaveBeenCalled();
+    expect(jest.mocked(prisma.person.updateMany)).not.toHaveBeenCalled();
+    expect(planLines()).toEqual([]);
+  });
+
+  it("an offering that is not a key after the strip logs skipped and makes no plan call", async () => {
+    await routeLead(
+      { ...checkoutLead, payload: { ...checkoutLead.payload, offering: "Wendi_Retainer!" } },
+      spokeMeta,
+      { idempotencyKey: KEY },
+    );
+    expect(setPlan).not.toHaveBeenCalled();
+    expect(planLines()).toEqual([{ event: "checkout-plan", outcome: "skipped", siteId: WS }]);
+  });
+
+  it("a replayed key writes nothing and sets nothing", async () => {
+    (prisma.lead.findUnique as jest.Mock).mockResolvedValue({
+      id: LEAD_ID,
+      email: checkoutLead.email,
+      source: checkoutLead.source,
+      payload: checkoutLead.payload,
+    });
+    const result = await routeLead(checkoutLead, spokeMeta, { idempotencyKey: KEY });
+    expect(result).toMatchObject({ ok: true, replayed: true, id: LEAD_ID });
+    expect(prisma.lead.create).not.toHaveBeenCalled();
+    expect(setPlan).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    ["throws", () => setPlan.mockRejectedValueOnce(new Error("down"))],
+    ["answers not_found", () => setPlan.mockResolvedValueOnce("not_found")],
+  ])("a plan step that %s answers exactly like a success, with one failed line naming no offering, email or key", async (_label, arrange) => {
+    const ok = await routeLead(checkoutLead, spokeMeta, { idempotencyKey: KEY });
+    info.mockClear();
+    error.mockClear();
+    arrange();
+    const failed = await routeLead(checkoutLead, spokeMeta, { idempotencyKey: KEY });
+    expect(failed).toEqual(ok);
+    expect(failed).toMatchObject({ ok: true, id: LEAD_ID, persisted: "db" });
+    expect(planLines()).toEqual([{ event: "checkout-plan", outcome: "failed", siteId: WS }]);
+    const logged = JSON.stringify([...info.mock.calls, ...error.mock.calls]);
+    expect(logged).not.toContain("retainer");
+    expect(logged).not.toContain("cleo@x.io");
+    expect(logged).not.toContain(KEY);
+  });
+});