@supabase/pg-delta 1.0.0-alpha.25 → 1.0.0-alpha.27

package/dist/core/objects/table/table.diff.js

@@ -28,12 +28,6 @@ function createAlterConstraintChange(mainTable, branchTable) {
                 table: branchTable,
                 constraint: c,
             }));
-            if (!c.validated) {
-                changes.push(new AlterTableValidateConstraint({
-                    table: branchTable,
-                    constraint: c,
-                }));
-            }
             // Add comment for newly created constraint
             if (c.comment !== null) {
                 changes.push(new CreateCommentOnConstraint({
@@ -53,7 +47,7 @@ function createAlterConstraintChange(mainTable, branchTable) {
             changes.push(new AlterTableDropConstraint({ table: mainTable, constraint: c }));
         }
     }
-    // Altered constraints -> drop + add
+    // Altered constraints -> drop + add (or VALIDATE-only shortcut)
     for (const [name, mainC] of mainByName) {
         const branchC = branchByName.get(name);
         if (!branchC)
@@ -62,23 +56,57 @@ function createAlterConstraintChange(mainTable, branchTable) {
         if (mainC.is_partition_clone || branchC.is_partition_clone) {
             continue;
         }
-        const changed = mainC.constraint_type !== branchC.constraint_type ||
-            mainC.deferrable !== branchC.deferrable ||
-            mainC.initially_deferred !== branchC.initially_deferred ||
-            mainC.validated !== branchC.validated ||
-            mainC.is_local !== branchC.is_local ||
-            mainC.no_inherit !== branchC.no_inherit ||
-            mainC.is_temporal !== branchC.is_temporal ||
-            JSON.stringify(mainC.key_columns) !==
-                JSON.stringify(branchC.key_columns) ||
-            JSON.stringify(mainC.foreign_key_columns) !==
-                JSON.stringify(branchC.foreign_key_columns) ||
-            mainC.foreign_key_table !== branchC.foreign_key_table ||
-            mainC.foreign_key_schema !== branchC.foreign_key_schema ||
-            mainC.on_update !== branchC.on_update ||
-            mainC.on_delete !== branchC.on_delete ||
-            mainC.match_type !== branchC.match_type ||
-            mainC.check_expression !== branchC.check_expression;
+        // Cheap scalar `===` checks first; only fall through to JSON.stringify
+        // on the array fields when every scalar has already matched.
+        const fieldsEqualExceptValidated = mainC.constraint_type === branchC.constraint_type &&
+            mainC.deferrable === branchC.deferrable &&
+            mainC.initially_deferred === branchC.initially_deferred &&
+            mainC.is_local === branchC.is_local &&
+            mainC.no_inherit === branchC.no_inherit &&
+            mainC.is_temporal === branchC.is_temporal &&
+            mainC.foreign_key_table === branchC.foreign_key_table &&
+            mainC.foreign_key_schema === branchC.foreign_key_schema &&
+            mainC.on_update === branchC.on_update &&
+            mainC.on_delete === branchC.on_delete &&
+            mainC.match_type === branchC.match_type &&
+            mainC.check_expression === branchC.check_expression &&
+            JSON.stringify(mainC.key_columns) ===
+                JSON.stringify(branchC.key_columns) &&
+            JSON.stringify(mainC.foreign_key_columns) ===
+                JSON.stringify(branchC.foreign_key_columns);
+        // Safe-migration shortcut: when the only difference is `validated`
+        // flipping from false to true, emit a single `ALTER TABLE ... VALIDATE
+        // CONSTRAINT` instead of drop+add. VALIDATE CONSTRAINT only takes
+        // SHARE UPDATE EXCLUSIVE (concurrent reads/writes proceed), whereas
+        // dropping and re-adding takes ACCESS EXCLUSIVE for the entire scan.
+        // Postgres has no reverse command, so `true -> false` must still go
+        // through drop+add below.
+        if (fieldsEqualExceptValidated &&
+            mainC.validated === false &&
+            branchC.validated === true) {
+            changes.push(new AlterTableValidateConstraint({
+                table: branchTable,
+                constraint: branchC,
+            }));
+            // VALIDATE preserves the constraint OID, so its comment is preserved
+            // too. Only emit a comment change if it actually differs.
+            if (mainC.comment !== branchC.comment) {
+                if (branchC.comment === null) {
+                    changes.push(new DropCommentOnConstraint({
+                        table: mainTable,
+                        constraint: mainC,
+                    }));
+                }
+                else {
+                    changes.push(new CreateCommentOnConstraint({
+                        table: branchTable,
+                        constraint: branchC,
+                    }));
+                }
+            }
+            continue;
+        }
+        const changed = mainC.validated !== branchC.validated || !fieldsEqualExceptValidated;
         if (changed) {
             changes.push(new AlterTableDropConstraint({
                 table: mainTable,
@@ -88,12 +116,6 @@ function createAlterConstraintChange(mainTable, branchTable) {
                 table: branchTable,
                 constraint: branchC,
             }));
-            if (!branchC.validated) {
-                changes.push(new AlterTableValidateConstraint({
-                    table: branchTable,
-                    constraint: branchC,
-                }));
-            }
             // Ensure constraint comment is applied after re-creation
             if (branchC.comment !== null) {
                 changes.push(new CreateCommentOnConstraint({
@@ -163,6 +185,7 @@ export function diffTables(ctx, main, branch) {
         changes.push(...createAlterConstraintChange(
         // Create a dummy table with no constraints do diff constraints against
         new Table({
+            // oxlint-disable-next-line typescript/no-misused-spread
             ...branchTable,
             constraints: [],
         }), branchTable));

package/dist/core/plan/hierarchy.js

@@ -262,7 +262,7 @@ function addClusterChange(cluster, change) {
             break;
         default: {
             const _exhaustive = objectType;
-            throw new Error(`Unhandled object type: ${_exhaustive}`);
+            throw new Error(`Unhandled object type: ${JSON.stringify(_exhaustive)}`);
         }
     }
 }
@@ -303,7 +303,7 @@ function addChildChange(schema, change) {
             break;
         default: {
             const _exhaustive = parentType;
-            throw new Error(`Unhandled parent type: ${_exhaustive}`);
+            throw new Error(`Unhandled parent type: ${JSON.stringify(_exhaustive)}`);
         }
     }
     const objectType = change.objectType;
@@ -351,7 +351,7 @@ function addChildChange(schema, change) {
             break;
         default: {
             const _exhaustive = objectType;
-            throw new Error(`Unhandled object type: ${_exhaustive}`);
+            throw new Error(`Unhandled object type: ${JSON.stringify(_exhaustive)}`);
         }
     }
 }
@@ -482,7 +482,7 @@ function addSchemaLevelChange(schema, change, enrichment) {
             break;
         default: {
             const _exhaustive = objectType;
-            throw new Error(`Unhandled object type: ${_exhaustive}`);
+            throw new Error(`Unhandled object type: ${JSON.stringify(_exhaustive)}`);
         }
     }
 }

package/dist/core/postgres-config.d.ts

@@ -30,6 +30,13 @@ export declare function connectWithRetry<T>(opts: {
     maxBackoffMs?: number;
     sleep?: (ms: number) => Promise<void>;
 }): Promise<T>;
+/**
+ * Race `connect()` against a `timeoutMs` rejection and clear the timer when
+ * either side wins. If the timer is left running after a fast connect, the
+ * pending `setTimeout` keeps the event loop alive and the process hangs for
+ * the rest of `timeoutMs`.
+ */
+export declare function connectWithTimeout<T>(connect: () => Promise<T>, timeoutMs: number, label: "source" | "target"): Promise<T>;
 /**
  * Options for creating a Pool with event listeners.
  */

package/dist/core/postgres-config.js

@@ -180,6 +180,24 @@ export async function connectWithRetry(opts) {
     // Unreachable: loop either returns or throws.
     throw lastError;
 }
+/**
+ * Race `connect()` against a `timeoutMs` rejection and clear the timer when
+ * either side wins. If the timer is left running after a fast connect, the
+ * pending `setTimeout` keeps the event loop alive and the process hangs for
+ * the rest of `timeoutMs`.
+ */
+export function connectWithTimeout(connect, timeoutMs, label) {
+    let timer;
+    return Promise.race([
+        connect(),
+        new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error(`Connection to ${label} database timed out after ${timeoutMs}ms. ` +
+                `The server may require SSL, use an invalid certificate, or be unreachable.`)), timeoutMs);
+        }),
+    ]).finally(() => {
+        clearTimeout(timer);
+    });
+}
 /**
  * Create a Pool with custom type handlers and optional event listeners.
  *
@@ -347,11 +365,7 @@ export async function createManagedPool(url, options) {
     const timeoutMs = DEFAULT_CONNECT_TIMEOUT_MS;
     try {
         const client = await connectWithRetry({
-            connect: () => Promise.race([
-                pool.connect(),
-                new Promise((_, reject) => setTimeout(() => reject(new Error(`Connection to ${label} database timed out after ${timeoutMs}ms. ` +
-                    `The server may require SSL, use an invalid certificate, or be unreachable.`)), timeoutMs)),
-            ]),
+            connect: () => connectWithTimeout(() => pool.connect(), timeoutMs, label),
         });
         client.release();
     }

package/dist/core/sort/debug-visualization.js

@@ -139,7 +139,7 @@ export function printDebugGraph(phaseChanges, graphData, edges, dependencyRows,
         const mermaidDiagram = generateMermaidDiagram(phaseChanges, graphData, edges, requirementSets, dependenciesByReferencedId);
         debugGraph("\n==== Mermaid (cycle detected) ====\n%s\n==== end ====", mermaidDiagram);
     }
-    catch (_error) {
+    catch {
         // ignore debug printing errors
     }
 }

package/dist/core/sort/topological-sort.js

@@ -5,7 +5,7 @@
  */
 export function performStableTopologicalSort(nodeCount, edges) {
     const adjacencyList = Array.from({ length: nodeCount }, () => new Set());
-    const inDegreeCounts = new Array(nodeCount).fill(0);
+    const inDegreeCounts = Array.from({ length: nodeCount }, () => 0);
     for (const [sourceIndex, targetIndex] of edges) {
         if (!adjacencyList[sourceIndex].has(targetIndex)) {
             adjacencyList[sourceIndex].add(targetIndex);
@@ -51,7 +51,7 @@ export function findCycle(nodeCount, edges) {
         adjacencyList[sourceIndex].push(targetIndex);
     }
     // 0 = unvisited, 1 = visiting, 2 = completed
-    const visitState = new Array(nodeCount).fill(0);
+    const visitState = Array.from({ length: nodeCount }, () => 0);
     const pathStack = [];
     let cycleNodeIndexes = null;
     const depthFirstSearch = (nodeIndex) => {

package/package.json

@@ -1,7 +1,33 @@
 {
   "name": "@supabase/pg-delta",
-  "version": "1.0.0-alpha.25",
+  "version": "1.0.0-alpha.27",
   "description": "PostgreSQL migrations made easy",
+  "keywords": [
+    "diff",
+    "migrations",
+    "pg",
+    "pg-delta",
+    "pgdelta",
+    "postgres"
+  ],
+  "homepage": "https://github.com/supabase/pg-toolbelt",
+  "bugs": "https://github.com/supabase/pg-toolbelt/issues",
+  "license": "MIT",
+  "author": "Supabase",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/supabase/pg-toolbelt.git",
+    "directory": "packages/pg-delta"
+  },
+  "bin": {
+    "pgdelta": "./dist/cli/bin/cli.js"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
   "type": "module",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -36,40 +62,12 @@
       "default": "./dist/core/catalog-export/index.js"
     }
   },
-  "bin": {
-    "pgdelta": "./dist/cli/bin/cli.js"
-  },
-  "files": [
-    "dist",
-    "src",
-    "README.md",
-    "LICENSE"
-  ],
-  "keywords": [
-    "pg",
-    "postgres",
-    "migrations",
-    "diff",
-    "pg-delta",
-    "pgdelta"
-  ],
-  "author": "Supabase",
-  "license": "MIT",
-  "homepage": "https://github.com/supabase/pg-toolbelt",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/supabase/pg-toolbelt.git",
-    "directory": "packages/pg-delta"
-  },
-  "bugs": "https://github.com/supabase/pg-toolbelt/issues",
-  "engines": {
-    "node": ">=20.0.0"
-  },
   "scripts": {
     "build": "tsc --project tsconfig.build.json",
     "check-types": "tsc --noEmit",
     "docs": "typedoc",
-    "format-and-lint": "biome check . --error-on-warnings",
+    "format-and-lint": "oxfmt --check . && oxlint --deny-warnings",
+    "format-and-lint:fix": "oxfmt . && oxlint --fix",
     "knip": "knip",
     "pgdelta": "bun src/cli/bin/cli.ts",
     "sync-base-images": "bun scripts/sync-supabase-base-images.ts",
@@ -77,12 +75,12 @@
     "test:unit": "bun run test src/",
     "test:integration": "bun run test tests/",
     "update-empty-baseline": "bun scripts/update-empty-catalog-baseline.ts",
-    "version": "changeset version && bun install --no-frozen-lockfile && bun run format-and-lint --write"
+    "version": "changeset version && bun install --no-frozen-lockfile && bun run format-and-lint:fix"
   },
   "dependencies": {
     "@stricli/core": "^1.2.4",
-    "@ts-safeql/sql-tag": "^0.2.0",
     "@supabase/pg-topo": "^1.0.0-alpha.1",
+    "@ts-safeql/sql-tag": "^0.2.0",
     "chalk": "^5.6.2",
     "debug": "^4.3.7",
     "pg": "^8.17.2",
@@ -103,5 +101,8 @@
     "testcontainers": "^11.10.0",
     "typedoc": "^0.28.17",
     "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=20.0.0"
   }
 }

package/src/cli/commands/catalog-export.ts

@@ -4,11 +4,13 @@
 
 import { writeFile } from "node:fs/promises";
 import { buildCommand, type CommandContext } from "@stricli/core";
+import { filterCatalog } from "../../core/catalog.filter.ts";
 import { extractCatalog } from "../../core/catalog.model.ts";
 import {
   serializeCatalog,
   stringifyCatalogSnapshot,
 } from "../../core/catalog.snapshot.ts";
+import type { FilterDSL } from "../../core/integrations/filter/dsl.ts";
 import { createManagedPool } from "../../core/postgres-config.ts";
 
 export const catalogExportCommand = buildCommand({
@@ -30,6 +32,21 @@ export const catalogExportCommand = buildCommand({
         parse: String,
         optional: true,
       },
+      filter: {
+        kind: "parsed",
+        brief:
+          'Filter DSL as inline JSON to filter changes (e.g., \'{"*/schema": "app"}\').',
+        parse: (value: string): FilterDSL => {
+          try {
+            return JSON.parse(value) as FilterDSL;
+          } catch (error) {
+            throw new Error(
+              `Invalid filter JSON: ${error instanceof Error ? error.message : String(error)}`,
+            );
+          }
+        },
+        optional: true,
+      },
     },
     aliases: {
       t: "target",
@@ -48,6 +65,10 @@ Use cases:
   - Snapshot template1 for use as an empty-database baseline
   - Snapshot a production database to generate revert migrations
   - Snapshot any state for reproducible offline diffs
+
+Pass --filter to scope the snapshot to a subset of the catalog (same
+Filter DSL accepted by plan/sync). Useful when committing a baseline
+snapshot to a repo and only one schema's drift is interesting.
     `.trim(),
   },
   async func(
@@ -56,6 +77,7 @@ Use cases:
       target: string;
       output: string;
       role?: string;
+      filter?: FilterDSL;
     },
   ) {
     const { pool, close } = await createManagedPool(flags.target, {
@@ -65,7 +87,10 @@ Use cases:
 
     try {
       const catalog = await extractCatalog(pool);
-      const snapshot = serializeCatalog(catalog);
+      const scoped = flags.filter
+        ? await filterCatalog(catalog, flags.filter)
+        : catalog;
+      const snapshot = serializeCatalog(scoped);
       const json = stringifyCatalogSnapshot(snapshot);
       await writeFile(flags.output, json, "utf-8");
       this.process.stdout.write(

package/src/core/catalog.filter.ts

@@ -0,0 +1,96 @@
+/**
+ * Prune a catalog to the objects that match a Filter DSL expression.
+ *
+ * The Filter DSL is defined over Change objects, so the catalog is
+ * diffed against an empty baseline first to materialize one CREATE
+ * change per object. The filter then evaluates against the same shape
+ * it would at plan time, and the surviving stableIds drive the prune.
+ *
+ * Dependency cascade is not applied. A scoped snapshot is partial by
+ * design: out-of-scope owners, roles, and types must exist on the
+ * target DB at apply time. Cascading would expand the filter beyond
+ * what the caller asked for and, in practice, collapse schema-scoped
+ * exports whose kept objects reference cluster-scoped owners.
+ */
+
+import { diffCatalogs } from "./catalog.diff.ts";
+import { Catalog, createEmptyCatalog } from "./catalog.model.ts";
+import { compileFilterDSL, type FilterDSL } from "./integrations/filter/dsl.ts";
+
+export async function filterCatalog(
+  catalog: Catalog,
+  filter: FilterDSL,
+): Promise<Catalog> {
+  if (
+    typeof filter === "object" &&
+    filter !== null &&
+    (filter as Record<string, unknown>).cascade === true
+  ) {
+    throw new Error(
+      "Filter DSL `cascade: true` is not supported by catalog-export: " +
+        "scoped snapshots are intentionally partial. Out-of-scope owners, " +
+        "roles, and types must exist on the target DB at apply time.",
+    );
+  }
+
+  const empty = await createEmptyCatalog(catalog.version, catalog.currentUser);
+  const changes = diffCatalogs(empty, catalog);
+  const filterFn = compileFilterDSL(filter);
+
+  const keep = new Set<string>();
+  for (const change of changes) {
+    if (!filterFn(change)) continue;
+    for (const id of change.creates ?? []) keep.add(id);
+  }
+
+  return pruneCatalog(catalog, keep);
+}
+
+function filterRecord<T>(
+  record: Record<string, T>,
+  keep: ReadonlySet<string>,
+): Record<string, T> {
+  return Object.fromEntries(
+    Object.entries(record).filter(([id]) => keep.has(id)),
+  );
+}
+
+function pruneCatalog(catalog: Catalog, keep: ReadonlySet<string>): Catalog {
+  const tables = filterRecord(catalog.tables, keep);
+  const materializedViews = filterRecord(catalog.materializedViews, keep);
+
+  return new Catalog({
+    aggregates: filterRecord(catalog.aggregates, keep),
+    collations: filterRecord(catalog.collations, keep),
+    compositeTypes: filterRecord(catalog.compositeTypes, keep),
+    domains: filterRecord(catalog.domains, keep),
+    enums: filterRecord(catalog.enums, keep),
+    extensions: filterRecord(catalog.extensions, keep),
+    procedures: filterRecord(catalog.procedures, keep),
+    indexes: filterRecord(catalog.indexes, keep),
+    materializedViews,
+    subscriptions: filterRecord(catalog.subscriptions, keep),
+    publications: filterRecord(catalog.publications, keep),
+    rlsPolicies: filterRecord(catalog.rlsPolicies, keep),
+    roles: filterRecord(catalog.roles, keep),
+    schemas: filterRecord(catalog.schemas, keep),
+    sequences: filterRecord(catalog.sequences, keep),
+    tables,
+    triggers: filterRecord(catalog.triggers, keep),
+    eventTriggers: filterRecord(catalog.eventTriggers, keep),
+    rules: filterRecord(catalog.rules, keep),
+    ranges: filterRecord(catalog.ranges, keep),
+    views: filterRecord(catalog.views, keep),
+    foreignDataWrappers: filterRecord(catalog.foreignDataWrappers, keep),
+    servers: filterRecord(catalog.servers, keep),
+    userMappings: filterRecord(catalog.userMappings, keep),
+    foreignTables: filterRecord(catalog.foreignTables, keep),
+    depends: catalog.depends.filter(
+      (d) =>
+        keep.has(d.dependent_stable_id) && keep.has(d.referenced_stable_id),
+    ),
+    indexableObjects: { ...tables, ...materializedViews },
+    version: catalog.version,
+    currentUser: catalog.currentUser,
+  });
+}

package/src/core/catalog.model.ts

@@ -183,7 +183,8 @@ let _pg17Baseline: Catalog | null = null;
 
 async function loadBaselineJson(): Promise<Record<string, unknown>> {
   const mod = await import(
-    "./fixtures/empty-catalogs/postgres-15-16-baseline.json"
+    "./fixtures/empty-catalogs/postgres-15-16-baseline.json",
+    { with: { type: "json" } }
   );
   return mod.default as Record<string, unknown>;
 }
@@ -256,10 +257,12 @@ export async function createEmptyCatalog(
 ): Promise<Catalog> {
   if (version >= 170000) {
     const baseline = await getPg17Baseline();
+    // oxlint-disable-next-line typescript/no-misused-spread
     return new Catalog({ ...baseline, version, currentUser });
   }
   if (version >= 150000) {
     const baseline = await getPg1516Baseline();
+    // oxlint-disable-next-line typescript/no-misused-spread
     return new Catalog({ ...baseline, version, currentUser });
   }
 
@@ -446,6 +449,8 @@ function normalizeCatalog(catalog: Catalog): Catalog {
       options: redactSensitiveOptionPairs(server.options),
       comment: server.comment,
       privileges: server.privileges,
+      wrapper_handler: server.wrapper_handler,
+      wrapper_validator: server.wrapper_validator,
     });
   });
 
@@ -454,6 +459,8 @@ function normalizeCatalog(catalog: Catalog): Catalog {
       user: mapping.user,
       server: mapping.server,
       options: redactSensitiveOptionPairs(mapping.options),
+      wrapper_handler: mapping.wrapper_handler,
+      wrapper_validator: mapping.wrapper_validator,
     });
   });
 
@@ -469,6 +476,8 @@ function normalizeCatalog(catalog: Catalog): Catalog {
         options: redactSensitiveOptionPairs(foreignTable.options),
         comment: foreignTable.comment,
         privileges: foreignTable.privileges,
+        wrapper_handler: foreignTable.wrapper_handler,
+        wrapper_validator: foreignTable.wrapper_validator,
       }),
   );
 

package/src/core/catalog.snapshot.test.ts

@@ -294,6 +294,7 @@ describe("catalog snapshot serde", () => {
 
     const sourceCatalog = await createEmptyCatalog(160000, "postgres");
     const targetCatalog = await createEmptyCatalog(160000, "postgres");
+    // oxlint-disable-next-line typescript/no-misused-spread
     const source = { ...sourceCatalog };
 
     expect(source instanceof Catalog).toBe(false);

package/src/core/expand-replace-dependencies.test.ts

@@ -189,11 +189,13 @@ describe("expandReplaceDependencies", () => {
       privileges: [],
     });
     const branchView = new View({
+      // oxlint-disable-next-line typescript/no-misused-spread
       ...mainView,
       definition: " SELECT count(*) AS n FROM public.members;",
     });
 
     const mainCatalog = new Catalog({
+      // oxlint-disable-next-line typescript/no-misused-spread
       ...baseline,
       tables: { [usersTable.stableId]: usersTable },
       views: { [mainView.stableId]: mainView },
@@ -206,6 +208,7 @@ describe("expandReplaceDependencies", () => {
       ],
     });
     const branchCatalog = new Catalog({
+      // oxlint-disable-next-line typescript/no-misused-spread
       ...baseline,
       views: { [branchView.stableId]: branchView },
     });
@@ -253,6 +256,7 @@ describe("expandReplaceDependencies", () => {
       owner: "postgres",
     });
     const branchSequence = new Sequence({
+      // oxlint-disable-next-line typescript/no-misused-spread
       ...mainSequence,
       persistence: "p",
     });
@@ -309,6 +313,7 @@ describe("expandReplaceDependencies", () => {
       { [usersTable.stableId]: usersTable },
     );
     const mainCatalog = new Catalog({
+      // oxlint-disable-next-line typescript/no-misused-spread
       ...baseline,
       sequences: { [mainSequence.stableId]: mainSequence },
       tables: { [usersTable.stableId]: usersTable },
@@ -326,6 +331,7 @@ describe("expandReplaceDependencies", () => {
       ],
     });
     const branchCatalog = new Catalog({
+      // oxlint-disable-next-line typescript/no-misused-spread
       ...baseline,
       sequences: { [branchSequence.stableId]: branchSequence },
       tables: { [usersTable.stableId]: usersTable },
@@ -369,6 +375,7 @@ describe("expandReplaceDependencies", () => {
       privileges: [],
     });
     const branchEnum = new Enum({
+      // oxlint-disable-next-line typescript/no-misused-spread
       ...mainEnum,
       labels: [
         { sort_order: 1, label: "draft" },
@@ -430,6 +437,7 @@ describe("expandReplaceDependencies", () => {
       privileges: [],
     });
     const branchChildren = new Table({
+      // oxlint-disable-next-line typescript/no-misused-spread
       ...mainChildren,
       columns: [
         { ...columnTemplate, name: "id", position: 1, not_null: true },
@@ -522,6 +530,7 @@ describe("expandReplaceDependencies", () => {
     ];
 
     const mainCatalog = new Catalog({
+      // oxlint-disable-next-line typescript/no-misused-spread
       ...baseline,
       enums: { [mainEnum.stableId]: mainEnum },
       tables: { [mainChildren.stableId]: mainChildren },
@@ -535,6 +544,7 @@ describe("expandReplaceDependencies", () => {
       ],
     });
     const branchCatalog = new Catalog({
+      // oxlint-disable-next-line typescript/no-misused-spread
       ...baseline,
       enums: { [branchEnum.stableId]: branchEnum },
       tables: { [branchChildren.stableId]: branchChildren },
@@ -657,6 +667,7 @@ describe("expandReplaceDependencies", () => {
     ];
 
     const mainCatalog = new Catalog({
+      // oxlint-disable-next-line typescript/no-misused-spread
       ...baseline,
       procedures: { [mainProcedure.stableId]: mainProcedure },
       views: { [mainView.stableId]: mainView },
@@ -669,6 +680,7 @@ describe("expandReplaceDependencies", () => {
       ],
     });
     const branchCatalog = new Catalog({
+      // oxlint-disable-next-line typescript/no-misused-spread
       ...baseline,
       procedures: { [branchProcedure.stableId]: branchProcedure },
       views: { [branchView.stableId]: branchView },

package/src/core/expand-replace-dependencies.ts

@@ -8,10 +8,7 @@ import { CreateMaterializedView } from "./objects/materialized-view/changes/mate
 import { DropMaterializedView } from "./objects/materialized-view/changes/materialized-view.drop.ts";
 import { CreateProcedure } from "./objects/procedure/changes/procedure.create.ts";
 import { DropProcedure } from "./objects/procedure/changes/procedure.drop.ts";
-import {
-  AlterTableAddConstraint,
-  AlterTableValidateConstraint,
-} from "./objects/table/changes/table.alter.ts";
+import { AlterTableAddConstraint } from "./objects/table/changes/table.alter.ts";
 import { CreateCommentOnConstraint } from "./objects/table/changes/table.comment.ts";
 import { CreateTable } from "./objects/table/changes/table.create.ts";
 import { DropTable } from "./objects/table/changes/table.drop.ts";
@@ -455,14 +452,6 @@ function buildReplaceChanges(
                       constraint,
                     }),
                   ];
-                  if (!constraint.validated) {
-                    items.push(
-                      new AlterTableValidateConstraint({
-                        table: resolved.branch,
-                        constraint,
-                      }),
-                    );
-                  }
                   if (
                     constraint.comment !== null &&
                     constraint.comment !== undefined