create-ailk 0.1.0 → 0.2.0

package/templates/apps/api/src/services/__tests__/deliverable-resend.test.ts

@@ -0,0 +1,359 @@
+/**
+ * @file deliverable-resend.test.ts
+ * @description Unit tests for the deliverable-fulfillment service's resend
+ * (#3998 D3/D4) surface: `resendDeliverableGrant` and `listSendlessGrants`.
+ * The CLI entry (`src/bin/deliverable-resend.ts`) is a thin, coverage-ignored
+ * wrapper over these two functions — this file is where the logic is
+ * actually exercised, through the same mocked-prisma double the fulfillment
+ * service tests use.
+ *
+ * External dependency boundaries mocked:
+ *   - @working-theory/database (via moduleNameMapper → prisma-client.js mock; prisma singleton via __mocks__/prisma.ts)
+ *   - @working-theory/email sendDeliverableEmail
+ *   - @working-theory/observability logger
+ */
+
+// 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");
+
+const mockSendDeliverableEmail = jest.fn();
+jest.mock("@working-theory/email", () => ({
+  sendDeliverableEmail: (...args: unknown[]) =>
+    mockSendDeliverableEmail(...args),
+}));
+
+const mockLoggerInfo = jest.fn();
+const mockLoggerWarn = jest.fn();
+const mockLoggerError = jest.fn();
+jest.mock("@working-theory/observability", () => ({
+  logger: {
+    info: (...args: unknown[]) => mockLoggerInfo(...args),
+    warn: (...args: unknown[]) => mockLoggerWarn(...args),
+    error: (...args: unknown[]) => mockLoggerError(...args),
+    debug: jest.fn(),
+  },
+}));
+
+import { prisma } from "../../lib/prisma.js";
+import {
+  listSendlessGrants,
+  resendDeliverableGrant,
+} from "../deliverable-fulfillment";
+
+// ─── Fixtures ─────────────────────────────────────────────────────────────────
+
+const en = (s: string) => ({ en: s });
+
+const SITE_ID = "site-abc";
+const SESSION_ID = "flsess_00000000-0000-7000-8000-0000000000c1";
+const LEAD_ID = "lead_00000000-0000-7000-8000-0000000000e1";
+const GRANT_ID = "dgrant_00000000-0000-7000-8000-0000000000g1";
+
+function deliverablesBlock() {
+  return {
+    assets: [{ assetKey: "guide-default" }],
+    copy: {
+      subject: en("Here's your guide"),
+      body: en("Thanks — your download is attached."),
+    },
+  };
+}
+
+// A resend re-parses the pinned snapshot through flowConfigSchema (D3), so —
+// unlike the fulfillment tests, which never re-validate the whole config —
+// this fixture must be a genuinely SCHEMA-VALID flow (steps.min(1) et al.),
+// not just a `deliverables`-block-shaped object.
+function baseConfigSnapshot() {
+  return {
+    slug: "get-a-quote",
+    defaultLocale: "en",
+    steps: [
+      {
+        key: "thanks",
+        type: "message" as const,
+        copy: { title: en("Thanks!"), body: en("We'll be in touch.") },
+      },
+    ],
+    deliverables: deliverablesBlock(),
+  };
+}
+
+function grantRow(overrides: Record<string, unknown> = {}) {
+  return {
+    id: GRANT_ID,
+    siteId: SITE_ID,
+    assetId: "dasset_00000000-0000-7000-8000-0000000000a1",
+    leadId: LEAD_ID,
+    sessionId: SESSION_ID,
+    ...overrides,
+  };
+}
+
+function leadRow(overrides: Record<string, unknown> = {}) {
+  return { email: "lead@example.com", ...overrides };
+}
+
+function sessionRow(overrides: Record<string, unknown> = {}) {
+  return {
+    flowSlug: "get-a-quote",
+    configSnapshot: baseConfigSnapshot(),
+    locale: "en",
+    ...overrides,
+  };
+}
+
+describe("resendDeliverableGrant", () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    process.env = {
+      ...originalEnv,
+      AILK_PUBLIC_API_URL: "https://api.example.com",
+      AILK_DELIVERABLE_EMAIL_FROM: "deliverable-default@example.com",
+    };
+    mockSendDeliverableEmail.mockResolvedValue({
+      ok: true,
+      messageId: "msg-test",
+    });
+    (prisma.deliverableGrant.findUnique as jest.Mock).mockResolvedValue(
+      grantRow(),
+    );
+    (prisma.lead.findUnique as jest.Mock).mockResolvedValue(leadRow());
+    (prisma.flowSession.findUnique as jest.Mock).mockResolvedValue(
+      sessionRow(),
+    );
+    (prisma.deliverableGrant.update as jest.Mock).mockResolvedValue({
+      id: GRANT_ID,
+    });
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  // ── D3 — resends a known grant ───────────────────────────────────────────
+
+  it("resolves lead email + session snapshot, sends, and stamps 'sent'", async () => {
+    const result = await resendDeliverableGrant(GRANT_ID);
+
+    expect(result).toEqual({ ok: true, outcome: "sent" });
+    expect(mockSendDeliverableEmail).toHaveBeenCalledWith(
+      expect.objectContaining({ to: "lead@example.com" }),
+    );
+    expect(prisma.deliverableGrant.update).toHaveBeenCalledWith({
+      where: { id: GRANT_ID },
+      data: { sendStatus: "sent", sendAt: expect.any(Date) },
+    });
+  });
+
+  // ── AC3 — never mints ─────────────────────────────────────────────────────
+
+  it("never calls deliverableGrant.create (AC3)", async () => {
+    await resendDeliverableGrant(GRANT_ID);
+
+    expect(prisma.deliverableGrant.create).not.toHaveBeenCalled();
+  });
+
+  it("builds a link byte-identical to the fulfillment path (AC3)", async () => {
+    await resendDeliverableGrant(GRANT_ID);
+
+    const [call] = mockSendDeliverableEmail.mock.calls;
+    expect(call[0].downloadLink).toBe(
+      `https://api.example.com/v1/deliverables/${GRANT_ID}`,
+    );
+  });
+
+  // ── Unknown grant id ──────────────────────────────────────────────────────
+
+  it("reports grant_not_found and sends nothing for an unknown grant id", async () => {
+    (prisma.deliverableGrant.findUnique as jest.Mock).mockResolvedValue(null);
+
+    const result = await resendDeliverableGrant("dgrant_does-not-exist");
+
+    expect(result).toEqual({
+      ok: false,
+      error: { kind: "grant_not_found", message: expect.any(String) },
+    });
+    expect(mockSendDeliverableEmail).not.toHaveBeenCalled();
+  });
+
+  // ── AC6 — pinned configSnapshot, unparseable → reported, no throw ────────
+
+  it("reports invalid_config_snapshot and sends nothing when the snapshot no longer parses (AC6)", async () => {
+    (prisma.flowSession.findUnique as jest.Mock).mockResolvedValue(
+      sessionRow({ configSnapshot: { not: "a valid flow config" } }),
+    );
+
+    const result = await resendDeliverableGrant(GRANT_ID);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.kind).toBe("invalid_config_snapshot");
+    }
+    expect(mockSendDeliverableEmail).not.toHaveBeenCalled();
+  });
+
+  it("does not throw when the snapshot is unparseable (AC6)", async () => {
+    (prisma.flowSession.findUnique as jest.Mock).mockResolvedValue(
+      sessionRow({ configSnapshot: null }),
+    );
+
+    await expect(resendDeliverableGrant(GRANT_ID)).resolves.toEqual(
+      expect.objectContaining({ ok: false }),
+    );
+  });
+
+  // ── AC6 — reads the session's PINNED config, not a live lookup ──────────
+
+  it("resolves copy at the session's stored locale", async () => {
+    const twoLocaleConfig = {
+      ...baseConfigSnapshot(),
+      deliverables: {
+        assets: [{ assetKey: "guide-default" }],
+        copy: {
+          subject: { en: "EN subject", "pt-BR": "PT subject" },
+          body: { en: "EN body", "pt-BR": "PT body" },
+        },
+      },
+    };
+    (prisma.flowSession.findUnique as jest.Mock).mockResolvedValue(
+      sessionRow({ locale: "pt-BR", configSnapshot: twoLocaleConfig }),
+    );
+
+    await resendDeliverableGrant(GRANT_ID);
+
+    const [call] = mockSendDeliverableEmail.mock.calls;
+    expect(call[0].subject).toBe("PT subject");
+  });
+
+  it("falls back to the config's defaultLocale when the session's stored locale is null", async () => {
+    const twoLocaleConfig = {
+      ...baseConfigSnapshot(),
+      deliverables: {
+        assets: [{ assetKey: "guide-default" }],
+        copy: {
+          subject: { en: "EN subject", "pt-BR": "PT subject" },
+          body: { en: "EN body", "pt-BR": "PT body" },
+        },
+      },
+    };
+    (prisma.flowSession.findUnique as jest.Mock).mockResolvedValue(
+      sessionRow({ locale: null, configSnapshot: twoLocaleConfig }),
+    );
+
+    await resendDeliverableGrant(GRANT_ID);
+
+    const [call] = mockSendDeliverableEmail.mock.calls;
+    expect(call[0].subject).toBe("EN subject");
+  });
+
+  // ── Data-integrity edges ─────────────────────────────────────────────────
+
+  it("reports lead_not_found when the grant's lead no longer exists", async () => {
+    (prisma.lead.findUnique as jest.Mock).mockResolvedValue(null);
+
+    const result = await resendDeliverableGrant(GRANT_ID);
+
+    expect(result).toEqual({
+      ok: false,
+      error: { kind: "lead_not_found", message: expect.any(String) },
+    });
+    expect(mockSendDeliverableEmail).not.toHaveBeenCalled();
+  });
+
+  it("reports session_not_found when the grant's session no longer exists", async () => {
+    (prisma.flowSession.findUnique as jest.Mock).mockResolvedValue(null);
+
+    const result = await resendDeliverableGrant(GRANT_ID);
+
+    expect(result).toEqual({
+      ok: false,
+      error: { kind: "session_not_found", message: expect.any(String) },
+    });
+    expect(mockSendDeliverableEmail).not.toHaveBeenCalled();
+  });
+
+  it("reports no_deliverables_block when the pinned snapshot carries no deliverables block", async () => {
+    (prisma.flowSession.findUnique as jest.Mock).mockResolvedValue(
+      sessionRow({
+        configSnapshot: { ...baseConfigSnapshot(), deliverables: undefined },
+      }),
+    );
+
+    const result = await resendDeliverableGrant(GRANT_ID);
+
+    expect(result).toEqual({
+      ok: false,
+      error: { kind: "no_deliverables_block", message: expect.any(String) },
+    });
+    expect(mockSendDeliverableEmail).not.toHaveBeenCalled();
+  });
+});
+
+describe("listSendlessGrants", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (prisma.deliverableGrant.findMany as jest.Mock).mockResolvedValue([]);
+  });
+
+  // ── D4 — list mode selects on sendStatus: null + siteId, no send ────────
+
+  it("selects on siteId + sendStatus: null and performs no send", async () => {
+    await listSendlessGrants({ siteId: SITE_ID });
+
+    expect(prisma.deliverableGrant.findMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({
+          siteId: SITE_ID,
+          sendStatus: null,
+        }),
+      }),
+    );
+    expect(mockSendDeliverableEmail).not.toHaveBeenCalled();
+  });
+
+  it("maps rows to {grantId, createdAt, sessionId}", async () => {
+    const createdAt = new Date("2026-08-01T00:00:00Z");
+    (prisma.deliverableGrant.findMany as jest.Mock).mockResolvedValue([
+      { id: GRANT_ID, createdAt, sessionId: SESSION_ID },
+    ]);
+
+    const rows = await listSendlessGrants({ siteId: SITE_ID });
+
+    expect(rows).toEqual([
+      { grantId: GRANT_ID, createdAt, sessionId: SESSION_ID },
+    ]);
+  });
+
+  // ── --since narrows the list by createdAt ────────────────────────────────
+
+  it("narrows the list by createdAt when since is given", async () => {
+    const since = new Date("2026-08-12T00:00:00Z");
+
+    await listSendlessGrants({ siteId: SITE_ID, since });
+
+    expect(prisma.deliverableGrant.findMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({
+          createdAt: { gte: since },
+        }),
+      }),
+    );
+  });
+
+  it("omits the createdAt filter when since is absent", async () => {
+    await listSendlessGrants({ siteId: SITE_ID });
+
+    const [call] = (prisma.deliverableGrant.findMany as jest.Mock).mock.calls;
+    expect(call[0].where.createdAt).toBeUndefined();
+  });
+
+  it("passes limit through as take when given", async () => {
+    await listSendlessGrants({ siteId: SITE_ID, limit: 5 });
+
+    expect(prisma.deliverableGrant.findMany).toHaveBeenCalledWith(
+      expect.objectContaining({ take: 5 }),
+    );
+  });
+});

package/templates/apps/api/src/services/__tests__/entitlements.test.ts

@@ -0,0 +1,142 @@
+/**
+ * @file entitlements.test.ts
+ *
+ * Unit tests for `resolveEntitlements(organizationId)` (org-scoped billing,
+ * #3601, spec AC3 + AC6). Mocks the module-level `prisma` singleton via the
+ * repo's manual-mock convention (`jest.mock("../../lib/prisma.js")` →
+ * `apps/api/src/lib/__mocks__/prisma.ts`). The resolver has no DI seam; it
+ * reads the `prisma` singleton directly.
+ */
+
+// eslint-disable-next-line no-restricted-syntax -- lib/prisma.ts wraps the external DB boundary (PrismaClient requires a live connection); __mocks__/prisma.ts is the repo-standard test double for this boundary.
+jest.mock("../../lib/prisma.js");
+
+import { prisma } from "../../lib/prisma.js";
+import { getOrgBillingIdentity, resolveEntitlements } from "../entitlements";
+
+const ORG_A = "org_00000000-0000-7000-8000-0000000000aa";
+const ORG_B = "org_00000000-0000-7000-8000-0000000000bb";
+
+describe("resolveEntitlements", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  // AC3 — same org → identical entitlements (members inherit); the resolver is
+  // keyed on organizationId only, so two members of the same org (two calls
+  // with the same id) resolve identical results.
+  it("resolves identical entitlements for two members of the same org (members inherit)", async () => {
+    (prisma.organization.findUnique as jest.Mock).mockResolvedValue({
+      tier: "pro",
+      seatCount: 5,
+    });
+
+    const first = await resolveEntitlements(ORG_A);
+    const second = await resolveEntitlements(ORG_A);
+
+    expect(first).toEqual(second);
+    expect(first.limits.static).toEqual({ seats: 5, tier: "pro" });
+    expect(first.features.length).toBeGreaterThan(0);
+  });
+
+  // AC3 — distinct orgs → independent results.
+  it("resolves independent results for distinct organizations", async () => {
+    (prisma.organization.findUnique as jest.Mock)
+      .mockResolvedValueOnce({ tier: "pro", seatCount: 10 })
+      .mockResolvedValueOnce({ tier: "free", seatCount: 1 });
+
+    const a = await resolveEntitlements(ORG_A);
+    const b = await resolveEntitlements(ORG_B);
+
+    expect(a.limits.static).toEqual({ seats: 10, tier: "pro" });
+    expect(b.limits.static).toEqual({ seats: 1, tier: "free" });
+    expect(a.features.length).toBeGreaterThan(0);
+    expect(b.features).toEqual([]);
+    expect(prisma.organization.findUnique).toHaveBeenCalledWith(
+      expect.objectContaining({ where: { id: ORG_A } }),
+    );
+    expect(prisma.organization.findUnique).toHaveBeenCalledWith(
+      expect.objectContaining({ where: { id: ORG_B } }),
+    );
+  });
+
+  // AC6 — the reserved metered slot is present and empty.
+  it("returns limits.metered as the reserved empty shape (AC6)", async () => {
+    (prisma.organization.findUnique as jest.Mock).mockResolvedValue({
+      tier: "enterprise",
+      seatCount: 50,
+    });
+
+    const ent = await resolveEntitlements(ORG_A);
+
+    expect(ent.limits.metered).toEqual({});
+    expect(Object.keys(ent.limits.metered)).toHaveLength(0);
+  });
+
+  // Safe-by-default: an unknown / un-billed org falls back to free baseline.
+  it("falls back to free-tier baseline for an unknown organization", async () => {
+    (prisma.organization.findUnique as jest.Mock).mockResolvedValue(null);
+
+    const ent = await resolveEntitlements("org_does_not_exist");
+
+    expect(ent.limits.static).toEqual({ seats: 1, tier: "free" });
+    expect(ent.features).toEqual([]);
+    expect(ent.limits.metered).toEqual({});
+  });
+
+  // The resolver reads ONLY the Organization (members inherit; no per-user
+  // billing read) — never touches prisma.user.
+  it("reads the Organization only — no per-user billing read", async () => {
+    (prisma.organization.findUnique as jest.Mock).mockResolvedValue({
+      tier: "pro",
+      seatCount: 2,
+    });
+
+    await resolveEntitlements(ORG_A);
+
+    expect(prisma.organization.findUnique).toHaveBeenCalledTimes(1);
+    expect(prisma.user.findUnique).not.toHaveBeenCalled();
+    expect(prisma.user.findFirst).not.toHaveBeenCalled();
+  });
+});
+
+describe("getOrgBillingIdentity", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  // #3701 AC-1/AC-2 — reads only Organization.billingCustomerId by explicit
+  // organization id, the presence-flag source for GET /v1/billing.
+  it("returns the org's raw billingCustomerId by explicit id", async () => {
+    (prisma.organization.findUnique as jest.Mock).mockResolvedValue({
+      billingCustomerId: "cus_test_00000000000000aaaa",
+    });
+
+    const identity = await getOrgBillingIdentity(ORG_A);
+
+    expect(identity).toEqual({ billingCustomerId: "cus_test_00000000000000aaaa" });
+    expect(prisma.organization.findUnique).toHaveBeenCalledWith(
+      expect.objectContaining({ where: { id: ORG_A } }),
+    );
+  });
+
+  // Safe-by-default — an unknown org resolves to null, never throws.
+  it("resolves billingCustomerId: null for an unknown organization", async () => {
+    (prisma.organization.findUnique as jest.Mock).mockResolvedValue(null);
+
+    const identity = await getOrgBillingIdentity("org_does_not_exist");
+
+    expect(identity).toEqual({ billingCustomerId: null });
+  });
+
+  // A billed-then-never-set-up org (row exists, field is null) also resolves null.
+  it("resolves billingCustomerId: null when the org row has no Stripe customer yet", async () => {
+    (prisma.organization.findUnique as jest.Mock).mockResolvedValue({
+      billingCustomerId: null,
+    });
+
+    const identity = await getOrgBillingIdentity(ORG_A);
+
+    expect(identity).toEqual({ billingCustomerId: null });
+  });
+});