create-ailk 0.24.0 → 0.26.0

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

@@ -1,166 +0,0 @@
-/**
- * @file listing-config.test.ts
- * @description Unit tests for the per-site project-listings config reads
- * (#5033) under the tenancy fence (#6257, Stage 2 unit C2).
- *
- * This suite is NEW. `listing-config.ts`'s only coverage lived under
- * `apps/api/src/routes/**\/__tests__/`, which this unit must not touch — so
- * the two reads it owns are pinned here instead, at the service boundary
- * where the fence is applied.
- *
- * Both reads run on the ANONYMOUS path, with no authenticated tenant:
- *
- *   - `listingConfigFor(siteId)` is handed an ALREADY-RESOLVED workspace id
- *     by every caller (a listing row's own `siteId`, a tenant's
- *     `workspaceId`, or `siteIdForPublicKey`'s return), so its read is
- *     scoped by it.
- *   - `siteIdForPublicKey(publicKey)` is the query that RESOLVES the tenant.
- *     It is the documented global-key exemption (its call site carries the
- *     marker comment): it is keyed on a
- *     site's public listing key, which names one row across all workspaces,
- *     and a tenant term would be the very thing it exists to produce.
- *
- * External dependency boundaries mocked:
- *   - @working-theory/database (via moduleNameMapper → prisma-client.js mock;
- *     prisma singleton via __mocks__/prisma.ts)
- *   - @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 mockLoggerWarn = jest.fn();
-const mockLoggerError = jest.fn();
-jest.mock("@working-theory/observability", () => ({
-  logger: {
-    info: jest.fn(),
-    warn: (...args: unknown[]) => mockLoggerWarn(...args),
-    error: (...args: unknown[]) => mockLoggerError(...args),
-    debug: jest.fn(),
-  },
-}));
-
-import { SITE_LISTING_CONFIG_DEFAULTS } from "@working-theory/validation";
-
-import { prisma } from "../../lib/prisma.js";
-import { __resetSiteWorkspaceCacheForTests } from "../../lib/site.js";
-import { listingConfigFor, siteIdForPublicKey } from "../listing-config";
-
-const SITE_ID = "wksp_00000000-0000-7000-8000-0000000000a1";
-const OTHER_SITE_ID = "wksp_00000000-0000-7000-8000-0000000000ff";
-const PUBLIC_KEY = "pk_listing_abcdef";
-
-const priorPublicKey = process.env["AILK_LISTING_PUBLIC_KEY"];
-const priorSiteId = process.env["AILK_SITE_ID"];
-
-beforeEach(() => {
-  jest.clearAllMocks();
-  __resetSiteWorkspaceCacheForTests();
-  delete process.env["AILK_LISTING_PUBLIC_KEY"];
-  delete process.env["AILK_SITE_ID"];
-});
-
-afterAll(() => {
-  if (priorPublicKey === undefined) delete process.env["AILK_LISTING_PUBLIC_KEY"];
-  else process.env["AILK_LISTING_PUBLIC_KEY"] = priorPublicKey;
-  if (priorSiteId === undefined) delete process.env["AILK_SITE_ID"];
-  else process.env["AILK_SITE_ID"] = priorSiteId;
-});
-
-// ─── listingConfigFor — the fenced read ────────────────────────────────────
-
-describe("listingConfigFor", () => {
-  it("scopes the config read by the workspace id it was handed (#6257 AC-1/AC-2)", async () => {
-    (prisma.siteListingConfig.findUnique as jest.Mock).mockResolvedValue({
-      data: { maxWindowDays: 60, defaultWindowDays: 21 },
-    });
-
-    await listingConfigFor(SITE_ID);
-
-    expect(prisma.siteListingConfig.findUnique).toHaveBeenCalledTimes(1);
-    const { where } = (prisma.siteListingConfig.findUnique as jest.Mock).mock.calls[0][0];
-    expect(where.workspaceId).toBe(SITE_ID);
-    expect(where.siteId).toBe(SITE_ID);
-  });
-
-  it("reads a DIFFERENT site under that site's own workspace id, never a remembered one", async () => {
-    (prisma.siteListingConfig.findUnique as jest.Mock).mockResolvedValue(null);
-
-    await listingConfigFor(SITE_ID);
-    await listingConfigFor(OTHER_SITE_ID);
-
-    const calls = (prisma.siteListingConfig.findUnique as jest.Mock).mock.calls;
-    expect(calls[0][0].where.workspaceId).toBe(SITE_ID);
-    expect(calls[1][0].where.workspaceId).toBe(OTHER_SITE_ID);
-  });
-
-  it("a site with no row gets the platform defaults", async () => {
-    (prisma.siteListingConfig.findUnique as jest.Mock).mockResolvedValue(null);
-
-    await expect(listingConfigFor(SITE_ID)).resolves.toEqual(
-      SITE_LISTING_CONFIG_DEFAULTS,
-    );
-  });
-
-  it("a stored blob that fails its schema gets the platform defaults, logged at ERROR", async () => {
-    (prisma.siteListingConfig.findUnique as jest.Mock).mockResolvedValue({
-      data: { maxWindowDays: "not-a-number" },
-    });
-
-    await expect(listingConfigFor(SITE_ID)).resolves.toEqual(
-      SITE_LISTING_CONFIG_DEFAULTS,
-    );
-    expect(mockLoggerError).toHaveBeenCalledWith(
-      expect.objectContaining({ siteId: SITE_ID }),
-      expect.stringContaining("PLATFORM defaults"),
-    );
-  });
-});
-
-// ─── siteIdForPublicKey — the documented global-key exemption ──────────────
-
-describe("siteIdForPublicKey", () => {
-  it("is keyed on the public listing key ALONE — the query that resolves the tenant carries no tenant term", async () => {
-    (prisma.siteListingConfig.findUnique as jest.Mock).mockResolvedValue({
-      siteId: SITE_ID,
-    });
-
-    await expect(siteIdForPublicKey(PUBLIC_KEY)).resolves.toBe(SITE_ID);
-
-    const { where } = (prisma.siteListingConfig.findUnique as jest.Mock).mock.calls[0][0];
-    expect(where).toEqual({ publicKey: PUBLIC_KEY });
-    expect(where.workspaceId).toBeUndefined();
-  });
-
-  it("an unmatched key resolves to null rather than falling through to the env path", async () => {
-    process.env["AILK_LISTING_PUBLIC_KEY"] = "pk_env_key";
-    (prisma.siteListingConfig.findUnique as jest.Mock).mockResolvedValue(null);
-
-    await expect(siteIdForPublicKey("pk_typo")).resolves.toBeNull();
-  });
-
-  it("the env single-tenant path returns the RESOLVED workspace id, never the raw alias", async () => {
-    process.env["AILK_LISTING_PUBLIC_KEY"] = PUBLIC_KEY;
-    process.env["AILK_SITE_ID"] = SITE_ID;
-    (prisma.siteListingConfig.findUnique as jest.Mock).mockResolvedValue(null);
-    // Keyed on the REQUESTED id — a blanket resolve would make a fail-closed
-    // assertion impossible (#6374's own test convention).
-    (prisma.workspace.findUnique as jest.Mock).mockImplementation(
-      async ({ where }: { where: { id: string } }) =>
-        where.id === SITE_ID
-          ? { id: SITE_ID, organizationId: "org_00000000-0000-7000-8000-000000000001" }
-          : null,
-    );
-
-    await expect(siteIdForPublicKey(PUBLIC_KEY)).resolves.toBe(SITE_ID);
-  });
-
-  it("fails closed when the env alias names no workspace", async () => {
-    process.env["AILK_LISTING_PUBLIC_KEY"] = PUBLIC_KEY;
-    process.env["AILK_SITE_ID"] = "no-such-workspace";
-    (prisma.siteListingConfig.findUnique as jest.Mock).mockResolvedValue(null);
-    (prisma.workspace.findUnique as jest.Mock).mockResolvedValue(null);
-
-    await expect(siteIdForPublicKey(PUBLIC_KEY)).resolves.toBeNull();
-  });
-});

package/templates/apps/api/src/services/__tests__/magnet-completion.test.ts

@@ -1,389 +0,0 @@
-/**
- * @file magnet-completion.test.ts
- *
- * #8757 D6 (spec docs/specs/8757-a-per-magnet-completion-setting-spec.md,
- * AC-5's origin, link and copy): where a submitter's account link points,
- * what the invite email says, and when a completion degrades to `lead`.
- *
- * Mocked at their own boundaries: the completion store, the sign-in client
- * read, the commerce claim, the offerings lister and `@working-theory/email`.
- */
-const mockLiveCompletionBySlug = jest.fn();
-const mockInviteSendCounts = jest.fn();
-// eslint-disable-next-line no-restricted-syntax -- jest mock factory must be hoisted
-jest.mock("../../lib/flow-completion-store.js", () => ({
-  liveCompletionBySlug: (...args: unknown[]) => mockLiveCompletionBySlug(...args),
-  inviteSendCounts: (...args: unknown[]) => mockInviteSendCounts(...args),
-}));
-
-const mockFindClientByClientId = jest.fn();
-// eslint-disable-next-line no-restricted-syntax -- jest mock factory must be hoisted
-jest.mock("../../lib/hub-sign-in-store.js", () => ({
-  findClientByClientId: (...args: unknown[]) => mockFindClientByClientId(...args),
-}));
-
-const mockResolveCommerceClaim = jest.fn();
-// eslint-disable-next-line no-restricted-syntax -- jest mock factory must be hoisted
-jest.mock("../../lib/require-commerce-claim.js", () => ({
-  resolveCommerceClaim: () => mockResolveCommerceClaim(),
-}));
-
-const mockListPlanOfferings = jest.fn();
-// eslint-disable-next-line no-restricted-syntax -- jest mock factory must be hoisted
-jest.mock("../plan-offerings.js", () => ({
-  listPlanOfferings: (...args: unknown[]) => mockListPlanOfferings(...args),
-}));
-
-const mockSendDeliverableEmail = jest.fn();
-jest.mock("@working-theory/email", () => ({
-  sendDeliverableEmail: (...args: unknown[]) => mockSendDeliverableEmail(...args),
-}));
-
-import { deliverableSenderAddress } from "../deliverable-fulfillment.js";
-import {
-  accountTargetFor,
-  inviteSenderAddress,
-  MAGNET_COMPLETION_BUDGET_MS,
-  magnetCompletionFor,
-  magnetCompletionWithinBudget,
-  sendInviteConfirmation,
-  type MagnetCompletion,
-} from "../magnet-completion.js";
-
-const WS = "wksp_00000000-0000-7000-8000-0000000000c1";
-const S1 = "spoke_00000000-0000-7000-8000-0000000000d1";
-const NOW = new Date("2026-10-15T12:00:00.000Z");
-const originalEnv = process.env;
-
-const client = (redirectUri: string, enabled = true) => ({
-  id: "oauthc_1",
-  clientId: S1,
-  clientSecret: "x",
-  redirectUris: [redirectUri],
-  enabled,
-});
-
-const invite = (config: unknown = { defaultLocale: "en" }): MagnetCompletion => ({
-  next: { completion: "invite" },
-  title: "Request a quote",
-  config,
-  target: { origin: "https://site.example", provider: "site" },
-});
-
-beforeEach(() => {
-  jest.clearAllMocks();
-  process.env = {
-    ...originalEnv,
-    FRONTEND_URL: "https://site.example/app",
-    AILK_ENABLED_MODULES: "multi-tenant",
-    AILK_DELIVERABLE_EMAIL_FROM: "hello@site.example",
-  };
-  mockInviteSendCounts.mockResolvedValue({ recipientDay: 1, siteHour: 1 });
-  mockSendDeliverableEmail.mockResolvedValue({ ok: true, messageId: "m1" });
-  mockResolveCommerceClaim.mockResolvedValue("claimed");
-  mockListPlanOfferings.mockResolvedValue([{ key: "retainer", name: "Retainer", type: "service" }]);
-});
-
-afterAll(() => {
-  process.env = originalEnv;
-});
-
-describe("accountTargetFor — the link's origin is never the request's", () => {
-  it("a keyless caller on a build with an account area gets FRONTEND_URL's origin and the site path", async () => {
-    expect(await accountTargetFor({ kind: "anonymous" })).toEqual({
-      origin: "https://site.example",
-      provider: "site",
-    });
-  });
-
-  it("a keyless caller on a build with no account area gets nothing", async () => {
-    process.env.AILK_ENABLED_MODULES = "signal-collectors";
-    expect(await accountTargetFor({ kind: "anonymous" })).toBeNull();
-  });
-
-  it("a spoke gets its enabled sign-in client's callback origin and the hub path", async () => {
-    mockFindClientByClientId.mockResolvedValue(client("https://spoke.example/api/hub-session/callback"));
-    expect(await accountTargetFor({ kind: "spoke", spokeId: S1, workspaceId: WS })).toEqual({
-      origin: "https://spoke.example",
-      provider: "hub",
-    });
-  });
-
-  it("a spoke with no client, a disabled one, or an http callback in production gets nothing", async () => {
-    const spoke = { kind: "spoke", spokeId: S1, workspaceId: WS } as const;
-    mockFindClientByClientId.mockResolvedValueOnce(null);
-    expect(await accountTargetFor(spoke)).toBeNull();
-    mockFindClientByClientId.mockResolvedValueOnce(client("https://spoke.example/cb", false));
-    expect(await accountTargetFor(spoke)).toBeNull();
-    process.env.NODE_ENV = "production";
-    mockFindClientByClientId.mockResolvedValueOnce(client("http://localhost:3000/api/hub-session/callback"));
-    expect(await accountTargetFor(spoke)).toBeNull();
-  });
-
-  it("an http loopback callback outside production is allowed (local development)", async () => {
-    process.env.NODE_ENV = "development";
-    mockFindClientByClientId.mockResolvedValue(client("http://localhost:3000/api/hub-session/callback"));
-    expect(await accountTargetFor({ kind: "spoke", spokeId: S1, workspaceId: WS })).toEqual({
-      origin: "http://localhost:3000",
-      provider: "hub",
-    });
-  });
-});
-
-describe("inviteSenderAddress — every completion email's sender", () => {
-  it.each([
-    [{ AILK_DELIVERABLE_EMAIL_FROM: "a@x.example", AILK_LEAD_NOTIFICATION_FROM: "b@x.example" }],
-    [{ AILK_DELIVERABLE_EMAIL_FROM: "", AILK_LEAD_NOTIFICATION_FROM: "b@x.example" }],
-    [{}],
-  ])("answers what deliverableSenderAddress answers for %j", (env) => {
-    delete process.env.AILK_DELIVERABLE_EMAIL_FROM;
-    delete process.env.AILK_LEAD_NOTIFICATION_FROM;
-    Object.assign(process.env, env);
-    expect(inviteSenderAddress()).toBe(deliverableSenderAddress());
-  });
-});
-
-describe("magnetCompletionWithinBudget — a slow read never holds the 201", () => {
-  it("answers null once the budget passes", async () => {
-    jest.useFakeTimers();
-    try {
-      mockLiveCompletionBySlug.mockReturnValue(new Promise(() => undefined));
-      const pending = magnetCompletionWithinBudget(WS, "contact", async () => null);
-      jest.advanceTimersByTime(MAGNET_COMPLETION_BUDGET_MS);
-      expect(await pending).toBeNull();
-    } finally {
-      jest.useRealTimers();
-    }
-  });
-});
-
-describe("magnetCompletionFor", () => {
-  const target = { origin: "https://site.example", provider: "site" as const };
-  const live = (completion: string, checkoutOffering: string | null = null) =>
-    mockLiveCompletionBySlug.mockResolvedValue({
-      completion,
-      checkoutOffering,
-      title: "Contact form",
-      config: {},
-    });
-
-  it("lead, or no live magnet, is null and never resolves a target", async () => {
-    const resolveTarget = jest.fn().mockResolvedValue(target);
-    live("lead");
-    expect(await magnetCompletionFor(WS, "contact", resolveTarget)).toBeNull();
-    mockLiveCompletionBySlug.mockResolvedValue(null);
-    expect(await magnetCompletionFor(WS, "contact", resolveTarget)).toBeNull();
-    expect(resolveTarget).not.toHaveBeenCalled();
-  });
-
-  it("invite with a target answers next: invite; with none degrades to lead", async () => {
-    live("invite");
-    expect(await magnetCompletionFor(WS, "contact", async () => target)).toMatchObject({
-      next: { completion: "invite" },
-      title: "Contact form",
-      target,
-    });
-    expect(await magnetCompletionFor(WS, "contact", async () => null)).toBeNull();
-  });
-
-  it("checkout re-checks the claim and the listed offering, and never resolves a target", async () => {
-    const resolveTarget = jest.fn();
-    live("checkout", "retainer");
-    expect(await magnetCompletionFor(WS, "contact", resolveTarget)).toMatchObject({
-      next: { completion: "checkout", checkoutOffering: "retainer" },
-    });
-    expect(mockListPlanOfferings).toHaveBeenCalledWith(WS);
-    expect(resolveTarget).not.toHaveBeenCalled();
-  });
-});
-
-describe("sendInviteConfirmation — copy and link", () => {
-  it("sends the defaults with the title filled in and the prefilled sign-in link", async () => {
-    expect(
-      await sendInviteConfirmation({
-        workspaceId: WS,
-        slug: "request-quote",
-        email: "a+b@x.example",
-        locale: undefined,
-        completion: invite(),
-        now: NOW,
-      }),
-    ).toBe("sent");
-    expect(mockInviteSendCounts).toHaveBeenCalledWith(WS, "request-quote", "a+b@x.example", NOW);
-    expect(mockSendDeliverableEmail).toHaveBeenCalledWith({
-      to: "a+b@x.example",
-      fromAddress: "hello@site.example",
-      subject: "We received your Request a quote",
-      body: "Thanks — we have your Request a quote. You can follow it in your account.",
-      cta: "Track this in your account",
-      downloadLink: "https://site.example/sign-in?next=%2Faccount&email=a%2Bb%40x.example",
-    });
-  });
-
-  it("uses the magnet's completionEmail in the submitter's locale, else its default locale", async () => {
-    const config = {
-      defaultLocale: "en",
-      completionEmail: {
-        subject: { en: "Got it", fr: "Bien reçu" },
-        body: { en: "Thanks.", fr: "Merci." },
-        cta: { en: "Follow it", fr: "Suivre" },
-      },
-    };
-    await sendInviteConfirmation({
-      workspaceId: WS,
-      slug: "contact",
-      email: "a@b.example",
-      locale: "fr",
-      completion: invite(config),
-      now: NOW,
-    });
-    expect(mockSendDeliverableEmail.mock.calls[0][0]).toMatchObject({
-      subject: "Bien reçu",
-      body: "Merci.",
-      cta: "Suivre",
-    });
-    await sendInviteConfirmation({
-      workspaceId: WS,
-      slug: "contact",
-      email: "a@b.example",
-      locale: "de",
-      completion: invite(config),
-      now: NOW,
-    });
-    expect(mockSendDeliverableEmail.mock.calls[1][0]).toMatchObject({ subject: "Got it" });
-  });
-
-  it.each(["constructor", "toString", "__proto__"])(
-    "a payload locale of %s reads the default locale's copy, never an inherited member",
-    async (locale) => {
-      const config = {
-        defaultLocale: "en",
-        completionEmail: { subject: { en: "Got it" }, body: { en: "Thanks." } },
-      };
-      expect(
-        await sendInviteConfirmation({
-          workspaceId: WS,
-          slug: "contact",
-          email: "a@b.example",
-          locale,
-          completion: invite(config),
-          now: NOW,
-        }),
-      ).toBe("sent");
-      expect(mockSendDeliverableEmail.mock.calls[0][0]).toMatchObject({
-        subject: "Got it",
-        body: "Thanks.",
-      });
-    },
-  );
-
-  it("an email the hint schema refuses gets no email (no_link)", async () => {
-    expect(
-      await sendInviteConfirmation({
-        workspaceId: WS,
-        slug: "contact",
-        email: "x\r\n@y",
-        locale: undefined,
-        completion: invite(),
-        now: NOW,
-      }),
-    ).toBe("no_link");
-    expect(mockSendDeliverableEmail).not.toHaveBeenCalled();
-  });
-
-  it.each([
-    [{ recipientDay: 2, siteHour: 2 }, "capped_recipient"],
-    [{ recipientDay: 1, siteHour: 51 }, "capped_site"],
-  ])("counts %j cap the send (%s)", async (counts, outcome) => {
-    mockInviteSendCounts.mockResolvedValue(counts);
-    expect(
-      await sendInviteConfirmation({
-        workspaceId: WS,
-        slug: "contact",
-        email: "a@b.example",
-        locale: undefined,
-        completion: invite(),
-        now: NOW,
-      }),
-    ).toBe(outcome);
-    expect(mockSendDeliverableEmail).not.toHaveBeenCalled();
-  });
-
-  it("a send that fails or throws is send_failed, never a throw", async () => {
-    mockSendDeliverableEmail.mockResolvedValueOnce({ ok: false, error: { kind: "send_failed" } });
-    mockSendDeliverableEmail.mockRejectedValueOnce(new Error("down"));
-    const input = {
-      workspaceId: WS,
-      slug: "contact",
-      email: "a@b.example",
-      locale: undefined,
-      completion: invite(),
-      now: NOW,
-    };
-    expect(await sendInviteConfirmation(input)).toBe("send_failed");
-    expect(await sendInviteConfirmation(input)).toBe("send_failed");
-  });
-});
-
-// Read as text, never imported: an app does not import a package's source.
-const monorepoFs = jest.requireActual<typeof import("node:fs")>("node:fs");
-const monorepoPath = jest.requireActual<typeof import("node:path")>("node:path");
-const MONOREPO = monorepoPath.resolve(__dirname, "../../../../..");
-const SLICES = "packages/create-ailk/src/module-architecture.ts";
-// Monorepo-only: a scaffolded site carries no packages/create-ailk, and the
-// scaffold matrix runs this suite inside one (#8780), so the slice assertion
-// skips where the slice map does not exist rather than failing to load.
-const describeInMonorepo = monorepoFs.existsSync(monorepoPath.join(MONOREPO, SLICES))
-  ? describe
-  : describe.skip;
-
-describeInMonorepo("#8757 AC-3 / NFR6 — the lead path reaches only base-tree files", () => {
-  const fs = monorepoFs;
-  const path = monorepoPath;
-  const REPO = MONOREPO;
-  const read = (rel: string) => fs.readFileSync(path.join(REPO, rel), "utf8");
-  // Lazy: describe.skip still runs this body at collection time, so the slice
-  // map is read only inside a test, never while the suite loads.
-  let slicesCache: string | undefined;
-  const slicesText = () => (slicesCache ??= read(SLICES));
-  const sliceGlobs = () =>
-    [...slicesText().matchAll(/"(apps\/api\/src\/[^"]*)\/\*\*"/g)].map((m) => m[1]!);
-  const named = (rel: string) =>
-    slicesText().includes(`"${rel}"`) || sliceGlobs().some((dir) => rel.startsWith(`${dir}/`));
-
-  /** Every apps/api source file `entry` reaches through relative imports. */
-  function closure(entry: string): string[] {
-    const seen = new Set<string>();
-    const walk = (rel: string) => {
-      if (seen.has(rel)) return;
-      seen.add(rel);
-      for (const m of read(rel).matchAll(/^(?:import|export)[^;]*?from\s+["'](\.[^"']+)["']/gm)) {
-        const target = path.posix.normalize(
-          path.posix.join(path.posix.dirname(rel), m[1]!.replace(/\.js$/, ".ts")),
-        );
-        if (fs.existsSync(path.join(REPO, target))) walk(target);
-      }
-    };
-    walk(entry);
-    return [...seen];
-  }
-
-  const NEW_BASE_FILES = [
-    "apps/api/src/lib/flow-completion-store.ts",
-    "apps/api/src/services/plan-offerings.ts",
-    "apps/api/src/services/magnet-completion.ts",
-  ];
-
-  it("the three new files carry no oss: false marker and are named by no module slice", () => {
-    for (const rel of NEW_BASE_FILES) {
-      expect(read(rel).split("\n", 1)[0]).not.toMatch(/oss:\s*false/);
-      expect(named(rel)).toBe(false);
-    }
-  });
-
-  it("routes/leads/index.ts imports, directly or not, no file a module slice owns", () => {
-    const reached = closure("apps/api/src/routes/leads/index.ts");
-    for (const rel of NEW_BASE_FILES) expect(reached).toContain(rel);
-    expect(reached.filter(named)).toEqual([]);
-  });
-});