create-ailk 0.24.0 → 0.26.0

package/templates/apps/api/src/services/__tests__/keyless-workspace-predicate.test.ts

@@ -1,234 +0,0 @@
-/**
- * @file keyless-workspace-predicate.test.ts
- *
- * One keyless-workspace predicate (#9145). `resolvePublicWorkspace` (content,
- * pricing, schedule, the consent cookie) and `resolveCallerWorkspace` (the
- * `/v1/flows` routes and the open deliverable) answer a keyless caller through
- * the SAME rule — `services/default-tenant.ts#resolveDefaultWorkspaceId`: one
- * workspace that is the seeded default resolves to it, anything else is
- * unresolved. The `AILK_SITE_ID` alias is never consulted for a keyless
- * caller, so a multi-workspace deployment that is not a hub answers every
- * anonymous route the same way instead of 503 on `/pricing` and the alias
- * workspace on `/flows/*`.
- *
- * The spoke-key arm and every refusal are unchanged; the hub cases here pin
- * that a keyless call on a hub is refused by both resolvers alike.
- *
- * External dependency boundaries mocked:
- *   - @working-theory/database (via the prisma singleton; __mocks__/prisma.ts)
- */
-import { createHash } from "node:crypto";
-
-// 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_WORKSPACE_ID } from "@working-theory/database/tenancy";
-import type { FastifyRequest } from "fastify";
-
-import * as configModule from "../../config/index.js";
-import type { HubSpokeKeyMode } from "../../config/index.js";
-import { __resetSiteWorkspaceCacheForTests } from "../../lib/site.js";
-import {
-  mockSentinelWorkspaceExists,
-  mockWorkspaceExists,
-} from "../../lib/__mocks__/prisma.js";
-import { prisma } from "../../lib/prisma.js";
-import {
-  __resetHubStatusForTests,
-  resolveCallerWorkspace,
-  resolvePublicWorkspace,
-} from "../public-site-resolver.js";
-
-const db = jest.mocked(prisma);
-
-const W1 = "wksp_01920000-0000-7000-8000-0000000000b1";
-const W2 = "wksp_01920000-0000-7000-8000-0000000000b2";
-const S1 = "spoke_01920000-0000-7000-8000-0000000000c1";
-const KEY_S1 = `ailk_spk_S1${"x".repeat(41)}`;
-
-const digest = (key: string) => createHash("sha256").update(key).digest("hex");
-
-/** A request double carrying only what the resolver may read. */
-function requestWith(headers: Record<string, string> = {}): FastifyRequest {
-  // eslint-disable-next-line no-restricted-syntax -- a FastifyRequest double carrying only the two members the resolver reads (headers, log)
-  return {
-    headers,
-    log: { warn: jest.fn(), info: jest.fn(), error: jest.fn() },
-  } as unknown as FastifyRequest;
-}
-
-function setMode(mode: HubSpokeKeyMode): void {
-  jest.replaceProperty(configModule, "config", {
-    ...configModule.config,
-    AILK_HUB_REQUIRE_SPOKE_KEY: mode,
-  });
-}
-
-/** A deployment with no spoke registered: not a hub (#7633 D1). */
-function notAHub(): void {
-  db.spoke.findFirst.mockResolvedValue(null);
-}
-
-/** A hub: its registry holds `S1` → `W1`. */
-function aHub(): void {
-  db.spoke.findFirst.mockResolvedValue({ id: S1 } as never);
-  db.spoke.findUnique.mockImplementation((async ({
-    where,
-  }: {
-    where: { credentialHash: string };
-  }) =>
-    where.credentialHash === digest(KEY_S1)
-      ? { id: S1, workspaceId: W1, revokedAt: null }
-      : null) as never);
-}
-
-/** Exactly one workspace, the seeded default on the sentinel Organization. */
-function oneWorkspaceDeployment(): void {
-  db.workspace.count.mockResolvedValue(1);
-  mockSentinelWorkspaceExists(db);
-}
-
-/** Three workspaces — the seeded default beside `W1` and `W2`. */
-function multiWorkspaceDeployment(): void {
-  db.workspace.count.mockResolvedValue(3);
-  mockSentinelWorkspaceExists(db, W1, W2);
-}
-
-const saved = {
-  adapter: process.env.CONTENT_ADAPTER,
-  databaseUrl: process.env.DATABASE_URL,
-  siteId: process.env.AILK_SITE_ID,
-};
-
-function restore(name: string, value: string | undefined): void {
-  if (value === undefined) delete process.env[name];
-  else process.env[name] = value;
-}
-
-beforeEach(() => {
-  jest.resetAllMocks();
-  process.env.DATABASE_URL = "postgres://stub";
-  process.env.CONTENT_ADAPTER = "database";
-  delete process.env.AILK_SITE_ID;
-  setMode("auto");
-  __resetHubStatusForTests();
-  __resetSiteWorkspaceCacheForTests();
-});
-
-afterEach(() => {
-  jest.restoreAllMocks();
-  restore("CONTENT_ADAPTER", saved.adapter);
-  restore("DATABASE_URL", saved.databaseUrl);
-  restore("AILK_SITE_ID", saved.siteId);
-});
-
-describe("a one-workspace deployment that is not a hub (#9145)", () => {
-  beforeEach(() => {
-    notAHub();
-    oneWorkspaceDeployment();
-  });
-
-  it("serves the same workspace through both resolvers", async () => {
-    const pub = await resolvePublicWorkspace(requestWith());
-    const caller = await resolveCallerWorkspace(requestWith());
-
-    expect(pub).toEqual({ kind: "resolved", workspaceId: DEFAULT_WORKSPACE_ID });
-    expect(caller).toEqual({
-      kind: "resolved",
-      workspaceId: DEFAULT_WORKSPACE_ID,
-      viaSpoke: false,
-    });
-  });
-
-  it("resolveCallerWorkspace answers the predicate on any content adapter — flows are database rows", async () => {
-    process.env.CONTENT_ADAPTER = "mdx";
-
-    await expect(resolveCallerWorkspace(requestWith())).resolves.toEqual({
-      kind: "resolved",
-      workspaceId: DEFAULT_WORKSPACE_ID,
-      viaSpoke: false,
-    });
-  });
-});
-
-describe("a multi-workspace deployment that is not a hub (#9145)", () => {
-  beforeEach(() => {
-    notAHub();
-    multiWorkspaceDeployment();
-  });
-
-  it("answers unresolved through both resolvers, though the default alias resolves", async () => {
-    const pub = await resolvePublicWorkspace(requestWith());
-    const caller = await resolveCallerWorkspace(requestWith());
-
-    expect(pub).toEqual({ kind: "unresolved", reason: "ambiguous" });
-    expect(caller).toEqual({ kind: "unresolved", reason: "ambiguous" });
-  });
-
-  it("answers unresolved through both, though AILK_SITE_ID names a real workspace", async () => {
-    process.env.AILK_SITE_ID = W1;
-
-    await expect(resolvePublicWorkspace(requestWith())).resolves.toEqual({
-      kind: "unresolved",
-      reason: "ambiguous",
-    });
-    await expect(resolveCallerWorkspace(requestWith())).resolves.toEqual({
-      kind: "unresolved",
-      reason: "ambiguous",
-    });
-  });
-});
-
-describe("a sole workspace that is not the seeded default (#9145)", () => {
-  it("answers unresolved through both, though AILK_SITE_ID names it", async () => {
-    notAHub();
-    process.env.AILK_SITE_ID = W1;
-    db.workspace.count.mockResolvedValue(1);
-    mockWorkspaceExists(db, W1);
-
-    await expect(resolvePublicWorkspace(requestWith())).resolves.toEqual({
-      kind: "unresolved",
-      reason: "ambiguous",
-    });
-    await expect(resolveCallerWorkspace(requestWith())).resolves.toEqual({
-      kind: "unresolved",
-      reason: "ambiguous",
-    });
-  });
-});
-
-describe("a hub (#9145 — the refusals are unchanged)", () => {
-  it("AILK_HUB_REQUIRE_SPOKE_KEY on refuses a keyless call through both, on a one-workspace deployment", async () => {
-    setMode("on");
-    notAHub();
-    oneWorkspaceDeployment();
-
-    await expect(resolvePublicWorkspace(requestWith())).resolves.toEqual({
-      kind: "unresolved",
-      reason: "spoke-refused",
-    });
-    await expect(resolveCallerWorkspace(requestWith())).resolves.toEqual({
-      kind: "unresolved",
-      reason: "spoke-refused",
-    });
-    expect(db.workspace.count).not.toHaveBeenCalled();
-  });
-
-  it("a registered spoke still resolves to its own workspace through both", async () => {
-    aHub();
-    multiWorkspaceDeployment();
-    const headers = { "x-ailk-spoke-key": KEY_S1 };
-
-    await expect(resolvePublicWorkspace(requestWith(headers))).resolves.toEqual({
-      kind: "resolved",
-      workspaceId: W1,
-    });
-    await expect(resolveCallerWorkspace(requestWith(headers))).resolves.toEqual({
-      kind: "resolved",
-      workspaceId: W1,
-      viaSpoke: true,
-      spokeId: S1,
-    });
-    expect(db.workspace.count).not.toHaveBeenCalled();
-  });
-});

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

@@ -1,251 +0,0 @@
-// oss: false
-/**
- * @file lead-accept-user.test.ts
- *
- * The find-or-create behind accepting an inbox message (#7418 D1, D2, D7, D7a,
- * D8): the lead's email resolves to ONE `auth.User` — an existing one is
- * linked and left untouched, a missing one is created verified with the plain
- * `user` role and no credential, membership or session.
- *
- * External dependency boundary mocked: `lib/prisma` — an inline factory with
- * an in-memory `users` table that honours the case-insensitive `equals`
- * filter and the byte-exact `@unique` email constraint (a duplicate create
- * throws Prisma's `P2002`). `account`/`session`/`membership` carry `create`
- * spies so AC-3 can assert none of them is ever written.
- */
-
-// eslint-disable-next-line no-restricted-syntax -- jest mock factory must be hoisted
-jest.mock("../../lib/prisma.js", () => ({
-  prisma: {
-    user: { findFirst: jest.fn(), create: jest.fn(), update: jest.fn() },
-    account: { create: jest.fn() },
-    session: { create: jest.fn() },
-    membership: { create: jest.fn() },
-  },
-}));
-
-import { prisma } from "../../lib/prisma.js";
-import { findOrCreateUserForLeadEmail } from "../lead-accept-user";
-
-type UserRow = {
-  id: string;
-  email: string;
-  name: string | null;
-  emailVerified: boolean;
-  role: string;
-  createdAt: Date;
-};
-
-type UserWhere = { email?: { equals: string; mode?: "insensitive" } };
-
-let USERS: UserRow[] = [];
-let nextUser = 1;
-
-function userId(n: number): string {
-  return `user_00000000-0000-7000-8000-${n.toString(16).padStart(12, "0")}`;
-}
-
-function uniqueViolation(): Error {
-  return Object.assign(new Error("Unique constraint failed on the fields: (`email`)"), {
-    code: "P2002",
-  });
-}
-
-/** Wires `prisma.user.findFirst`/`create` to a fresh in-memory table. */
-function seedUsers(rows: UserRow[]): UserRow[] {
-  USERS = rows.map((r) => ({ ...r }));
-  nextUser = 100;
-
-  (prisma.user.findFirst as jest.Mock).mockImplementation(
-    async ({ where }: { where: UserWhere }) => {
-      const filter = where.email;
-      const match = USERS.filter((u) =>
-        filter?.mode === "insensitive"
-          ? u.email.toLowerCase() === filter.equals.toLowerCase()
-          : u.email === filter?.equals,
-      ).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime())[0];
-      return match ? { id: match.id, emailVerified: match.emailVerified } : null;
-    },
-  );
-  (prisma.user.create as jest.Mock).mockImplementation(
-    async ({ data }: { data: Partial<UserRow> & { email: string } }) => {
-      // Postgres `@unique` is byte-exact — the same constraint the real
-      // table carries.
-      if (USERS.some((u) => u.email === data.email)) throw uniqueViolation();
-      const row: UserRow = {
-        id: userId(nextUser++),
-        name: null,
-        emailVerified: false,
-        role: "user",
-        createdAt: new Date(),
-        ...data,
-      };
-      USERS.push(row);
-      return { id: row.id };
-    },
-  );
-  return USERS;
-}
-
-function existingUser(overrides: Partial<UserRow> & { email: string }): UserRow {
-  return {
-    id: userId(1),
-    name: "Existing Person",
-    emailVerified: false,
-    role: "admin",
-    createdAt: new Date("2026-01-01T00:00:00.000Z"),
-    ...overrides,
-  };
-}
-
-describe("findOrCreateUserForLeadEmail (#7418)", () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it("AC-3 / D1 — with no existing user, creates exactly one verified plain user with the lowercased email and no name, and no Account/Session/Membership", async () => {
-    const table = seedUsers([]);
-
-    const result = await findOrCreateUserForLeadEmail({
-      email: "  New.Person@Example.COM ",
-    });
-
-    expect(result).toEqual({
-      ok: true,
-      value: { userId: table[0]?.id, created: true },
-    });
-    expect(table).toHaveLength(1);
-    expect(table[0]).toMatchObject({
-      email: "new.person@example.com",
-      emailVerified: true,
-      role: "user",
-      name: null,
-    });
-    expect(prisma.user.create).toHaveBeenCalledTimes(1);
-    const [{ data }] = (prisma.user.create as jest.Mock).mock.calls[0] as [
-      { data: Record<string, unknown> },
-    ];
-    // D7a — no name copied from the anonymous payload; nothing nested that
-    // would create a relation row.
-    expect(Object.keys(data).sort()).toEqual(["email", "emailVerified", "role"]);
-    expect(prisma.account.create).not.toHaveBeenCalled();
-    expect(prisma.session.create).not.toHaveBeenCalled();
-    expect(prisma.membership.create).not.toHaveBeenCalled();
-  });
-
-  it("AC-4 / D2 — with an existing user, links to it and changes none of its fields", async () => {
-    const before = existingUser({ email: "ada@example.com" });
-    const table = seedUsers([before]);
-
-    const result = await findOrCreateUserForLeadEmail({ email: "ada@example.com" });
-
-    expect(result).toEqual({
-      ok: true,
-      value: { userId: before.id, created: false },
-    });
-    expect(table).toEqual([before]);
-    expect(prisma.user.create).not.toHaveBeenCalled();
-    expect(prisma.user.update).not.toHaveBeenCalled();
-  });
-
-  it("AC-10 / D7 — an existing `Foo@Example.com` is linked from a lead email `foo@example.com`; no user is created", async () => {
-    const before = existingUser({ email: "Foo@Example.com" });
-    const table = seedUsers([before]);
-
-    const result = await findOrCreateUserForLeadEmail({ email: "foo@example.com" });
-
-    expect(result).toEqual({
-      ok: true,
-      value: { userId: before.id, created: false },
-    });
-    expect(table).toHaveLength(1);
-    expect(prisma.user.create).not.toHaveBeenCalled();
-    expect(prisma.user.findFirst).toHaveBeenCalledWith(
-      expect.objectContaining({
-        where: { email: { equals: "foo@example.com", mode: "insensitive" } },
-        orderBy: { createdAt: "asc" },
-      }),
-    );
-  });
-
-  it("D7 — two case-variant rows for one mailbox link the OLDEST, with no distinct error", async () => {
-    const older = existingUser({
-      id: userId(2),
-      email: "foo@example.com",
-      createdAt: new Date("2026-01-01T00:00:00.000Z"),
-    });
-    const newer = existingUser({
-      id: userId(3),
-      email: "FOO@example.com",
-      createdAt: new Date("2026-02-01T00:00:00.000Z"),
-    });
-    seedUsers([newer, older]);
-
-    const result = await findOrCreateUserForLeadEmail({ email: "Foo@Example.com" });
-
-    expect(result).toEqual({
-      ok: true,
-      value: { userId: older.id, created: false },
-    });
-  });
-
-  it.each(["", "   ", "not-an-email", "ada@", "@example.com"])(
-    "D7 — a lead email that is not an address after trimming (%j) is invalid_email, and nothing is read or written",
-    async (email) => {
-      seedUsers([]);
-
-      const result = await findOrCreateUserForLeadEmail({ email });
-
-      expect(result).toEqual({ ok: false, error: { kind: "invalid_email" } });
-      expect(prisma.user.findFirst).not.toHaveBeenCalled();
-      expect(prisma.user.create).not.toHaveBeenCalled();
-    },
-  );
-
-  it("D8 — a create that loses a race (P2002) re-reads and links the winner with created: false", async () => {
-    const table = seedUsers([]);
-    // The concurrent winner lands between this call's read and its create.
-    (prisma.user.findFirst as jest.Mock).mockImplementationOnce(async () => {
-      table.push(existingUser({ id: userId(9), email: "race@example.com" }));
-      return null;
-    });
-
-    const result = await findOrCreateUserForLeadEmail({ email: "race@example.com" });
-
-    expect(result).toEqual({
-      ok: true,
-      value: { userId: userId(9), created: false },
-    });
-    expect(table).toHaveLength(1);
-    expect(prisma.user.create).toHaveBeenCalledTimes(1);
-  });
-
-  it("AC-8 — two concurrent calls for one email leave exactly one user, and both resolve to it", async () => {
-    const table = seedUsers([]);
-
-    const [a, b] = await Promise.all([
-      findOrCreateUserForLeadEmail({ email: "twice@example.com" }),
-      findOrCreateUserForLeadEmail({ email: "Twice@Example.com" }),
-    ]);
-
-    expect(table).toHaveLength(1);
-    // Both reached the create; the second hit P2002 and re-read (D8).
-    expect(prisma.user.create).toHaveBeenCalledTimes(2);
-    const id = table[0]?.id;
-    expect(a).toMatchObject({ ok: true, value: { userId: id } });
-    expect(b).toMatchObject({ ok: true, value: { userId: id } });
-    expect([a, b].filter((r) => r.ok && r.value.created)).toHaveLength(1);
-  });
-
-  it("SEC-006 — a Prisma failure is internal_error and never carries the Prisma message", async () => {
-    seedUsers([]);
-    (prisma.user.create as jest.Mock).mockRejectedValueOnce(
-      new Error("connection to db.internal:5432 failed for ada@example.com"),
-    );
-
-    const result = await findOrCreateUserForLeadEmail({ email: "ada@example.com" });
-
-    expect(result).toEqual({ ok: false, error: { kind: "internal_error" } });
-    expect(JSON.stringify(result)).not.toContain("ada@example.com");
-  });
-});