create-ailk 0.24.0 → 0.25.1

package/templates/apps/api/src/__tests__/factories/content-fixture.ts

@@ -1,138 +0,0 @@
-/**
- * @file content-fixture.ts
- * Filesystem fixture helpers for content route tests.
- *
- * Creates a per-test temp directory with minimal MDX fixture content,
- * points the content adapter at it via CONTENT_ROOT env, and cleans up
- * in afterEach. This allows content route tests to exercise the real
- * content adapter stack without mocking internal modules.
- *
- * Usage:
- *   import { setupContentFixture } from "../../__tests__/factories/content-fixture";
- *
- *   const { getContentRoot } = setupContentFixture();
- *
- * The setup/teardown hooks register themselves — call setupContentFixture()
- * at describe-scope and the beforeEach/afterEach run automatically.
- *
- * Issue #507: replaces jest.mock("../../../lib/content-adapter.js") in
- * content route tests.
- */
-
-import * as fs from "fs/promises";
-import * as os from "os";
-import * as path from "path";
-
-import { resetContentAdapter } from "../../lib/content-adapter.js";
-
-export interface ContentFixture {
-  /** Returns the current temp content root (changes per test). */
-  getContentRoot: () => string;
-  /**
-   * Write an additional MDX file into the fixture dir.
-   * type and slug are used to construct the path: <root>/<type>/<slug>.mdx
-   */
-  writeFixturePage: (
-    type: string,
-    slug: string,
-    frontmatter: Record<string, string>,
-    body?: string,
-  ) => Promise<void>;
-}
-
-/**
- * Register beforeEach/afterEach hooks that create a fresh temp dir per test,
- * set CONTENT_ROOT, and reset the adapter singleton.
- *
- * Returns a fixture handle for writing additional content from within tests.
- */
-export function setupContentFixture(): ContentFixture {
-  let contentRoot = "";
-
-  beforeEach(async () => {
-    contentRoot = await fs.mkdtemp(
-      path.join(os.tmpdir(), "ailk-api-content-test-"),
-    );
-
-    // Seed one fixture page per supported type so the adapter is not empty.
-    // Tests that need specific pages call writeFixturePage() themselves.
-    await Promise.all([
-      writeDefaultFixture(contentRoot, "HomePage", "home"),
-      writeDefaultFixture(contentRoot, "AboutPage", "about"),
-      writeDefaultFixture(contentRoot, "Product", "test-product"),
-    ]);
-
-    process.env.CONTENT_ROOT = contentRoot;
-    resetContentAdapter();
-  });
-
-  afterEach(async () => {
-    delete process.env.CONTENT_ROOT;
-    resetContentAdapter();
-
-    // Best-effort cleanup — don't fail the test if temp dir can't be removed.
-    try {
-      await fs.rm(contentRoot, { recursive: true, force: true });
-    } catch {
-      // ignore
-    }
-    contentRoot = "";
-  });
-
-  return {
-    getContentRoot: () => contentRoot,
-    writeFixturePage: (type, slug, frontmatter, body = "") =>
-      writeFixturePage(contentRoot, type, slug, frontmatter, body),
-  };
-}
-
-// ─── Internal helpers ─────────────────────────────────────────────────────────
-
-async function writeDefaultFixture(
-  root: string,
-  type: string,
-  slug: string,
-): Promise<void> {
-  await writeFixturePage(
-    root,
-    type,
-    slug,
-    {
-      type,
-      slug,
-      title: `${type} ${slug} title`,
-      description: `${type} ${slug} description`,
-    },
-    `Default fixture body for ${type}/${slug}.`,
-  );
-}
-
-async function writeFixturePage(
-  root: string,
-  type: string,
-  slug: string,
-  frontmatter: Record<string, string>,
-  body = "",
-): Promise<void> {
-  // Write the fixture in TWO places:
-  //   1. <root>/en/<type>/<slug>.mdx — post-S2 locale-prefixed read path
-  //      (callers passing an explicit locale find pages here).
-  //   2. <root>/<type>/<slug>.mdx — legacy write path. The adapter's write
-  //      methods (createPage/updatePage/deletePage) still write here in
-  //      Phase 3 S3 per the S1 spec ("locale-aware writes deferred"), so
-  //      write-route tests assert against this layout.
-  // Duplicating the fixture keeps both read and write test paths happy until
-  // write tools learn the locale-prefixed layout.
-  const fmLines = Object.entries(frontmatter)
-    .map(([k, v]) => `${k}: "${v}"`)
-    .join("\n");
-  const content = `---\n${fmLines}\n---\n\n${body}\n`;
-
-  const localeDir = path.join(root, "en", type);
-  await fs.mkdir(localeDir, { recursive: true });
-  await fs.writeFile(path.join(localeDir, `${slug}.mdx`), content, "utf8");
-
-  const legacyDir = path.join(root, type);
-  await fs.mkdir(legacyDir, { recursive: true });
-  await fs.writeFile(path.join(legacyDir, `${slug}.mdx`), content, "utf8");
-}

package/templates/apps/api/src/__tests__/factories/in-memory-prisma.ts

@@ -1,441 +0,0 @@
-/**
- * @file in-memory-prisma.ts
- *
- * An in-memory, where-clause-honouring Prisma double, shared by the route
- * suites that register every tenant-guarded route plugin behind the real auth
- * and tenant preHandlers (`routes/workspaces/__tests__/member-operates.test.ts`,
- * #7636, and `agent-guard-parity.test.ts`, #3591).
- *
- * Every delegate call is recorded on `__calls` and the store is exposed on
- * `__db`, so a refusal can be shown to read nothing. A relation filter the
- * double does not model throws, so scoping that rides on one can never pass
- * for the wrong reason.
- *
- * Unique keys (#852 D13). A model listed in `UNIQUE_KEYS` enforces its
- * declared compound keys the way Postgres does (NULLs distinct): `createMany`
- * with `skipDuplicates` skips a conflicting row (`ON CONFLICT DO NOTHING`),
- * and a `create`, a `createMany` without it, or an `updateMany` that would
- * give two rows one key throws `{ code: "P2002" }`. `flowDefinition` declares
- * its `(siteId, slug)` key (#8515); a suite that pushes rows onto `__db`
- * directly never reaches the check.
- *
- * Member area (#7877 D17). `piece`, `interaction` and `workspacePieceStages`
- * are ordinary delegates here — `where` on `workspaceId`, `personId`, `id`,
- * `channel`, `direction`, `readAt: null` and `id: { in }`, and
- * `orderBy`/`take`, all honoured as for any model — minted with their
- * registry prefixes (`piece_`, `intx_`, `pstages_`) so a boundary id check
- * accepts them, and one stage list per workspace is a declared unique key.
- *
- * Raw reads (#852 D13). `$queryRawUnsafe` is one recorded `jest.fn` per
- * double (as are `$transaction` and `$executeRaw`, #7877); each call answers the next entry of the `__rawResults` queue
- * (default `[]` when the queue is empty) — an `Error` entry is thrown.
- *
- * Usage — the factory must run inside the hoisted `jest.mock` callback:
- *
- *   jest.mock("../../../lib/prisma.js", () =>
- *     jest
- *       .requireActual<typeof import("../../../__tests__/factories/in-memory-prisma")>(
- *         "../../../__tests__/factories/in-memory-prisma",
- *       )
- *       .createInMemoryPrisma(),
- *   );
- */
-export function createInMemoryPrisma(): { prisma: Record<string, unknown> } {
-  type Row = Record<string, unknown>;
-  type Where = Record<string, unknown>;
-  const db: Record<string, Row[]> = {};
-  const calls: Array<{ model: string; op: string }> = [];
-  const OPS = new Set([
-    "in",
-    "notIn",
-    "lt",
-    "lte",
-    "gt",
-    "gte",
-    "not",
-    "equals",
-    "startsWith",
-    "endsWith",
-    "contains",
-    "has",
-    "hasSome",
-    "mode",
-    "path",
-  ]);
-  const isPlain = (v: unknown): v is Record<string, unknown> =>
-    v !== null &&
-    typeof v === "object" &&
-    !Array.isArray(v) &&
-    !(v instanceof Date);
-  const norm = (v: unknown) => (v instanceof Date ? v.getTime() : (v ?? null));
-  const eq = (a: unknown, b: unknown) => norm(a) === norm(b);
-  const cmp = (a: unknown, b: unknown) => {
-    const x = norm(a) as number;
-    const y = norm(b) as number;
-    return x < y ? -1 : x > y ? 1 : 0;
-  };
-  const table = (model: string) => (db[model] ??= []);
-  const UNIQUE_KEYS: Record<string, string[][]> = {
-    person: [
-      ["workspaceId", "email"],
-      ["workspaceId", "userId"],
-    ],
-    workspacePieceStages: [["workspaceId"]],
-    // #8515 D2 — `@@unique([siteId, slug])`, so the onboarding seed's
-    // `createMany({ skipDuplicates })` is insert-only here as in Postgres.
-    flowDefinition: [["siteId", "slug"]],
-  };
-  /** Column defaults a create omits, as the schema declares them. */
-  const DEFAULTS: Record<string, Row> = {
-    // #8435 — a created Person carries every nullable column the way Postgres
-    // would read it back: `null`, not absent. The contact fill reads `null` as
-    // "blank" and `undefined` as "not mine to touch".
-    person: {
-      userId: null,
-      givenName: null,
-      familyName: null,
-      telephone: null,
-      addressLine1: null,
-      addressLine2: null,
-      addressCity: null,
-      addressRegion: null,
-      addressPostalCode: null,
-      addressCountry: null,
-      companyName: null,
-      jobTitle: null,
-      contactConfirmedAt: null,
-      contactConfirmedBy: null,
-    },
-    // #8516 D1 — the column default and the seven nullable proposal columns.
-    piece: {
-      needsClient: false,
-      kind: "deliverable",
-      approvedAt: null,
-      priceAmount: null,
-      priceCurrency: null,
-      checkoutSessionId: null,
-      checkoutUrl: null,
-      checkoutExpiresAt: null,
-      paidAt: null,
-      paidSessionId: null,
-    },
-    interaction: { assetId: null, readAt: null },
-    // #9070 D1 — the shown Price ids' column default, as Postgres reads it back.
-    workspaceOfferings: { shownPriceIds: [] },
-  };
-  /** A model whose registry prefix is not its delegate name (`packages/ids`). */
-  const ID_PREFIX: Record<string, string> = {
-    interaction: "intx",
-    // #8515 — a created workspace is a `wksp_` id, so the onboarding seed's
-    // id check accepts it.
-    workspace: "wksp",
-    workspacePieceStages: "pstages",
-  };
-  /** Whether `row` would share a declared unique key with another row. */
-  function conflicts(model: string, row: Row, except?: Row): boolean {
-    return (UNIQUE_KEYS[model] ?? []).some((key) =>
-      key.every((k) => row[k] != null)
-        ? table(model).some(
-            (other) =>
-              other !== except && key.every((k) => eq(other[k], row[k])),
-          )
-        : false,
-    );
-  }
-  const uniqueViolation = () =>
-    Object.assign(new Error("Unique constraint failed"), { code: "P2002" });
-  const rawResults: unknown[] = [];
-
-  function matchCond(value: unknown, cond: unknown): boolean {
-    if (cond === undefined) return true;
-    if (!isPlain(cond)) return eq(value, cond);
-    const keys = Object.keys(cond);
-    if (!keys.every((k) => OPS.has(k))) {
-      // A nested filter is matched against a nested value. A relation filter
-      // this double does not model fails loudly, so scoping that rides on
-      // one can never pass for the wrong reason.
-      if (
-        keys.some((k) =>
-          ["some", "none", "every", "is", "isNot"].includes(k),
-        ) ||
-        !isPlain(value)
-      ) {
-        throw new Error(
-          `in-memory prisma: unmodelled filter ${JSON.stringify(keys)}`,
-        );
-      }
-      return matches(value, cond);
-    }
-    if ("path" in cond) {
-      const path = cond.path as string[];
-      let nested: unknown = value;
-      for (const p of path) nested = isPlain(nested) ? nested[p] : undefined;
-      const { path: _p, ...rest } = cond;
-      return matchCond(nested, rest);
-    }
-    for (const [op, arg] of Object.entries(cond)) {
-      switch (op) {
-        case "in":
-          if (!(arg as unknown[]).some((v) => eq(value, v))) return false;
-          break;
-        case "notIn":
-          if ((arg as unknown[]).some((v) => eq(value, v))) return false;
-          break;
-        case "lt":
-          if (value == null || cmp(value, arg) >= 0) return false;
-          break;
-        case "lte":
-          if (value == null || cmp(value, arg) > 0) return false;
-          break;
-        case "gt":
-          if (value == null || cmp(value, arg) <= 0) return false;
-          break;
-        case "gte":
-          if (value == null || cmp(value, arg) < 0) return false;
-          break;
-        case "not":
-          if (matchCond(value, arg)) return false;
-          break;
-        case "equals":
-          if (!eq(value, arg)) return false;
-          break;
-        case "startsWith":
-          if (typeof value !== "string" || !value.startsWith(arg as string))
-            return false;
-          break;
-        case "endsWith":
-          if (typeof value !== "string" || !value.endsWith(arg as string))
-            return false;
-          break;
-        case "contains":
-          if (typeof value !== "string" || !value.includes(arg as string))
-            return false;
-          break;
-        case "has":
-          if (!Array.isArray(value) || !value.includes(arg)) return false;
-          break;
-        case "hasSome":
-          if (
-            !Array.isArray(value) ||
-            !(arg as unknown[]).some((v) => value.includes(v))
-          ) {
-            return false;
-          }
-          break;
-        default:
-          break;
-      }
-    }
-    return true;
-  }
-
-  function matches(row: Row, where: Where | undefined): boolean {
-    for (const [key, cond] of Object.entries(where ?? {})) {
-      if (key === "AND") {
-        const all = Array.isArray(cond) ? cond : [cond];
-        if (!all.every((w) => matches(row, w as Where))) return false;
-      } else if (key === "OR") {
-        if (!(cond as Where[]).some((w) => matches(row, w))) return false;
-      } else if (key === "NOT") {
-        const all = Array.isArray(cond) ? cond : [cond];
-        if (all.some((w) => matches(row, w as Where))) return false;
-      } else if (
-        !(key in row) &&
-        isPlain(cond) &&
-        !Object.keys(cond).every((k) => OPS.has(k))
-      ) {
-        if (!matches(row, cond)) return false;
-      } else if (!matchCond(row[key], cond)) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  function pick(value: unknown, select: unknown): unknown {
-    if (!isPlain(select) || value == null) return value;
-    if (Array.isArray(value)) return value.map((v) => pick(v, select));
-    if (!isPlain(value)) return value;
-    const out: Row = {};
-    for (const [key, spec] of Object.entries(select)) {
-      if (spec === true) out[key] = value[key];
-      else if (isPlain(spec) && key in value) {
-        out[key] = pick(value[key], (spec as Row).select ?? spec);
-      }
-    }
-    return out;
-  }
-
-  function sorted(rows: Row[], orderBy: unknown): Row[] {
-    if (!orderBy) return rows;
-    const orders = (Array.isArray(orderBy) ? orderBy : [orderBy]) as Array<
-      Record<string, string>
-    >;
-    return [...rows].sort((a, b) => {
-      for (const ord of orders) {
-        const [field, dir] = Object.entries(ord)[0] as [string, string];
-        const c = cmp(a[field], b[field]);
-        if (c !== 0) return dir === "desc" ? -c : c;
-      }
-      return 0;
-    });
-  }
-
-  let seq = 0;
-  function apply(row: Row, data: Row): Row {
-    for (const [key, value] of Object.entries(data)) {
-      if (isPlain(value) && "increment" in value) {
-        row[key] = ((row[key] as number) ?? 0) + (value.increment as number);
-      } else if (isPlain(value) && "set" in value) {
-        row[key] = value.set;
-      } else {
-        row[key] = value;
-      }
-    }
-    row["updatedAt"] = new Date();
-    return row;
-  }
-
-  function delegate(model: string) {
-    const log = (op: string) => calls.push({ model, op });
-    const findMany = (args: Row = {}) => {
-      let rows = sorted(
-        table(model).filter((r) => matches(r, args.where as Where)),
-        args.orderBy,
-      );
-      if (typeof args.skip === "number") rows = rows.slice(args.skip);
-      if (typeof args.take === "number") rows = rows.slice(0, args.take);
-      return rows.map(
-        (r) => pick({ ...r }, args.select ?? args.include) as Row,
-      );
-    };
-    const build = (data: Row): Row => ({
-      // A registry-shaped id, so an `isId` boundary check accepts it.
-      id: `${ID_PREFIX[model] ?? model}_00000000-0000-7000-8000-${String(++seq).padStart(12, "0")}`,
-      createdAt: new Date(),
-      updatedAt: new Date(),
-      ...DEFAULTS[model],
-      ...data,
-    });
-    const create = (args: Row) => {
-      const row = build(args.data as Row);
-      if (conflicts(model, row)) throw uniqueViolation();
-      table(model).push(row);
-      return pick({ ...row }, args.select);
-    };
-    return {
-      findMany: jest.fn(
-        async (args: Row = {}) => (log("findMany"), findMany(args)),
-      ),
-      findFirst: jest.fn(
-        async (args: Row = {}) => (log("findFirst"), findMany(args)[0] ?? null),
-      ),
-      findUnique: jest.fn(
-        async (args: Row = {}) => (
-          log("findUnique"),
-          findMany(args)[0] ?? null
-        ),
-      ),
-      findUniqueOrThrow: jest.fn(async (args: Row = {}) => {
-        log("findUniqueOrThrow");
-        const row = findMany(args)[0];
-        if (!row) throw new Error(`${model} not found`);
-        return row;
-      }),
-      count: jest.fn(
-        async (args: Row = {}) => (
-          log("count"),
-          findMany({ where: args.where }).length
-        ),
-      ),
-      create: jest.fn(async (args: Row) => (log("create"), create(args))),
-      createMany: jest.fn(async (args: Row) => {
-        log("createMany");
-        let count = 0;
-        for (const data of args.data as Row[]) {
-          const row = build(data);
-          if (conflicts(model, row)) {
-            if (args.skipDuplicates === true) continue;
-            throw uniqueViolation();
-          }
-          table(model).push(row);
-          count += 1;
-        }
-        return { count };
-      }),
-      update: jest.fn(async (args: Row) => {
-        log("update");
-        const row = table(model).find((r) => matches(r, args.where as Where));
-        if (!row) throw new Error(`${model} not found`);
-        return pick({ ...apply(row, args.data as Row) }, args.select);
-      }),
-      updateMany: jest.fn(async (args: Row) => {
-        log("updateMany");
-        const rows = table(model).filter((r) =>
-          matches(r, args.where as Where),
-        );
-        for (const row of rows) {
-          if (conflicts(model, { ...row, ...(args.data as Row) }, row)) {
-            throw uniqueViolation();
-          }
-        }
-        for (const row of rows) apply(row, args.data as Row);
-        return { count: rows.length };
-      }),
-      upsert: jest.fn(async (args: Row) => {
-        log("upsert");
-        const row = table(model).find((r) => matches(r, args.where as Where));
-        if (row)
-          return pick({ ...apply(row, args.update as Row) }, args.select);
-        return create({ data: args.create, select: args.select });
-      }),
-      deleteMany: jest.fn(async (args: Row = {}) => {
-        log("deleteMany");
-        const before = table(model).length;
-        db[model] = table(model).filter(
-          (r) => !matches(r, args.where as Where),
-        );
-        return { count: before - table(model).length };
-      }),
-      groupBy: jest.fn(async () => (log("groupBy"), [])),
-      aggregate: jest.fn(
-        async () => (
-          log("aggregate"),
-          { _count: {}, _sum: {}, _max: {}, _min: {} }
-        ),
-      ),
-    };
-  }
-
-  const delegates: Record<string, ReturnType<typeof delegate>> = {};
-  const queryRawUnsafe = jest.fn(async (..._args: unknown[]) => {
-    const next = rawResults.length > 0 ? rawResults.shift() : [];
-    if (next instanceof Error) throw next;
-    return next;
-  });
-  // Recorded, so a suite can see a lock statement ran first in its
-  // transaction (#7877 D9): an interactive callback runs on this double.
-  const transaction = jest.fn(async (arg: unknown) =>
-    typeof arg === "function"
-      ? (arg as (tx: unknown) => unknown)(prisma)
-      : Promise.all(arg as Promise<unknown>[]),
-  );
-  const executeRaw = jest.fn(async (..._args: unknown[]) => 0);
-  const prisma: Record<string, unknown> = new Proxy(
-    {},
-    {
-      get(_target, prop) {
-        if (prop === "__db") return db;
-        if (prop === "__calls") return calls;
-        if (prop === "__rawResults") return rawResults;
-        if (prop === "$queryRawUnsafe") return queryRawUnsafe;
-        if (prop === "$transaction") return transaction;
-        if (prop === "$executeRaw") return executeRaw;
-        if (prop === "$queryRaw") return async () => [];
-        if (typeof prop !== "string" || prop === "then") return undefined;
-        return (delegates[prop] ??= delegate(prop));
-      },
-    },
-  );
-  return { prisma };
-}

package/templates/apps/api/src/__tests__/factories/index.ts

@@ -1,70 +0,0 @@
-/**
- * @file factories/index.ts
- * Typed test data factories for apps/api route tests.
- *
- * Each factory returns a fully-typed object with all required fields populated.
- * Pass overrides to vary only the fields relevant to the test case.
- *
- * Used by: content, leads, checkout route tests (Issue #507 real-dependency refactor).
- */
-
-import type { ContentPage } from "@working-theory/content-adapters";
-import type { Lead, LeadCaptureRecord } from "@working-theory/validation";
-
-// ─── Content factories ────────────────────────────────────────────────────────
-
-export type ContentPageOverrides = Partial<ContentPage>;
-
-/**
- * Build a fully-typed ContentPage. Defaults to a HomePage with deterministic values.
- */
-export function buildContent(
-  overrides: ContentPageOverrides = {},
-): ContentPage {
-  return {
-    type: "HomePage",
-    slug: "test-page",
-    title: "Test Page Title",
-    description: "A test page description for automated tests.",
-    ...overrides,
-  };
-}
-
-// ─── Lead factories ───────────────────────────────────────────────────────────
-
-export type LeadOverrides = Partial<Lead>;
-
-/**
- * Build a fully-typed Lead record (as returned by the DB / written to file).
- */
-export function buildLead(overrides: LeadOverrides = {}): Lead {
-  return {
-    id: "test-lead-id-00000001",
-    siteId: "test-site-abc",
-    source: "contact",
-    email: "test@example.com",
-    payload: { message: "Hello from factory" },
-    createdAt: new Date().toISOString(),
-    ...overrides,
-  };
-}
-
-// ─── LeadCaptureRecord factories ──────────────────────────────────────────────
-
-export type LeadCaptureRecordOverrides = Partial<LeadCaptureRecord>;
-
-/**
- * Build a fully-typed LeadCaptureRecord (as written to the JSONL capture file).
- */
-export function buildLeadCaptureRecord(
-  overrides: LeadCaptureRecordOverrides = {},
-): LeadCaptureRecord {
-  return {
-    id: "test-capture-id-00000001",
-    createdAt: new Date().toISOString(),
-    source: "contact",
-    data: { email: "test@example.com" },
-    metadata: {},
-    ...overrides,
-  };
-}