feat(migrate-ts): diffTableChecks — evolve CHECKs on existing PG tables (offline)

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: dmealing

server/typescript/packages/migrate-ts/src/diff/index.ts

@@ -1,13 +1,14 @@
 import type {
   SchemaSnapshot, TableDescriptor, ColumnDescriptor, IndexDescriptor, FkDescriptor,
   ViewDescriptor,
-  Change, ChangeStatus, DiffResult, AllowOptions, AmbiguousCallback,
+  Change, ChangeStatus, DiffResult, AllowOptions, AmbiguousCallback, Dialect,
 } from "../types.js";
 import type { SqlType } from "../sql-type.js";
 import { sqlTypeEquals } from "../sql-type.js";
 import { applyStatus } from "./status.js";
 import { detectColumnRenames, detectTableRenames } from "./rename-heuristic.js";
 import { viewSqlEquals } from "../view-sql-compare.js";
+import { checkExprEquals } from "../check-expr-compare.js";
 import { DEFAULT_DB_SCHEMA_POSTGRES } from "@metaobjectsdev/metadata";
 
 export interface DiffArgs {
@@ -26,6 +27,8 @@ export interface DiffArgs {
    * the default. Pass additional patterns to extend.
    */
   ignoreTables?: string[];
+  /** Dialect; CHECK-constraint evolution on existing tables is emitted for postgres only. */
+  dialect?: Dialect;
 }
 
 const ALLOWED: ChangeStatus = { state: "allowed" };
@@ -156,10 +159,10 @@ export async function diff(
     diffTableColumns(expectedTable, actualTable, changes);
     diffTableIndexes(expectedTable, actualTable, changes);
     diffTableForeignKeys(expectedTable, actualTable, changes);
-    // CHECK constraints on existing tables are intentionally NOT diffed:
-    // checks are a create-time-only concern (inlined in CREATE TABLE). Evolving
-    // an enum's values on a live table (which would alter its CHECK) is deferred
-    // until check introspection lands. No add-check / drop-check is produced here.
+    // CHECK constraints on existing tables are evolved for postgres only (SQLite
+    // evolves checks via table recreate, not ALTER). Gated on `actual.checks`
+    // being populated — by the snapshot offline, or pg_constraint introspection.
+    if (args.dialect === "postgres") diffTableChecks(expectedTable, actualTable, changes);
   }
 
   // Pass 2b: views. Identity is (schema, name). A name present on both sides
@@ -293,6 +296,26 @@ function diffTableForeignKeys(
   }
 }
 
+function diffTableChecks(expected: TableDescriptor, actual: TableDescriptor, changes: Change[]): void {
+  const sx = schemaSpread(expected.schema);
+  const expectedChk = new Map(expected.checks.map((c) => [c.name, c]));
+  const actualChk = new Map(actual.checks.map((c) => [c.name, c]));
+  for (const [name, ec] of expectedChk) {
+    const ac = actualChk.get(name);
+    if (!ac) {
+      changes.push({ kind: "add-check", table: expected.name, ...sx, check: ec, status: ALLOWED });
+    } else if (!checkExprEquals(ec.expression, ac.expression)) {
+      changes.push({ kind: "drop-check", table: expected.name, ...sx, check: name, restore: ac, status: ALLOWED });
+      changes.push({ kind: "add-check", table: expected.name, ...sx, check: ec, status: ALLOWED });
+    }
+  }
+  for (const [name, ac] of actualChk) {
+    if (!expectedChk.has(name)) {
+      changes.push({ kind: "drop-check", table: expected.name, ...sx, check: name, restore: ac, status: ALLOWED });
+    }
+  }
+}
+
 function viewIdentity(v: { name: string; schema?: string }): string {
   return (v.schema ?? DEFAULT_DB_SCHEMA_POSTGRES) + "." + v.name;
 }

server/typescript/packages/migrate-ts/src/snapshot/plan.ts

@@ -32,6 +32,7 @@ export async function planOffline(args: PlanOfflineArgs): Promise<PlanOfflineRes
   const result = await diff({
     expected: nextSnapshot,
     actual: args.snapshot,
+    dialect: args.dialect,
     ...(args.allow ? { allow: args.allow } : {}),
     ...(args.onAmbiguous ? { onAmbiguous: args.onAmbiguous } : {}),
     ...(args.ignoreTables ? { ignoreTables: args.ignoreTables } : {}),

server/typescript/packages/migrate-ts/test/check-evolution/diff-offline.test.ts

@@ -0,0 +1,44 @@
+import { describe, test, expect } from "bun:test";
+import type { SchemaSnapshot, TableDescriptor, CheckDescriptor } from "../../src/types.js";
+import { diff } from "../../src/diff/index.js";
+
+const CHK = (name: string, expression: string): CheckDescriptor => ({ name, expression });
+function tbl(checks: CheckDescriptor[]): TableDescriptor {
+  return { name: "orders", columns: [{ name: "qty", sqlType: { kind: "integer", bits: 32 }, nullable: false }],
+    indexes: [], foreignKeys: [], checks, primaryKey: ["qty"] };
+}
+const snap = (checks: CheckDescriptor[]): SchemaSnapshot => ({ tables: [tbl(checks)], views: [] });
+const C0 = CHK("orders_qty_numeric_chk", "qty >= 1");
+const C0b = CHK("orders_qty_numeric_chk", "qty >= 5"); // changed bound, same name
+const C1 = CHK("orders_qty_max_chk", "qty <= 100");
+
+describe("diffTableChecks — postgres existing-table evolution", () => {
+  test("added check on an existing table → add-check", async () => {
+    const r = await diff({ expected: snap([C0, C1]), actual: snap([C0]), dialect: "postgres" });
+    expect(r.changes.filter((c) => c.kind === "add-check").map((c) => (c as any).check.name)).toEqual(["orders_qty_max_chk"]);
+  });
+  test("removed check → drop-check (gated, so blocked without allow)", async () => {
+    const r = await diff({ expected: snap([C0]), actual: snap([C0, C1]), dialect: "postgres" });
+    const drop = r.changes.find((c) => c.kind === "drop-check");
+    expect(drop && (drop as any).check).toBe("orders_qty_max_chk");
+    expect(drop!.status.state).toBe("blocked"); // no allow.dropCheck
+  });
+  test("changed expression (same name) → drop + add", async () => {
+    const r = await diff({ expected: snap([C0b]), actual: snap([C0]), dialect: "postgres", allow: { dropCheck: true } });
+    expect(r.changes.some((c) => c.kind === "drop-check")).toBe(true);
+    expect(r.changes.some((c) => c.kind === "add-check" && (c as any).check.expression === "qty >= 5")).toBe(true);
+  });
+  test("PG-rewritten actual expression equal to expected → NO change (idempotent)", async () => {
+    const r = await diff({ expected: snap([CHK("orders_qty_numeric_chk", "qty >= 1")]),
+      actual: snap([CHK("orders_qty_numeric_chk", "(qty >= 1)")]), dialect: "postgres" });
+    expect(r.changes.some((c) => c.kind.endsWith("-check"))).toBe(false);
+  });
+  test("dialect gate: sqlite produces NO check changes even when they differ", async () => {
+    const r = await diff({ expected: snap([C0, C1]), actual: snap([C0]), dialect: "sqlite" });
+    expect(r.changes.some((c) => c.kind.endsWith("-check"))).toBe(false);
+  });
+  test("no dialect passed → no check evolution (back-compat)", async () => {
+    const r = await diff({ expected: snap([C0, C1]), actual: snap([C0]) });
+    expect(r.changes.some((c) => c.kind.endsWith("-check"))).toBe(false);
+  });
+});