create-ailk 0.5.0 → 0.6.1

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

@@ -0,0 +1,166 @@
+/**
+ * @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__/project-listings.fence.test.ts

@@ -0,0 +1,154 @@
+// oss: false
+/**
+ * @file project-listings.fence.test.ts
+ *
+ * #6258 AC-6 — `attachWaitlistCounts` (`services/project-listings.ts:425-443`)
+ * is one of the nine fenced reads that gain a `workspaceId` term beside their
+ * existing `siteId` one. This suite is that read's per-`where` proof.
+ *
+ * Why a NEW file rather than an addition to an existing suite: this service's
+ * only coverage today lives under `apps/api/src/routes/project-listings/__tests__/`,
+ * a path under the advisory route floor this unit keeps its diff out of
+ * (spec § 8.3). The `where` lives in the service, so the service is where it
+ * is proven.
+ */
+import { listProjectListings } from "../project-listings.js";
+
+// Boundary mocks — `project-listings.ts`'s import chain reaches the Resend
+// client and the licence check; neither is exercised by the read under test.
+jest.mock("@working-theory/email", () => ({
+  sendLeadNotification: jest.fn().mockResolvedValue({ ok: true, messageId: "msg-test" }),
+  sendDeliverableEmail: jest.fn().mockResolvedValue({ ok: true, messageId: "msg-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 -- jest mock factory must be hoisted
+jest.mock("../../lib/prisma.js", () => ({
+  prisma: {
+    projectListing: { findMany: jest.fn() },
+    waitlistScore: { count: jest.fn() },
+  },
+}));
+
+import { prisma } from "../../lib/prisma.js";
+
+const SITE = "wksp_00000000-0000-7000-8000-000000000001";
+const EXPERIMENT_A = "ailk-founder-diagnostic";
+const EXPERIMENT_B = "ailk-agency-waitlist";
+
+/**
+ * A listing row carrying `workspaceId` equal to its `siteId` — exactly what
+ * the `project_listings_workspace_site_agree` CHECK guarantees in the
+ * database (#6258 D11).
+ */
+function listingRow(id: string, experimentKey: string | null): Record<string, unknown> {
+  return {
+    id,
+    siteId: SITE,
+    workspaceId: SITE,
+    leadId: null,
+    slug: `slug-${id}`,
+    name: "Acme",
+    headline: null,
+    oneLiner: null,
+    problem: null,
+    solution: null,
+    url: null,
+    product: null,
+    commitment: null,
+    teamComposition: null,
+    faqs: null,
+    anythingElse: null,
+    address: null,
+    addressLine1: null,
+    addressLine2: null,
+    addressCity: null,
+    addressRegion: null,
+    addressPostalCode: null,
+    addressCountry: null,
+    questions: null,
+    siteAnswers: null,
+    windowDays: null,
+    founderName: null,
+    founderFirstName: null,
+    founderLastName: null,
+    founderEmail: null,
+    founderPhone: null,
+    founderCompany: null,
+    emailVerifiedAt: null,
+    logoMarkUrl: null,
+    logoWordmarkUrl: null,
+    featured: false,
+    status: "active",
+    consentAt: new Date("2026-09-01T00:00:00.000Z"),
+    decidedAt: null,
+    decidedBy: null,
+    issueUrl: null,
+    experimentKey,
+    windowEndsAt: new Date("2099-01-01T00:00:00.000Z"),
+    createdAt: new Date("2026-09-01T00:00:00.000Z"),
+    updatedAt: new Date("2026-09-01T00:00:00.000Z"),
+  };
+}
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  (prisma.waitlistScore.count as jest.Mock).mockResolvedValue(3);
+});
+
+describe("attachWaitlistCounts — the fenced count filters on workspaceId beside siteId (#6258 AC-6)", () => {
+  it("prisma.waitlistScore.count's where carries workspaceId === the resolved scope id, by value", async () => {
+    (prisma.projectListing.findMany as jest.Mock).mockResolvedValue([
+      listingRow("plst_a", EXPERIMENT_A),
+    ]);
+
+    await listProjectListings(SITE);
+
+    expect((prisma.waitlistScore.count as jest.Mock).mock.calls[0]![0]!.where).toEqual({
+      siteId: SITE,
+      workspaceId: SITE,
+      experimentKey: EXPERIMENT_A,
+    });
+  });
+
+  it("every DISTINCT experimentKey gets the same two scope terms — one count per key, no more", async () => {
+    (prisma.projectListing.findMany as jest.Mock).mockResolvedValue([
+      listingRow("plst_a", EXPERIMENT_A),
+      listingRow("plst_b", EXPERIMENT_B),
+      listingRow("plst_c", EXPERIMENT_A),
+    ]);
+
+    await listProjectListings(SITE);
+
+    expect(prisma.waitlistScore.count).toHaveBeenCalledTimes(2);
+    const wheres = (prisma.waitlistScore.count as jest.Mock).mock.calls.map(
+      (call) => call[0]!.where as Record<string, unknown>,
+    );
+    for (const where of wheres) {
+      expect(where.siteId).toBe(SITE);
+      expect(where.workspaceId).toBe(SITE);
+    }
+    expect(wheres.map((w) => w.experimentKey).sort()).toEqual(
+      [EXPERIMENT_A, EXPERIMENT_B].sort(),
+    );
+  });
+
+  it("no listing carries an experimentKey → no fenced read is issued at all", async () => {
+    (prisma.projectListing.findMany as jest.Mock).mockResolvedValue([
+      listingRow("plst_a", null),
+    ]);
+
+    await listProjectListings(SITE);
+
+    expect(prisma.waitlistScore.count).not.toHaveBeenCalled();
+  });
+});

package/templates/apps/api/src/services/__tests__/public-site-resolver.test.ts

@@ -0,0 +1,137 @@
+/**
+ * @file public-site-resolver.test.ts
+ *
+ * Unit tests for `resolvePublicWorkspace(request)` (#5852, roadmap D4 read
+ * half). Database-free: the module-level `prisma` singleton is faked via the
+ * repo's manual-mock convention (`jest.mock("../../lib/prisma.js")` →
+ * `apps/api/src/lib/__mocks__/prisma.ts`), so every case runs in the ordinary
+ * workspace Jest run with no `DATABASE_URL`.
+ *
+ * The four arms under test: no-op off the database adapter (`mdx`,
+ * `projection`), resolved on a one-workspace deployment, and fail-closed on
+ * every ambiguity (zero, two, or a sole non-default workspace).
+ */
+
+// 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 {
+  DEFAULT_ORG_ID,
+  DEFAULT_WORKSPACE_ID,
+} from "@working-theory/database/tenancy";
+import type { FastifyRequest } from "fastify";
+
+import { prisma } from "../../lib/prisma.js";
+import { resolvePublicWorkspace } from "../public-site-resolver.js";
+
+// The resolver reads nothing off the request today (#5852 D1), so the stub is
+// an empty object asserted at the parameter's type rather than a fixture.
+const request = {} as FastifyRequest;
+
+/** A one-workspace deployment seeded with the well-known default. */
+function seedOneWorkspaceDeployment(): void {
+  (prisma.workspace.count as jest.Mock).mockResolvedValue(1);
+  (prisma.workspace.findUnique as jest.Mock).mockResolvedValue({
+    id: DEFAULT_WORKSPACE_ID,
+    organizationId: DEFAULT_ORG_ID,
+  });
+}
+
+describe("resolvePublicWorkspace", () => {
+  const savedAdapter = process.env.CONTENT_ADAPTER;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    if (savedAdapter === undefined) {
+      delete process.env.CONTENT_ADAPTER;
+    } else {
+      process.env.CONTENT_ADAPTER = savedAdapter;
+    }
+  });
+
+  describe("off the database adapter, it is a no-op (D4)", () => {
+    it("returns not-required under the default mdx adapter", async () => {
+      delete process.env.CONTENT_ADAPTER;
+
+      await expect(resolvePublicWorkspace(request)).resolves.toEqual({
+        kind: "not-required",
+      });
+    });
+
+    it("returns not-required under the projection adapter", async () => {
+      process.env.CONTENT_ADAPTER = "projection";
+
+      await expect(resolvePublicWorkspace(request)).resolves.toEqual({
+        kind: "not-required",
+      });
+    });
+
+    it("issues no tenancy query at all on the mdx arm", async () => {
+      delete process.env.CONTENT_ADAPTER;
+
+      await resolvePublicWorkspace(request);
+
+      expect(prisma.workspace.count).not.toHaveBeenCalled();
+      expect(prisma.workspace.findUnique).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("under CONTENT_ADAPTER=database", () => {
+    beforeEach(() => {
+      process.env.CONTENT_ADAPTER = "database";
+    });
+
+    it("resolves the seeded default on a one-workspace deployment", async () => {
+      seedOneWorkspaceDeployment();
+
+      await expect(resolvePublicWorkspace(request)).resolves.toEqual({
+        kind: "resolved",
+        workspaceId: DEFAULT_WORKSPACE_ID,
+      });
+    });
+
+    it("is unresolved when the deployment has no workspace", async () => {
+      (prisma.workspace.count as jest.Mock).mockResolvedValue(0);
+
+      await expect(resolvePublicWorkspace(request)).resolves.toEqual({
+        kind: "unresolved",
+        reason: "ambiguous",
+      });
+    });
+
+    it("is unresolved when the deployment has two workspaces", async () => {
+      (prisma.workspace.count as jest.Mock).mockResolvedValue(2);
+
+      await expect(resolvePublicWorkspace(request)).resolves.toEqual({
+        kind: "unresolved",
+        reason: "ambiguous",
+      });
+    });
+
+    it("is unresolved when the sole workspace is not the seeded default", async () => {
+      (prisma.workspace.count as jest.Mock).mockResolvedValue(1);
+      (prisma.workspace.findUnique as jest.Mock).mockResolvedValue(null);
+
+      await expect(resolvePublicWorkspace(request)).resolves.toEqual({
+        kind: "unresolved",
+        reason: "ambiguous",
+      });
+    });
+
+    it("is unresolved when the sole workspace hangs off a non-sentinel org", async () => {
+      (prisma.workspace.count as jest.Mock).mockResolvedValue(1);
+      (prisma.workspace.findUnique as jest.Mock).mockResolvedValue({
+        id: DEFAULT_WORKSPACE_ID,
+        organizationId: "org_01930000-0000-7000-8000-00000000beef",
+      });
+
+      await expect(resolvePublicWorkspace(request)).resolves.toEqual({
+        kind: "unresolved",
+        reason: "ambiguous",
+      });
+    });
+  });
+});