create-ailk 0.24.0 → 0.25.1

package/templates/database/__tests__/piece-kind.db.test.ts

@@ -1,208 +0,0 @@
-/**
- * @file piece-kind.db.test.ts
- *
- * LIVE-DATABASE proof of the piece kind and a proposal's price and payment
- * columns (#8516, spec docs/specs/8516-proposals-as-an-artifact-kind-spec.md
- * D1, D2, AC-1). 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, so
- * dropping and re-adding the columns never outlives the suite. What it proves
- * that a mock cannot:
- *   1. Re-running the migration's own text over a piece written with the
- *      pre-#8516 column set reads it back as a `deliverable`, the seven other
- *      columns NULL and every pre-existing column (`updated_at` included)
- *      byte-equal — no row is rewritten.
- *   2. Each CHECK and the unique index refuse what they name.
- */
-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 = join(__dirname, "..", "migrations", "20261016120000_piece_kind", "migration.sql");
-
-const WS = "wksp_01920000-8516-7000-8000-0000000000c1";
-const USER = "user_01920000-8516-7000-8000-0000000000a1";
-const NEW_COLUMNS = [
-  "kind",
-  "price_amount",
-  "price_currency",
-  "checkout_session_id",
-  "checkout_url",
-  "checkout_expires_at",
-  "paid_at",
-  "paid_session_id",
-] as const;
-
-describeDb("the piece kind columns (#8516 D1, D2, AC-1, live DB)", () => {
-  let db: Client;
-  let personId: string;
-
-  beforeAll(async () => {
-    db = new Client({ connectionString: process.env.DATABASE_URL });
-    await db.connect();
-    await db.query("BEGIN");
-    personId = (
-      await db.query<{ id: string }>(
-        `INSERT INTO "people" ("workspace_id", "email", "updated_at") VALUES ($1, $2, now()) RETURNING "id"`,
-        [WS, "p8516@example.com"],
-      )
-    ).rows[0]!.id;
-  });
-
-  afterAll(async () => {
-    await db.query("ROLLBACK");
-    await db.end();
-  });
-
-  /** Insert one piece with the pre-#8516 column set plus any of the new ones. */
-  const insertPiece = (cols: Record<string, unknown> = {}) => {
-    const all: Record<string, unknown> = {
-      workspace_id: WS,
-      person_id: personId,
-      title: "Site redesign",
-      stage: "requested",
-      updated_by: USER,
-      updated_at: new Date("2026-10-01T09:00:00.000Z"),
-      ...cols,
-    };
-    const names = Object.keys(all);
-    return db.query<{ id: string }>(
-      `INSERT INTO "pieces" (${names.map((n) => `"${n}"`).join(", ")})
-       VALUES (${names.map((_, i) => `$${i + 1}`).join(", ")}) RETURNING "id"`,
-      names.map((n) => all[n]),
-    );
-  };
-
-  /** Run `sql` 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);
-    }
-  };
-
-  it("re-running the migration over a pre-#8516 row reads it as a deliverable, nothing else changed", async () => {
-    await db.query(
-      `ALTER TABLE "pieces" ${NEW_COLUMNS.map((c) => `DROP COLUMN "${c}"`).join(", ")}`,
-    );
-    const pieceId = (await insertPiece()).rows[0]!.id;
-    await db.query(
-      `INSERT INTO "piece_versions" ("workspace_id", "person_id", "piece_id", "version", "link", "delivered_by")
-       VALUES ($1, $2, $3, 1, 'https://example.com/v1.pdf', $4)`,
-      [WS, personId, pieceId, USER],
-    );
-    const before = (
-      await db.query<{ row: Record<string, unknown> }>(
-        `SELECT row_to_json(p) AS row FROM "pieces" p WHERE "id" = $1`,
-        [pieceId],
-      )
-    ).rows[0]!.row;
-
-    await db.query(readFileSync(MIGRATION, "utf8"));
-
-    const after = (
-      await db.query<{ row: Record<string, unknown> }>(
-        `SELECT row_to_json(p) AS row FROM "pieces" p WHERE "id" = $1`,
-        [pieceId],
-      )
-    ).rows[0]!.row;
-    expect(after.kind).toBe("deliverable");
-    for (const column of NEW_COLUMNS.slice(1)) expect(after[column]).toBeNull();
-    const kept = Object.fromEntries(
-      Object.entries(after).filter(([key]) => !(NEW_COLUMNS as readonly string[]).includes(key)),
-    );
-    expect(kept).toEqual(before);
-  });
-
-  it("refuses a kind outside the two", async () => {
-    expect(await violation(() => insertPiece({ kind: "other" }))).toBe("pieces_kind_allowed");
-  });
-
-  it("refuses a price on a deliverable, half a price, and an amount out of range", async () => {
-    expect(
-      await violation(() => insertPiece({ price_amount: 1000, price_currency: "usd" })),
-    ).toBe("pieces_price_proposal_only");
-    expect(await violation(() => insertPiece({ kind: "proposal", price_amount: 1000 }))).toBe(
-      "pieces_price_pair",
-    );
-    for (const amount of [0, 100000001]) {
-      expect(
-        await violation(() =>
-          insertPiece({ kind: "proposal", price_amount: amount, price_currency: "usd" }),
-        ),
-      ).toBe("pieces_price_range");
-    }
-    expect(
-      await violation(() =>
-        insertPiece({ kind: "proposal", price_amount: 1, price_currency: "usd" }),
-      ),
-    ).toBeNull();
-  });
-
-  const SESSION = {
-    checkout_session_id: "cs_test_a1",
-    checkout_url: "https://checkout.stripe.com/c/pay/cs_test_a1",
-    checkout_expires_at: new Date("2026-10-16T13:00:00.000Z"),
-  };
-
-  it("refuses a checkout session on an unapproved or unpriced piece, and a partial session", async () => {
-    expect(
-      await violation(() =>
-        insertPiece({ kind: "proposal", price_amount: 5000, price_currency: "usd", ...SESSION }),
-      ),
-    ).toBe("pieces_checkout_needs_approved_price");
-    expect(
-      await violation(() => insertPiece({ kind: "proposal", approved_at: new Date(), ...SESSION })),
-    ).toBe("pieces_checkout_needs_approved_price");
-    expect(
-      await violation(() =>
-        insertPiece({
-          kind: "proposal",
-          price_amount: 5000,
-          price_currency: "usd",
-          approved_at: new Date(),
-          checkout_session_id: "cs_test_a2",
-        }),
-      ),
-    ).toBe("pieces_checkout_triple");
-  });
-
-  it("refuses paid_at without the session that paid it", async () => {
-    expect(
-      await violation(() =>
-        insertPiece({
-          kind: "proposal",
-          price_amount: 5000,
-          price_currency: "usd",
-          approved_at: new Date(),
-          paid_at: new Date(),
-        }),
-      ),
-    ).toBe("pieces_paid_pair");
-  });
-
-  it("refuses two pieces holding one checkout session", async () => {
-    const approvedPriced = {
-      kind: "proposal",
-      price_amount: 5000,
-      price_currency: "usd",
-      approved_at: new Date(),
-      ...SESSION,
-      checkout_session_id: "cs_test_dup",
-    };
-    expect(await violation(() => insertPiece(approvedPriced))).toBeNull();
-    expect(await violation(() => insertPiece(approvedPriced))).toBe(
-      "pieces_checkout_session_id_key",
-    );
-  });
-});

package/templates/database/__tests__/prefixed-ids.db.test.ts

@@ -1,222 +0,0 @@
-/**
- * @file prefixed-ids.db.test.ts
- *
- * LIVE-DATABASE proof of the ADR-0031 mechanical tier. Requires DATABASE_URL
- * pointing at a Postgres with the migrations applied (`prisma migrate deploy`)
- * — the whole suite SKIPS when DATABASE_URL is unset, keeping the workspace
- * Jest run DB-free (the repo convention; the `apps/api Route Tests (Postgres)`
- * workflow and local runs with a real DB exercise it).
- *
- * Uses the `pg` driver directly (raw SQL): the generated Prisma client is
- * ESM-only (`import.meta`) and cannot load under this package's CJS ts-jest
- * transform — and raw SQL is the sharper proof anyway, since the CHECK
- * constraints must hold on the path no application helper can guard.
- * (Client-level coverage — plain + nested `create` and Better Auth inserts
- * landing DB-minted prefixed ids — was verified live against the migrated
- * schema; see PR #3671's verification log.)
- *
- * What it proves — the ADR-0031 Tier-2 success criteria:
- *   1. uuidv7() property tests: version nibble 7, RFC-4122 variant,
- *      non-decreasing across a millisecond boundary. A failure here is a
- *      staging bug to surface to Sam, NOT a signal to rewrite the SQL.
- *   2. An insert with NO caller-supplied id lands a correctly-prefixed id via
- *      the DATABASE default.
- *   3. An insert with a malformed id is REJECTED by the CHECK constraint.
- *   4. The relation-free scope columns (workspaceId refs) are CHECKed too.
- *   5. The reserved-range sentinel ids are admitted by the CHECKs.
- */
-import { readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-
-import { Client } from "pg";
-
-import { DEFAULT_ORG_ID, DEFAULT_WORKSPACE_ID } from "../tenancy.js";
-
-const describeDb = process.env.DATABASE_URL ? describe : describe.skip;
-
-const V7_RE =
-  /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
-
-/**
- * Every distinct `_format` CHECK constraint name declared across
- * `database/migrations/*\/migration.sql` — both the inline `CREATE TABLE`
- * form and the `ALTER TABLE ... ADD CONSTRAINT` form (including the
- * existence-guarded `DO $$` blocks later migrations use for a NULLABLE
- * scope column, e.g. 20260919120000_flow_workspace_key). Comment lines are
- * skipped so a rollback note that merely mentions a constraint name doesn't
- * count as a second declaration.
- *
- * Derived from the migration source rather than hard-coded (#6119): a
- * hard-coded literal here goes stale the moment a later migration adds a
- * new prefixed-id model or scope column, failing this test for a reason
- * that has nothing to do with the database under test. Deriving it instead
- * still catches the real defect this test guards — the live database
- * missing a CHECK its own migrations declare (a partial/failed deploy,
- * migrations applied out of order, one silently dropped) — because the
- * expected count comes from the repo's migration files while the actual
- * count comes from a live query against the database those migrations were
- * run against; the two are independent unless the migrations actually ran
- * to completion.
- */
-function declaredFormatCheckCount(): number {
-  const migrationsDir = join(__dirname, "..", "migrations");
-  const names = new Set<string>();
-  for (const entry of readdirSync(migrationsDir, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    const sqlPath = join(migrationsDir, entry.name, "migration.sql");
-    let sql: string;
-    try {
-      sql = readFileSync(sqlPath, "utf-8");
-    } catch {
-      continue;
-    }
-    for (const line of sql.split("\n")) {
-      if (line.trim().startsWith("--")) continue;
-      const match = line.match(/CONSTRAINT\s+"([a-z_]+_format)"/);
-      if (match) names.add(match[1]);
-    }
-  }
-  return names.size;
-}
-
-describeDb("prefixed UUIDv7 ids (ADR-0031, live DB)", () => {
-  let db: Client;
-  // #6254 (the tenancy-fence keystone) retrofitted `leads.workspace_id` to
-  // NOT NULL plus `leads_workspace_site_agree CHECK (workspace_id =
-  // site_id)` and `leads_workspace_id_format CHECK (workspace_id ~
-  // '^wksp_...')`. Every "leads" insert below now needs a well-formed
-  // `wksp_` id in BOTH columns — a real seeded workspace (mirroring
-  // `composite-fence.db.test.ts`'s own fixture pattern), not the prior
-  // free-text `'adr31-test'` literal, which satisfied neither CHECK.
-  let workspaceId: string;
-
-  beforeAll(async () => {
-    db = new Client({ connectionString: process.env.DATABASE_URL });
-    await db.connect();
-
-    const org = (
-      await db.query<{ id: string }>(
-        `INSERT INTO "organizations" ("name", "slug", "updated_at")
-         VALUES ('ADR31 Fence Org', 'adr31-fence-org', now()) RETURNING "id"`,
-      )
-    ).rows[0]!;
-    workspaceId = (
-      await db.query<{ id: string }>(
-        `INSERT INTO "workspaces" ("organization_id", "name", "slug", "updated_at")
-         VALUES ($1, 'ADR31 Fence Workspace', 'adr31-fence-ws', now()) RETURNING "id"`,
-        [org.id],
-      )
-    ).rows[0]!.id;
-  });
-
-  afterAll(async () => {
-    await db.query(`DELETE FROM "leads" WHERE "workspace_id" = $1`, [
-      workspaceId,
-    ]);
-    await db.query(
-      `DELETE FROM "organizations" WHERE "slug" LIKE 'adr31-%'`,
-    );
-    await db.end();
-  });
-
-  describe("uuidv7() SQL function properties", () => {
-    it("version nibble is 7 and variant is RFC-4122 across 200 samples", async () => {
-      const { rows } = await db.query<{ id: string }>(
-        "SELECT uuidv7()::text AS id FROM generate_series(1, 200)",
-      );
-      expect(rows).toHaveLength(200);
-      for (const { id } of rows) {
-        expect(id).toMatch(V7_RE);
-      }
-    });
-
-    it("is non-decreasing across a millisecond boundary", async () => {
-      const first = (await db.query<{ id: string }>(
-        "SELECT uuidv7()::text AS id",
-      )).rows[0].id;
-      await new Promise((r) => setTimeout(r, 5));
-      const second = (await db.query<{ id: string }>(
-        "SELECT uuidv7()::text AS id",
-      )).rows[0].id;
-      expect(second >= first).toBe(true);
-    });
-  });
-
-  describe("DB-generated prefixed defaults", () => {
-    it("an insert with NO id lands a prefixed id via the database default", async () => {
-      const org = (await db.query<{ id: string }>(
-        `INSERT INTO "organizations" ("name", "slug", "updated_at")
-         VALUES ('ADR31 Org', 'adr31-org', now()) RETURNING "id"`,
-      )).rows[0];
-      expect(org.id).toMatch(/^org_/);
-      expect(org.id.slice("org_".length)).toMatch(V7_RE);
-
-      const lead = (await db.query<{ id: string }>(
-        `INSERT INTO "leads" ("site_id", "workspace_id", "source", "email", "payload")
-         VALUES ($1, $1, 'test', 'adr31@example.com', '{}') RETURNING "id"`,
-        [workspaceId],
-      )).rows[0];
-      expect(lead.id).toMatch(/^lead_/);
-      expect(lead.id.slice("lead_".length)).toMatch(V7_RE);
-    });
-  });
-
-  describe("CHECK constraints — the mechanical tier", () => {
-    it("REJECTS an insert with a malformed primary key", async () => {
-      // workspace_id (= site_id) is supplied and well-formed here so the
-      // ONLY constraint this insert can violate is leads_id_format — proving
-      // the malformed-id rejection still fires for its original reason,
-      // not the (now also NOT NULL) workspace_id (#6373 AC-3).
-      await expect(
-        db.query(
-          `INSERT INTO "leads" ("id", "site_id", "workspace_id", "source", "email", "payload")
-           VALUES ('bad', $1, $1, 'x', 'a@b.co', '{}')`,
-          [workspaceId],
-        ),
-      ).rejects.toThrow(/leads_id_format/);
-    });
-
-    it("REJECTS an insert with a bare (unprefixed) uuid primary key", async () => {
-      await expect(
-        db.query(
-          `INSERT INTO "leads" ("id", "site_id", "workspace_id", "source", "email", "payload")
-           VALUES ('0190f3a2-7c1d-7e4a-9b2c-0123456789ab', $1, $1, 'x', 'a@b.co', '{}')`,
-          [workspaceId],
-        ),
-      ).rejects.toThrow(/leads_id_format/);
-    });
-
-    it("REJECTS a malformed relation-free scope ref (workspaceId with no FK)", async () => {
-      await expect(
-        db.query(
-          `INSERT INTO "workspace_themes" ("workspace_id", "data", "updated_at")
-           VALUES ('not-a-workspace-id', '{}', now())`,
-        ),
-      ).rejects.toThrow(/workspace_themes_workspace_id_format/);
-    });
-
-    it("ADMITS the reserved-range sentinel ids (seed path stays valid)", async () => {
-      const org = (await db.query<{ id: string }>(
-        `INSERT INTO "organizations" ("id", "name", "slug", "updated_at")
-         VALUES ($1, 'ADR31 Sentinel', 'adr31-sentinel', now()) RETURNING "id"`,
-        [DEFAULT_ORG_ID],
-      )).rows[0];
-      expect(org.id).toBe(DEFAULT_ORG_ID);
-
-      const ws = (await db.query<{ id: string }>(
-        `INSERT INTO "workspaces" ("id", "organization_id", "name", "slug", "updated_at")
-         VALUES ($1, $2, 'Sentinel WS', 'sentinel', now()) RETURNING "id"`,
-        [DEFAULT_WORKSPACE_ID, DEFAULT_ORG_ID],
-      )).rows[0];
-      expect(ws.id).toBe(DEFAULT_WORKSPACE_ID);
-    });
-
-    it("carries the full CHECK complement declared by the migrations", async () => {
-      const { rows } = await db.query<{ n: string }>(
-        `SELECT count(*)::text AS n FROM pg_constraint
-         WHERE contype = 'c' AND conname LIKE '%_format'`,
-      );
-      expect(rows[0].n).toBe(String(declaredFormatCheckCount()));
-    });
-  });
-});

package/templates/database/__tests__/project-listing-consent-at.db.test.ts

@@ -1,111 +0,0 @@
-/**
- * @file project-listing-consent-at.db.test.ts
- *
- * LIVE-DATABASE proof that `ProjectListing.consentAt` round-trips through
- * the real Prisma Client with timezone information preserved (#6171).
- * Requires DATABASE_URL pointing at a Postgres with the migrations applied
- * (`prisma migrate deploy`) — the whole suite SKIPS when DATABASE_URL is
- * unset, keeping the workspace Jest run DB-free (the repo convention; see
- * `prefixed-ids.db.test.ts` / `appointment.db.test.ts`).
- *
- * The bug this guards: `database/inbox/schema.prisma`'s `consentAt` field
- * declared `DateTime @default(now()) @map("consent_at")` with no native-type
- * annotation, so Prisma treated it as `TIMESTAMP(3)` (no time zone) by
- * default, while its migration
- * (`20260909180000_listing_draft_and_fields/migration.sql`) created the
- * actual column as `TIMESTAMPTZ` — deliberately, since it records a legal
- * consent timestamp. The fix adds `@db.Timestamptz(3)` so the schema's
- * declared type agrees with what the column actually is.
- *
- * Spawns `project-listing-consent-probe.ts` via `tsx` (a real ESM process)
- * rather than importing the generated client directly, for the same reason
- * `appointment.db.test.ts` does: the generated client is ESM-only
- * (`import.meta.url`) and cannot load under this package's CJS `ts-jest`
- * transform.
- */
-import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-
-const describeDb = process.env.DATABASE_URL ? describe : describe.skip;
-
-const DATABASE_DIR = join(__dirname, "..");
-const PROBE_SCRIPT = join(
-  __dirname,
-  "fixtures",
-  "project-listing-consent-probe.ts",
-);
-
-// Runs with no DATABASE_URL required — a deterministic guard so the schema
-// declaration can't silently regress even in a DB-free run (the live-DB
-// round trip below still runs whenever DATABASE_URL is set).
-describe("ProjectListing.consentAt — schema declares the real column type (#6171)", () => {
-  it("carries @db.Timestamptz(3), matching the TIMESTAMPTZ column created by 20260909180000_listing_draft_and_fields", () => {
-    const schema = readFileSync(
-      join(DATABASE_DIR, "inbox", "schema.prisma"),
-      "utf-8",
-    );
-    const fieldLine = schema
-      .split("\n")
-      .find((line) => /^\s*consentAt\s+DateTime\b/.test(line));
-    expect(fieldLine).toBeDefined();
-    expect(fieldLine).toMatch(/@db\.Timestamptz\(3\)/);
-  });
-});
-
-/** Walk up from DATABASE_DIR to find node_modules/.bin/tsx (worktree-safe —
- * mirrors `appointment.db.test.ts`'s own resolution). */
-function findTsxBin(): string {
-  let dir = DATABASE_DIR;
-  for (let i = 0; i < 5; i++) {
-    const candidate = join(dir, "node_modules", ".bin", "tsx");
-    if (existsSync(candidate)) return candidate;
-    dir = join(dir, "..");
-  }
-  throw new Error(`tsx binary not found searching up from ${DATABASE_DIR}.`);
-}
-
-describeDb(
-  "ProjectListing.consentAt — live DB round trip via prisma.projectListing (#6171)",
-  () => {
-    it("preserves the exact instant through create() + a fresh findUniqueOrThrow(), regardless of session timezone", () => {
-      const tsxBin = findTsxBin();
-      const result = spawnSync(tsxBin, [PROBE_SCRIPT], {
-        cwd: DATABASE_DIR,
-        encoding: "utf-8",
-        env: process.env,
-      });
-
-      // Exit status + a successful stdout parse is the full signal (see
-      // appointment.db.test.ts for why this, rather than empty stderr, is
-      // the right assertion — a stray Node/tsx diagnostic must not fail an
-      // otherwise-successful run).
-      if (result.status !== 0) {
-        throw new Error(
-          `probe exited ${result.status}: ${result.stderr || "(no stderr)"}`,
-        );
-      }
-
-      const probe = JSON.parse(result.stdout) as {
-        writtenIso: string;
-        createdConsentAtIso: string;
-        rereadConsentAtIso: string;
-        liveColumnDataType: string | null;
-      };
-
-      // The instant `create()` returns must be exactly what was written —
-      // not shifted by the pinned Asia/Kolkata (+05:30) session timezone.
-      expect(probe.createdConsentAtIso).toBe(probe.writtenIso);
-
-      // A SECOND, independent read (a fresh findUniqueOrThrow, not the
-      // object create() already returned) must agree too — the read path,
-      // not just the write path, preserves the instant.
-      expect(probe.rereadConsentAtIso).toBe(probe.writtenIso);
-
-      // Ground truth: the live column really is timezone-aware, which is
-      // what makes the schema's `@db.Timestamptz(3)` annotation correct
-      // rather than merely quiet.
-      expect(probe.liveColumnDataType).toBe("timestamp with time zone");
-    });
-  },
-);