create-ailk 0.24.0 → 0.26.0

package/templates/database/__tests__/flow-completion-migration.test.ts

@@ -1,115 +0,0 @@
-/**
- * @file flow-completion-migration.test.ts
- *
- * DB-free proof of the flow_completion migration's shape (#8757, spec
- * docs/specs/8757-a-per-magnet-completion-setting-spec.md D2, AC-2). Reads
- * the migration's own text: it adds exactly the two columns and three named
- * CHECKs, each added `NOT VALID` then `VALIDATE`d, and its one `UPDATE` is the
- * slug backfill between its markers — naming exactly the standard magnets
- * whose default is `invite` (`STANDARD_MAGNET_COMPLETIONS`). It inserts and
- * deletes nothing. The live-database half is `flow-completion.db.test.ts`.
- */
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-import { STANDARD_MAGNET_COMPLETIONS } from "@working-theory/validation";
-
-const MIGRATION = join(
-  __dirname,
-  "..",
-  "migrations",
-  "20261018120000_flow_completion",
-  "migration.sql",
-);
-
-const CHECKS = [
-  "flow_definitions_completion_domain",
-  "flow_definitions_checkout_offering_pair",
-  "flow_definitions_checkout_offering_format",
-];
-
-/** The migration's statements, comments stripped, whitespace collapsed. */
-function statements(): string[] {
-  const text = readFileSync(MIGRATION, "utf8")
-    .split("\n")
-    .filter((line) => !line.trimStart().startsWith("--"))
-    .join("\n");
-  return text
-    .split(";")
-    .map((s) => s.replace(/\s+/g, " ").trim())
-    .filter((s) => s.length > 0);
-}
-
-/** The text between the `-- BEGIN completion backfill` / `-- END …` markers. */
-function backfillBlock(): string {
-  const match = /-- BEGIN completion backfill\n([\s\S]*?)-- END completion backfill/.exec(
-    readFileSync(MIGRATION, "utf8"),
-  );
-  if (!match) throw new Error("completion backfill markers not found");
-  return match[1]!;
-}
-
-describe("the flow_completion migration (#8757 D2, AC-2)", () => {
-  it("adds exactly the two columns, the completion default lead", () => {
-    const adds = statements().filter((s) => /^ALTER TABLE "flow_definitions" ADD COLUMN /.test(s));
-    expect(adds).toHaveLength(1);
-    const columns = adds[0]!.split(/ADD COLUMN /).slice(1).map((c) => c.trim().replace(/,$/, ""));
-    expect(columns).toEqual([
-      `"completion" VARCHAR(16) NOT NULL DEFAULT 'lead'`,
-      `"checkout_offering" VARCHAR(40)`,
-    ]);
-  });
-
-  it("adds the three named CHECKs NOT VALID, then VALIDATEs each", () => {
-    const all = statements();
-    const added = all
-      .map((s) => /^ALTER TABLE "flow_definitions" ADD CONSTRAINT "([a-z_]+)" CHECK \(.*\) NOT VALID$/.exec(s)?.[1])
-      .filter((name): name is string => name !== undefined);
-    const validated = all
-      .map((s) => /^ALTER TABLE "flow_definitions" VALIDATE CONSTRAINT "([a-z_]+)"$/.exec(s)?.[1])
-      .filter((name): name is string => name !== undefined);
-    expect(added).toEqual(CHECKS);
-    expect(validated).toEqual(CHECKS);
-    for (const name of CHECKS) {
-      expect(all.findIndex((s) => s.includes(`VALIDATE CONSTRAINT "${name}"`))).toBeGreaterThan(
-        all.findIndex((s) => s.includes(`ADD CONSTRAINT "${name}"`)),
-      );
-    }
-  });
-
-  it("holds exactly one UPDATE, inside the backfill markers, naming the invite defaults", () => {
-    const updates = statements().filter((s) => /\bUPDATE\b/i.test(s));
-    expect(updates).toHaveLength(1);
-    const block = backfillBlock().replace(/\s+/g, " ").trim();
-    expect(block).toBe(updates[0] + ";");
-    const list = /WHERE "slug" IN \(([^)]*)\)/.exec(block)?.[1];
-    const slugs = (list ?? "").split(",").map((s) => s.trim().replace(/^'|'$/g, ""));
-    const invite = Object.entries(STANDARD_MAGNET_COMPLETIONS)
-      .filter(([, completion]) => completion === "invite")
-      .map(([slug]) => slug);
-    expect([...slugs].sort()).toEqual([...invite].sort());
-    expect(block).toContain(`SET "completion" = 'invite'`);
-  });
-
-  it("inserts and deletes nothing", () => {
-    for (const s of statements()) expect(s).not.toMatch(/\b(INSERT|DELETE)\b/i);
-  });
-
-  it("every statement is one of the expected shapes", () => {
-    const unexpected = statements().filter(
-      (s) =>
-        !/^ALTER TABLE "flow_definitions" (ADD COLUMN|ADD CONSTRAINT|VALIDATE CONSTRAINT) /.test(s) &&
-        !/^UPDATE "flow_definitions" SET "completion" = 'invite' WHERE "slug" IN \(/.test(s),
-    );
-    expect(unexpected).toEqual([]);
-  });
-
-  it("schema.prisma declares both fields on FlowDefinition", () => {
-    const prisma = readFileSync(join(__dirname, "..", "inbox", "schema.prisma"), "utf8");
-    const model = /model FlowDefinition \{([\s\S]*?)\n\}/.exec(prisma)?.[1] ?? "";
-    expect(model).toMatch(/\n\s*completion String @default\("lead"\) @db\.VarChar\(16\)\n/);
-    expect(model).toMatch(
-      /\n\s*checkoutOffering String\? @map\("checkout_offering"\) @db\.VarChar\(40\)\n/,
-    );
-  });
-});

package/templates/database/__tests__/flow-completion.db.test.ts

@@ -1,136 +0,0 @@
-/**
- * @file flow-completion.db.test.ts
- *
- * LIVE-DATABASE proof of a magnet's completion columns (#8757, spec
- * docs/specs/8757-a-per-magnet-completion-setting-spec.md D2, AC-2). Requires
- * DATABASE_URL pointing at a Postgres with the migrations applied — SKIPS
- * when DATABASE_URL is unset (the repo convention; the `apps/api Route Tests
- * (Postgres)` workflow exercises it).
- *
- * Uses the `pg` driver directly, in ONE transaction that is rolled back. What
- * it proves that a mock cannot:
- *   1. The migration's backfill block, run over magnets at the five slugs,
- *      leaves `contact` and `form` at `lead` and sets the three process
- *      magnets to `invite`; a second run changes nothing.
- *   2. Each CHECK refuses what it names.
- */
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-import { Client } from "pg";
-
-const describeDb = process.env.DATABASE_URL ? describe : describe.skip;
-
-const MIGRATION_SQL = readFileSync(
-  join(__dirname, "..", "migrations", "20261018120000_flow_completion", "migration.sql"),
-  "utf8",
-);
-
-/** The text between the `-- BEGIN completion backfill` / `-- END …` markers. */
-function backfillBlock(sql: string): string {
-  const match = /-- BEGIN completion backfill\n([\s\S]*?)-- END completion backfill/.exec(sql);
-  if (!match?.[1]) throw new Error("completion backfill markers not found");
-  return match[1];
-}
-
-const WS = "wksp_01920000-8757-7000-8000-0000000000c1";
-const SLUGS = ["contact", "onboarding", "request-quote", "job-application", "form"] as const;
-
-describeDb("the magnet completion columns (#8757 D2, AC-2, live DB)", () => {
-  let db: Client;
-
-  beforeAll(async () => {
-    db = new Client({ connectionString: process.env.DATABASE_URL });
-    await db.connect();
-    await db.query("BEGIN");
-  });
-
-  afterAll(async () => {
-    await db.query("ROLLBACK");
-    await db.end();
-  });
-
-  /** Insert one magnet at `slug`, with any of the completion columns. */
-  const insertMagnet = (slug: string, cols: Record<string, unknown> = {}) => {
-    const all: Record<string, unknown> = {
-      site_id: WS,
-      workspace_id: WS,
-      slug,
-      config: JSON.stringify({ steps: [] }),
-      title: `Magnet ${slug}`,
-      status: "draft",
-      updated_at: new Date("2026-10-01T09:00:00.000Z"),
-      ...cols,
-    };
-    const names = Object.keys(all);
-    return db.query<{ id: string }>(
-      `INSERT INTO "flow_definitions" (${names.map((n) => `"${n}"`).join(", ")})
-       VALUES (${names.map((_, i) => `$${i + 1}`).join(", ")}) RETURNING "id"`,
-      names.map((n) => all[n]),
-    );
-  };
-
-  /** Run `run` inside a savepoint; resolve to the violated constraint's name, or null. */
-  const violation = async (run: () => Promise<unknown>): Promise<string | null> => {
-    await db.query("SAVEPOINT attempt");
-    try {
-      await run();
-      await db.query("RELEASE SAVEPOINT attempt");
-      return null;
-    } catch (err) {
-      await db.query("ROLLBACK TO SAVEPOINT attempt");
-      return (err as { constraint?: string }).constraint ?? String(err);
-    }
-  };
-
-  const completions = async () =>
-    Object.fromEntries(
-      (
-        await db.query<{ slug: string; completion: string; checkout_offering: string | null }>(
-          `SELECT "slug", "completion", "checkout_offering" FROM "flow_definitions" WHERE "workspace_id" = $1`,
-          [WS],
-        )
-      ).rows.map((r) => [r.slug, [r.completion, r.checkout_offering]]),
-    );
-
-  it("the backfill sets the three process magnets to invite and leaves contact and form at lead, idempotently", async () => {
-    for (const slug of SLUGS) await insertMagnet(slug);
-    const before = await completions();
-    for (const slug of SLUGS) expect(before[slug]).toEqual(["lead", null]);
-
-    await db.query(backfillBlock(MIGRATION_SQL));
-    const after = await completions();
-    expect(after).toEqual({
-      contact: ["lead", null],
-      form: ["lead", null],
-      onboarding: ["invite", null],
-      "request-quote": ["invite", null],
-      "job-application": ["invite", null],
-    });
-
-    const rerun = await db.query(backfillBlock(MIGRATION_SQL));
-    expect(await completions()).toEqual(after);
-    // The re-run matches the same rows but stores the same values.
-    expect(rerun.rowCount).toBeGreaterThanOrEqual(3);
-  });
-
-  it.each([
-    ["checkout with no offering", { completion: "checkout", checkout_offering: null }, "flow_definitions_checkout_offering_pair"],
-    ["an offering beside lead", { completion: "lead", checkout_offering: "retainer" }, "flow_definitions_checkout_offering_pair"],
-    ["a capitalised key", { completion: "checkout", checkout_offering: "Bad" }, "flow_definitions_checkout_offering_format"],
-    ["an underscored key", { completion: "checkout", checkout_offering: "a_b" }, "flow_definitions_checkout_offering_format"],
-    ["a fourth value", { completion: "other", checkout_offering: null }, "flow_definitions_completion_domain"],
-  ])("refuses %s", async (_label, cols, constraint) => {
-    expect(await violation(() => insertMagnet(`refused-${constraint.length}-${String(cols.completion)}`, cols))).toBe(
-      constraint,
-    );
-  });
-
-  it("accepts checkout with a listed-shape offering", async () => {
-    expect(
-      await violation(() =>
-        insertMagnet("paid-waitlist", { completion: "checkout", checkout_offering: "retainer" }),
-      ),
-    ).toBeNull();
-  });
-});

package/templates/database/__tests__/flow-workspace-key.db.test.ts

@@ -1,263 +0,0 @@
-/**
- * @file flow-workspace-key.db.test.ts
- *
- * LIVE-DATABASE proof of the #6155 backfill (spec § 8.4, AC-1). Requires
- * DATABASE_URL pointing at a Postgres with the migrations applied (`prisma
- * migrate deploy`); the whole suite SKIPS when DATABASE_URL is unset,
- * matching `prefixed-ids.db.test.ts` / `artifact-content-store.db.test.ts`
- * and keeping the workspace Jest run DB-free.
- *
- * Raw SQL through `pg`, for the same reason those two files give: the
- * generated Prisma client is ESM-only and cannot load under this package's
- * CJS ts-jest transform.
- *
- * RECONCILED WITH #6254 (the tenancy-fence keystone, #6373 AC-4). The
- * ORIGINAL "RE-RUN TECHNIQUE" this file used — insert fresh
- * `workspace_id IS NULL` rows, then re-execute this migration's own SQL
- * verbatim to prove its backfill logic — assumed a row COULD land with
- * `workspace_id` unset. That assumption is no longer true on current main:
- * `database/migrations/20260922120000_tenancy_fence` retrofits
- * `flow_definitions.workspace_id` / `flow_sessions.workspace_id` to NOT
- * NULL, plus a `CHECK (workspace_id = site_id)` equality and a
- * `CHECK (workspace_id ~ '^wksp_...')` format constraint on BOTH tables.
- * Together those three constraints mean:
- *
- *   - `site_id` must now ALWAYS be a well-formed `wksp_` id equal to
- *     `workspace_id` — the legacy alias `"default"` (never `wksp_`-shaped)
- *     and an arbitrary unresolvable string can no longer be written at all,
- *     with or without `workspace_id` supplied. Attempting either now aborts
- *     the write outright (a NOT NULL / CHECK violation), rather than landing
- *     a row with `workspace_id` left NULL — this is the fence doing exactly
- *     what its own migration text says an unresolvable row must do ("abort
- *     the transaction rather than pass through silently").
- *   - The `"default"` alias itself is resolved at the APPLICATION layer
- *     before a write reaches the database now (the fence migration's own
- *     header: "the application-code half of D1a... is fixed in the same
- *     PR") — a fresh row's `site_id` is never the literal string `"default"`
- *     on live main, only ever the resolved `DEFAULT_WORKSPACE_ID` sentinel.
- *
- * So this suite's three cases are reconciled to what main actually does:
- *
- *   1. A row whose `site_id` names a real workspace carries a matching
- *      `workspace_id` from the moment it is written (the shape the OLD
- *      backfill used to produce is now enforced at write time), and is
- *      readable through the shape `tenantDb(tenant).flows.byId` /
- *      `.flowSessions.byId` use (`findFirst({ id, workspaceId })`). The
- *      shipped `20260919120000_flow_workspace_key` migration is STILL
- *      re-run verbatim afterward — every `workspace_id IS NULL` row it
- *      would touch is now unreachable, so this proves the migration stays
- *      safely re-runnable (NFR3) rather than corrupting an already-correct
- *      row, not that it backfills one.
- *   2. A row whose `site_id` matches no workspace can no longer be created
- *      at all — inserting it (with `workspace_id` omitted, exactly the
- *      pre-fence shape) is REJECTED by the NOT NULL constraint the fence
- *      added, never landed unset.
- *   3. A row whose `site_id` is the resolved sentinel `DEFAULT_WORKSPACE_ID`
- *      — what the legacy `"default"` alias now resolves to before any write
- *      reaches the database — carries a matching `workspace_id` from the
- *      moment it is written, exactly like case 1.
- *   4. The literal sentinel id written into the migration's own SQL text
- *      equals `DEFAULT_WORKSPACE_ID` from `../tenancy.js` — read from the
- *      `.sql` file and compared, so the two cannot drift apart (§ 5.3
- *      step 5). Unaffected by the fence — no DB write involved.
- */
-import { randomUUID } from "node:crypto";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-import { Client } from "pg";
-
-import { DEFAULT_WORKSPACE_ID } from "../tenancy.js";
-
-const describeDb = process.env.DATABASE_URL ? describe : describe.skip;
-
-/** A run-unique suffix so repeated local runs never collide. */
-const RUN = randomUUID().slice(0, 8);
-
-const MIGRATION_SQL_PATH = join(
-  __dirname,
-  "..",
-  "migrations",
-  "20260919120000_flow_workspace_key",
-  "migration.sql",
-);
-const MIGRATION_SQL = readFileSync(MIGRATION_SQL_PATH, "utf-8");
-
-describeDb(
-  "flow_definitions / flow_sessions workspace_id backfill (#6155, live DB)",
-  () => {
-    let db: Client;
-    let otherWorkspaceId: string;
-    const noSuchSite = `no-such-site-${RUN}`;
-
-    const definitionIds: string[] = [];
-    const sessionIds: string[] = [];
-
-    beforeAll(async () => {
-      db = new Client({ connectionString: process.env.DATABASE_URL });
-      await db.connect();
-
-      // A REAL, non-sentinel workspace — the "pinned, resolvable" case (rule 3:
-      // exact `workspaces.id` equality, nothing to do with the sentinel).
-      const org = (
-        await db.query<{ id: string }>(
-          `INSERT INTO "organizations" ("name", "slug", "updated_at")
-         VALUES ($1, $2, now()) RETURNING "id"`,
-          [`6155 Org ${RUN}`, `6155-org-${RUN}`],
-        )
-      ).rows[0]!;
-      otherWorkspaceId = (
-        await db.query<{ id: string }>(
-          `INSERT INTO "workspaces" ("organization_id", "name", "slug", "updated_at")
-         VALUES ($1, $2, $3, now()) RETURNING "id"`,
-          [org.id, `6155 Workspace ${RUN}`, `6155-ws-${RUN}`],
-        )
-      ).rows[0]!.id;
-
-      // One FlowDefinition / FlowSession pair, carrying its correct
-      // workspace_id from the moment of insert — the fence's NOT NULL means
-      // there is no longer a `workspace_id IS NULL` pre-state to construct
-      // for a row that CAN legitimately exist (see the file header). `title`
-      // / `status` are also NOT NULL as of the same-day
-      // `20260919130000_flow_definition_admin_columns` migration (no column
-      // default, by that migration's own design — a nameless/unpublished
-      // magnet must never enter the table silently) — both supplied here so
-      // the ONLY thing under test is the workspace_id/site_id shape.
-      const insertPair = async (siteId: string): Promise<void> => {
-        const def = (
-          await db.query<{ id: string }>(
-            `INSERT INTO "flow_definitions"
-               ("site_id", "workspace_id", "slug", "config", "title", "status", "updated_at")
-             VALUES ($1, $1, $2, '{}'::jsonb, 'Test', 'live', now()) RETURNING "id"`,
-            [siteId, `6155-${RUN}-${siteId}`],
-          )
-        ).rows[0]!;
-        definitionIds.push(def.id);
-
-        const sess = (
-          await db.query<{ id: string }>(
-            `INSERT INTO "flow_sessions"
-               ("site_id", "workspace_id", "flow_id", "flow_slug", "config_snapshot", "updated_at")
-             VALUES ($1, $1, $2, $3, '{}'::jsonb, now()) RETURNING "id"`,
-            [siteId, def.id, `6155-${RUN}-${siteId}`],
-          )
-        ).rows[0]!;
-        sessionIds.push(sess.id);
-      };
-
-      // Case 1's row FIRST, then the migration re-run, THEN case 3's row —
-      // deliberately sequenced, not merged into one loop. The migration's
-      // OWN post-assertions (re-read verbatim below) reject ANY row whose
-      // workspace_id names a workspace absent from "workspaces" ("nothing
-      // guessed"); `DEFAULT_WORKSPACE_ID` has no corresponding "workspaces"
-      // row on a freshly-migrated-but-unseeded database (that row is
-      // `database/seed.ts`'s job, not a migration's), so the re-run must
-      // happen BEFORE case 3's row exists, or it would trip that guard for
-      // a row it never touched.
-      await insertPair(otherWorkspaceId);
-
-      // Re-run the shipped migration file verbatim (NFR3 — still
-      // re-runnable). Every `workspace_id IS NULL` row it would touch is now
-      // unreachable (the fence's NOT NULL forbids one from ever existing),
-      // so this is a no-op on the row just inserted — proven by the
-      // "unchanged after re-run" assertion in the first `it()` block below,
-      // not a backfill.
-      await db.query(MIGRATION_SQL);
-
-      await insertPair(DEFAULT_WORKSPACE_ID);
-    });
-
-    afterAll(async () => {
-      await db.query(`DELETE FROM "flow_sessions" WHERE "flow_slug" LIKE $1`, [
-        `6155-${RUN}-%`,
-      ]);
-      await db.query(`DELETE FROM "flow_definitions" WHERE "slug" LIKE $1`, [
-        `6155-${RUN}-%`,
-      ]);
-      await db.query(`DELETE FROM "workspaces" WHERE "slug" = $1`, [
-        `6155-ws-${RUN}`,
-      ]);
-      await db.query(`DELETE FROM "organizations" WHERE "slug" = $1`, [
-        `6155-org-${RUN}`,
-      ]);
-      await db.end();
-    });
-
-    it("a row whose site_id names a real workspace carries a matching workspace_id, unchanged by a migration re-run, and is readable through the accessor's own query shape", async () => {
-      const [defId, sessId] = [definitionIds[0]!, sessionIds[0]!];
-
-      const def = await db.query<{ workspace_id: string | null }>(
-        `SELECT "workspace_id" FROM "flow_definitions" WHERE "id" = $1`,
-        [defId],
-      );
-      expect(def.rows[0]!.workspace_id).toBe(otherWorkspaceId);
-
-      // The shape tenantDb(tenant).flows.byId uses: findFirst({ id, workspaceId }).
-      const readable = await db.query(
-        `SELECT "id" FROM "flow_definitions" WHERE "id" = $1 AND "workspace_id" = $2`,
-        [defId, otherWorkspaceId],
-      );
-      expect(readable.rows).toHaveLength(1);
-
-      const sess = await db.query<{ workspace_id: string | null }>(
-        `SELECT "workspace_id" FROM "flow_sessions" WHERE "id" = $1`,
-        [sessId],
-      );
-      expect(sess.rows[0]!.workspace_id).toBe(otherWorkspaceId);
-
-      const sessReadable = await db.query(
-        `SELECT "id" FROM "flow_sessions" WHERE "id" = $1 AND "workspace_id" = $2`,
-        [sessId, otherWorkspaceId],
-      );
-      expect(sessReadable.rows).toHaveLength(1);
-    });
-
-    it("a row whose site_id matches no workspace can no longer be created — the fence retrofit rejects it outright, never leaving it unset", async () => {
-      // The EXACT pre-fence shape (no workspace_id supplied) — proving that
-      // what used to land a `workspace_id IS NULL` row is now rejected
-      // before it can, on both tables the #6155 backfill covered.
-      await expect(
-        db.query(
-          `INSERT INTO "flow_definitions" ("site_id", "slug", "config", "title", "status", "updated_at")
-           VALUES ($1, $2, '{}'::jsonb, 'Test', 'live', now())`,
-          [noSuchSite, `6155-${RUN}-abort-def`],
-        ),
-      ).rejects.toThrow(/workspace_id/);
-
-      await expect(
-        db.query(
-          `INSERT INTO "flow_sessions" ("site_id", "flow_id", "flow_slug", "config_snapshot", "updated_at")
-           VALUES ($1, $2, $3, '{}'::jsonb, now())`,
-          [noSuchSite, definitionIds[0]!, `6155-${RUN}-abort-sess`],
-        ),
-      ).rejects.toThrow(/workspace_id/);
-    });
-
-    it("a row whose site_id is the resolved sentinel DEFAULT_WORKSPACE_ID carries a matching workspace_id (D2 rule 2's write-time destination)", async () => {
-      const [defId, sessId] = [definitionIds[1]!, sessionIds[1]!];
-
-      const def = await db.query<{ workspace_id: string | null }>(
-        `SELECT "workspace_id" FROM "flow_definitions" WHERE "id" = $1`,
-        [defId],
-      );
-      expect(def.rows[0]!.workspace_id).toBe(DEFAULT_WORKSPACE_ID);
-
-      const sess = await db.query<{ workspace_id: string | null }>(
-        `SELECT "workspace_id" FROM "flow_sessions" WHERE "id" = $1`,
-        [sessId],
-      );
-      expect(sess.rows[0]!.workspace_id).toBe(DEFAULT_WORKSPACE_ID);
-    });
-
-    it("the migration's own literal sentinel id equals DEFAULT_WORKSPACE_ID — the two cannot drift apart", () => {
-      // SQL cannot import database/tenancy.ts (§ 5.3 step 5), so the migration
-      // carries the sentinel as a literal. Pin it against the exported
-      // constant by reading the shipped file, not a re-typed copy of it.
-      const occurrences = MIGRATION_SQL.match(/'wksp_[0-9a-f-]+'/g) ?? [];
-      expect(occurrences.length).toBeGreaterThan(0);
-      for (const literal of occurrences) {
-        expect(literal).toBe(`'${DEFAULT_WORKSPACE_ID}'`);
-      }
-    });
-  },
-);