create-ailk 0.5.0 → 0.6.0

package/templates/database/__tests__/composite-fence.db.test.ts

@@ -0,0 +1,206 @@
+/**
+ * @file composite-fence.db.test.ts
+ *
+ * LIVE-DATABASE proof of the #6254 keystone constraints (AC-2, AC-5, AC-7).
+ * Requires DATABASE_URL pointing at a Postgres with the migrations applied
+ * (`prisma migrate deploy`); the whole suite SKIPS when DATABASE_URL is
+ * unset, matching `flow-workspace-key.db.test.ts` / `prefixed-ids.db.test.ts`
+ * and keeping the workspace Jest run DB-free.
+ *
+ * Raw SQL through `pg`, for the same reason those files give: the generated
+ * Prisma client is ESM-only and cannot load under this package's CJS ts-jest
+ * transform.
+ *
+ * This suite proves the CONSTRAINTS database/migrations/
+ * 20260922120000_tenancy_fence adds — it does not re-prove that migration's
+ * own backfill (that is `flow-workspace-key.db.test.ts`'s job for its two
+ * models, and this migration's backfill is largely a defensive re-run of
+ * work the #6155/#6203 precedent migrations already did — see this
+ * migration's own header comment). What it proves (spec § 8.2):
+ *
+ *   1. `Lead` rejects a row whose `workspaceId` disagrees with its `siteId`
+ *      — SQLSTATE 23514 (AC-5's core).
+ *   2. `Lead` accepts a row whose `workspaceId` AGREES with its `siteId` —
+ *      without this, assertion 1 would also pass against a table that
+ *      rejects everything.
+ *   3. `FlowDefinition` rejects the same disagreement — AC-5's "at least
+ *      one retrofit model besides Lead".
+ *   4. NULL is unstorable on `Lead` and `FlowDefinition` — SQLSTATE 23502
+ *      (not_null_violation) — AC-7.
+ *   5. `WorkspaceSiteIdentity` carries the AC-2 composite unique constraint,
+ *      proven at the database, not just in the schema file.
+ *   6. The migration's own literal sentinel id equals `DEFAULT_WORKSPACE_ID`
+ *      — the two cannot drift apart (the #6155/#6203 precedents' own
+ *      technique).
+ */
+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",
+  "20260922120000_tenancy_fence",
+  "migration.sql",
+);
+const MIGRATION_SQL = readFileSync(MIGRATION_SQL_PATH, "utf-8");
+
+/** Postgres's own error shape carries `code` as a 5-character SQLSTATE. */
+type PgError = { code?: string };
+
+describeDb("the #6254 tenancy-fence constraints (live DB)", () => {
+  let db: Client;
+  let workspaceAId: string;
+  let workspaceBId: string;
+
+  beforeAll(async () => {
+    db = new Client({ connectionString: process.env.DATABASE_URL });
+    await db.connect();
+
+    // Two REAL, distinct workspaces — A and B — so a "disagreement" insert
+    // names two values that both actually exist, not a real one versus
+    // garbage (which the format CHECK, not the equality CHECK, would catch).
+    const org = (
+      await db.query<{ id: string }>(
+        `INSERT INTO "organizations" ("name", "slug", "updated_at")
+         VALUES ($1, $2, now()) RETURNING "id"`,
+        [`6254 Org ${RUN}`, `6254-org-${RUN}`],
+      )
+    ).rows[0]!;
+
+    workspaceAId = (
+      await db.query<{ id: string }>(
+        `INSERT INTO "workspaces" ("organization_id", "name", "slug", "updated_at")
+         VALUES ($1, $2, $3, now()) RETURNING "id"`,
+        [org.id, `6254 Workspace A ${RUN}`, `6254-ws-a-${RUN}`],
+      )
+    ).rows[0]!.id;
+
+    workspaceBId = (
+      await db.query<{ id: string }>(
+        `INSERT INTO "workspaces" ("organization_id", "name", "slug", "updated_at")
+         VALUES ($1, $2, $3, now()) RETURNING "id"`,
+        [org.id, `6254 Workspace B ${RUN}`, `6254-ws-b-${RUN}`],
+      )
+    ).rows[0]!.id;
+  });
+
+  afterAll(async () => {
+    await db.query(`DELETE FROM "flow_definitions" WHERE "slug" LIKE $1`, [
+      `6254-${RUN}-%`,
+    ]);
+    await db.query(`DELETE FROM "leads" WHERE "source" = $1`, [
+      `6254-test-${RUN}`,
+    ]);
+    await db.query(`DELETE FROM "workspaces" WHERE "slug" LIKE $1`, [
+      `6254-ws-%-${RUN}`,
+    ]);
+    await db.query(`DELETE FROM "organizations" WHERE "slug" = $1`, [
+      `6254-org-${RUN}`,
+    ]);
+    await db.end();
+  });
+
+  describe("AC-5 — the equality CHECK rejects a site<->workspace disagreement", () => {
+    it("Lead: workspace_id disagreeing with site_id raises 23514", async () => {
+      await expect(
+        db.query(
+          `INSERT INTO "leads" ("site_id", "workspace_id", "source", "email", "payload")
+           VALUES ($1, $2, $3, $4, '{}'::jsonb)`,
+          [workspaceAId, workspaceBId, `6254-test-${RUN}`, "disagree@example.com"],
+        ),
+      ).rejects.toMatchObject<{ code: PgError["code"] }>({ code: "23514" });
+    });
+
+    it("Lead: workspace_id AGREEING with site_id succeeds", async () => {
+      const result = await db.query<{ id: string }>(
+        `INSERT INTO "leads" ("site_id", "workspace_id", "source", "email", "payload")
+         VALUES ($1, $1, $2, $3, '{}'::jsonb) RETURNING "id"`,
+        [workspaceAId, `6254-test-${RUN}`, "agree@example.com"],
+      );
+      expect(result.rows).toHaveLength(1);
+    });
+
+    it("FlowDefinition (the second retrofit model, AC-5's own requirement): workspace_id disagreeing with site_id raises 23514", async () => {
+      await expect(
+        db.query(
+          `INSERT INTO "flow_definitions"
+             ("site_id", "workspace_id", "slug", "config", "title", "status", "updated_at")
+           VALUES ($1, $2, $3, '{}'::jsonb, 'Test', 'live', now())`,
+          [workspaceAId, workspaceBId, `6254-${RUN}-disagree`],
+        ),
+      ).rejects.toMatchObject<{ code: PgError["code"] }>({ code: "23514" });
+    });
+
+    it("FlowDefinition: workspace_id AGREEING with site_id succeeds", async () => {
+      const result = 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"`,
+        [workspaceAId, `6254-${RUN}-agree`],
+      );
+      expect(result.rows).toHaveLength(1);
+    });
+  });
+
+  describe("AC-7 — NOT NULL: no row can exist with workspace_id IS NULL", () => {
+    it("Lead: omitting workspace_id raises 23502 (not_null_violation)", async () => {
+      await expect(
+        db.query(
+          `INSERT INTO "leads" ("site_id", "source", "email", "payload")
+           VALUES ($1, $2, $3, '{}'::jsonb)`,
+          [workspaceAId, `6254-test-${RUN}`, "null@example.com"],
+        ),
+      ).rejects.toMatchObject<{ code: PgError["code"] }>({ code: "23502" });
+    });
+
+    it("FlowDefinition: omitting workspace_id raises 23502 (not_null_violation)", async () => {
+      await expect(
+        db.query(
+          `INSERT INTO "flow_definitions" ("site_id", "slug", "config", "title", "status", "updated_at")
+           VALUES ($1, $2, '{}'::jsonb, 'Test', 'live', now())`,
+          [workspaceAId, `6254-${RUN}-null`],
+        ),
+      ).rejects.toMatchObject<{ code: PgError["code"] }>({ code: "23502" });
+    });
+  });
+
+  describe("AC-2 — WorkspaceSiteIdentity's composite unique exists at the database", () => {
+    it("pg_constraint reports a UNIQUE constraint over (id, workspace_id)", async () => {
+      const result = await db.query<{ contype: string; conkey_count: number }>(
+        `SELECT c.contype, array_length(c.conkey, 1) AS conkey_count
+           FROM pg_constraint c
+           JOIN pg_class t ON t.oid = c.conrelid
+          WHERE t.relname = 'workspace_site_identities'
+            AND c.conname = 'workspace_site_identities_id_workspace_id_key'`,
+      );
+      expect(result.rows).toHaveLength(1);
+      expect(result.rows[0]!.contype).toBe("u");
+      expect(result.rows[0]!.conkey_count).toBe(2);
+    });
+  });
+
+  describe("the migration's own literal sentinel id equals DEFAULT_WORKSPACE_ID", () => {
+    it("cannot drift apart — read from the shipped file, not a re-typed copy", () => {
+      // SQL cannot import database/tenancy.ts (spec § 5.3 step 5), so the
+      // migration carries the sentinel as a literal. Pin it against the
+      // exported constant by reading the shipped file, exactly as the
+      // #6155/#6203 precedents do.
+      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}'`);
+      }
+    });
+  });
+});