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

package/src/core/objects/rls-policy/changes/rls-policy.base.ts

@@ -4,7 +4,7 @@ import type { RlsPolicy } from "../rls-policy.model.ts";
 abstract class BaseRlsPolicyChange extends BaseChange {
   abstract readonly policy: RlsPolicy;
   abstract readonly scope: "object" | "comment";
-  readonly objectType: "rls_policy" = "rls_policy";
+  readonly objectType = "rls_policy" as const;
 }
 
 export abstract class CreateRlsPolicyChange extends BaseRlsPolicyChange {

package/src/core/objects/role/changes/role.base.ts

@@ -9,7 +9,7 @@ abstract class BaseRoleChange extends BaseChange {
     | "membership"
     | "default_privilege"
     | "security_label";
-  readonly objectType: "role" = "role";
+  readonly objectType = "role" as const;
 }
 
 export abstract class CreateRoleChange extends BaseRoleChange {

package/src/core/objects/schema/changes/schema.base.ts

@@ -8,7 +8,7 @@ abstract class BaseSchemaChange extends BaseChange {
     | "comment"
     | "privilege"
     | "security_label";
-  readonly objectType: "schema" = "schema";
+  readonly objectType = "schema" as const;
 }
 
 export abstract class CreateSchemaChange extends BaseSchemaChange {

package/src/core/objects/sequence/changes/sequence.base.ts

@@ -8,7 +8,7 @@ abstract class BaseSequenceChange extends BaseChange {
     | "comment"
     | "privilege"
     | "security_label";
-  readonly objectType: "sequence" = "sequence";
+  readonly objectType = "sequence" as const;
 }
 
 export abstract class CreateSequenceChange extends BaseSequenceChange {

package/src/core/objects/table/changes/table.base.ts

@@ -8,7 +8,7 @@ abstract class BaseTableChange extends BaseChange {
     | "comment"
     | "privilege"
     | "security_label";
-  readonly objectType: "table" = "table";
+  readonly objectType = "table" as const;
 }
 
 export abstract class CreateTableChange extends BaseTableChange {

package/src/core/objects/table/changes/table.comment.ts

@@ -179,10 +179,7 @@ export class CreateCommentOnConstraint extends CreateTableChange {
   public readonly constraint: TableConstraintProps;
   public readonly scope = "comment" as const;
 
-  constructor(props: {
-    table: Table;
-    constraint: TableConstraintProps;
-  }) {
+  constructor(props: { table: Table; constraint: TableConstraintProps }) {
     super();
     this.table = props.table;
     this.constraint = props.constraint;
@@ -228,10 +225,7 @@ export class DropCommentOnConstraint extends DropTableChange {
   public readonly constraint: TableConstraintProps;
   public readonly scope = "comment" as const;
 
-  constructor(props: {
-    table: Table;
-    constraint: TableConstraintProps;
-  }) {
+  constructor(props: { table: Table; constraint: TableConstraintProps }) {
     super();
     this.table = props.table;
     this.constraint = props.constraint;

package/src/core/objects/table/table.diff.test.ts

@@ -75,7 +75,7 @@ describe.concurrent("table.diff", () => {
     expect(dropped[0]).toBeInstanceOf(DropTable);
   });
 
-  test("created NOT VALID CHECK emits AddConstraint + ValidateConstraint", () => {
+  test("created NOT VALID CHECK emits AddConstraint only (no Validate)", () => {
     const main = new Table({
       ...base,
       name: "t_nv",
@@ -102,6 +102,7 @@ describe.concurrent("table.diff", () => {
       constraints: [],
     });
     const branch = new Table({
+      // oxlint-disable-next-line typescript/no-misused-spread
       ...main,
       constraints: [
         {
@@ -132,20 +133,208 @@ describe.concurrent("table.diff", () => {
           match_type: null,
           check_expression: "a > 0",
           owner: "o1",
+          definition: "CHECK (a > 0) NOT VALID",
+        },
+      ],
+    });
+    const changes = diffTables(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    const add = changes.find((c) => c instanceof AlterTableAddConstraint);
+    expect(add).toBeInstanceOf(AlterTableAddConstraint);
+    expect(add?.serialize()).toContain("NOT VALID");
+    expect(changes.some((c) => c instanceof AlterTableValidateConstraint)).toBe(
+      false,
+    );
+  });
+
+  test("NOT VALID -> validated emits only VALIDATE CONSTRAINT (no drop+add)", () => {
+    const sharedConstraint = {
+      name: "ck_nv",
+      constraint_type: "c" as const,
+      deferrable: false,
+      initially_deferred: false,
+      is_local: true,
+      no_inherit: false,
+      is_temporal: false,
+      is_partition_clone: false,
+      parent_constraint_schema: null,
+      parent_constraint_name: null,
+      parent_table_schema: null,
+      parent_table_name: null,
+      key_columns: [],
+      foreign_key_columns: null,
+      foreign_key_table: null,
+      foreign_key_schema: null,
+      foreign_key_table_is_partition: null,
+      foreign_key_parent_schema: null,
+      foreign_key_parent_table: null,
+      foreign_key_effective_schema: null,
+      foreign_key_effective_table: null,
+      on_update: null,
+      on_delete: null,
+      match_type: null,
+      check_expression: "a > 0",
+      owner: "o1",
+      comment: null,
+    };
+
+    const main = new Table({
+      ...base,
+      name: "t_nv",
+      columns: [
+        {
+          name: "a",
+          position: 1,
+          data_type: "integer",
+          data_type_str: "integer",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: null,
+          comment: null,
+        },
+      ],
+      constraints: [
+        {
+          ...sharedConstraint,
+          validated: false,
+          definition: "CHECK (a > 0) NOT VALID",
+        },
+      ],
+    });
+    const branch = new Table({
+      // oxlint-disable-next-line typescript/no-misused-spread
+      ...main,
+      constraints: [
+        {
+          ...sharedConstraint,
+          validated: true,
           definition: "CHECK (a > 0)",
         },
       ],
     });
+
+    const changes = diffTables(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+
+    const validate = changes.find(
+      (c) => c instanceof AlterTableValidateConstraint,
+    );
+    expect(validate).toBeInstanceOf(AlterTableValidateConstraint);
+    expect(validate?.serialize()).toMatchInlineSnapshot(
+      `"ALTER TABLE public.t_nv VALIDATE CONSTRAINT ck_nv"`,
+    );
+
+    expect(changes.some((c) => c instanceof AlterTableDropConstraint)).toBe(
+      false,
+    );
+    expect(changes.some((c) => c instanceof AlterTableAddConstraint)).toBe(
+      false,
+    );
+  });
+
+  test("NOT VALID -> validated + other field change still drops+adds (no shortcut)", () => {
+    const sharedConstraint = {
+      name: "ck_nv",
+      constraint_type: "c" as const,
+      deferrable: false,
+      initially_deferred: false,
+      is_local: true,
+      no_inherit: false,
+      is_temporal: false,
+      is_partition_clone: false,
+      parent_constraint_schema: null,
+      parent_constraint_name: null,
+      parent_table_schema: null,
+      parent_table_name: null,
+      key_columns: [],
+      foreign_key_columns: null,
+      foreign_key_table: null,
+      foreign_key_schema: null,
+      foreign_key_table_is_partition: null,
+      foreign_key_parent_schema: null,
+      foreign_key_parent_table: null,
+      foreign_key_effective_schema: null,
+      foreign_key_effective_table: null,
+      on_update: null,
+      on_delete: null,
+      match_type: null,
+      owner: "o1",
+      comment: null,
+    };
+
+    const main = new Table({
+      ...base,
+      name: "t_nv",
+      columns: [
+        {
+          name: "a",
+          position: 1,
+          data_type: "integer",
+          data_type_str: "integer",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: null,
+          comment: null,
+        },
+      ],
+      constraints: [
+        {
+          ...sharedConstraint,
+          validated: false,
+          check_expression: "a > 0",
+          definition: "CHECK (a > 0) NOT VALID",
+        },
+      ],
+    });
+    const branch = new Table({
+      // oxlint-disable-next-line typescript/no-misused-spread
+      ...main,
+      constraints: [
+        {
+          ...sharedConstraint,
+          validated: true,
+          check_expression: "a > 1",
+          definition: "CHECK (a > 1)",
+        },
+      ],
+    });
+
     const changes = diffTables(
       testContext,
       { [main.stableId]: main },
       { [branch.stableId]: branch },
     );
+
+    expect(changes.some((c) => c instanceof AlterTableDropConstraint)).toBe(
+      true,
+    );
     expect(changes.some((c) => c instanceof AlterTableAddConstraint)).toBe(
       true,
     );
     expect(changes.some((c) => c instanceof AlterTableValidateConstraint)).toBe(
-      true,
+      false,
     );
   });
 
@@ -362,7 +551,7 @@ describe.concurrent("table.diff", () => {
       true,
     );
     expect(created.some((c) => c instanceof AlterTableValidateConstraint)).toBe(
-      true,
+      false,
     );
 
     const dropped = diffTables(
@@ -480,6 +669,7 @@ describe.concurrent("table.diff", () => {
       ],
     });
     const tBranch = new Table({
+      // oxlint-disable-next-line typescript/no-misused-spread
       ...tMain,
       constraints: [
         {
@@ -501,7 +691,7 @@ describe.concurrent("table.diff", () => {
     );
   });
 
-  test("altered foreign key properties triggers drop+add and validate when not validated", () => {
+  test("altered foreign key to NOT VALID triggers drop+add without validate", () => {
     const tMain = new Table({
       ...base,
       name: "t_fk",
@@ -559,12 +749,14 @@ describe.concurrent("table.diff", () => {
       ],
     });
     const tBranch = new Table({
+      // oxlint-disable-next-line typescript/no-misused-spread
       ...tMain,
       constraints: [
         {
           ...(tMain.constraints[0] as (typeof tMain.constraints)[number]),
           on_delete: "c",
           validated: false,
+          definition: "FOREIGN KEY (a) REFERENCES other(a) NOT VALID",
         },
       ],
     });
@@ -606,7 +798,7 @@ describe.concurrent("table.diff", () => {
       true,
     );
     expect(changes.some((c) => c instanceof AlterTableValidateConstraint)).toBe(
-      true,
+      false,
     );
   });
 
@@ -686,6 +878,7 @@ describe.concurrent("table.diff", () => {
       ],
     });
     const tBranch = new Table({
+      // oxlint-disable-next-line typescript/no-misused-spread
       ...tMain,
       constraints: [
         {

package/src/core/objects/table/table.diff.ts

@@ -86,14 +86,6 @@ function createAlterConstraintChange(mainTable: Table, branchTable: Table) {
           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(
@@ -120,7 +112,7 @@ function createAlterConstraintChange(mainTable: Table, branchTable: Table) {
     }
   }
 
-  // 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) continue;
@@ -130,24 +122,68 @@ function createAlterConstraintChange(mainTable: Table, branchTable: Table) {
       continue;
     }
 
+    // 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.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;
+      mainC.validated !== branchC.validated || !fieldsEqualExceptValidated;
     if (changed) {
       changes.push(
         new AlterTableDropConstraint({
@@ -161,14 +197,6 @@ function createAlterConstraintChange(mainTable: Table, branchTable: Table) {
           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(
@@ -265,6 +293,7 @@ export function diffTables(
       ...createAlterConstraintChange(
         // Create a dummy table with no constraints do diff constraints against
         new Table({
+          // oxlint-disable-next-line typescript/no-misused-spread
           ...branchTable,
           constraints: [],
         }),

package/src/core/objects/trigger/changes/trigger.alter.ts

@@ -28,10 +28,7 @@ export class ReplaceTrigger extends AlterTriggerChange {
   public readonly indexableObject?: TableLikeObject;
   public readonly scope = "object" as const;
 
-  constructor(props: {
-    trigger: Trigger;
-    indexableObject?: TableLikeObject;
-  }) {
+  constructor(props: { trigger: Trigger; indexableObject?: TableLikeObject }) {
     super();
     this.trigger = props.trigger;
     this.indexableObject = props.indexableObject;

package/src/core/objects/trigger/changes/trigger.base.ts

@@ -4,7 +4,7 @@ import type { Trigger } from "../trigger.model.ts";
 abstract class BaseTriggerChange extends BaseChange {
   abstract readonly trigger: Trigger;
   abstract readonly scope: "object" | "comment";
-  readonly objectType: "trigger" = "trigger";
+  readonly objectType = "trigger" as const;
 }
 
 export abstract class CreateTriggerChange extends BaseTriggerChange {

package/src/core/objects/type/composite-type/changes/composite-type.base.ts

@@ -8,7 +8,7 @@ abstract class BaseCompositeTypeChange extends BaseChange {
     | "comment"
     | "privilege"
     | "security_label";
-  readonly objectType: "composite_type" = "composite_type";
+  readonly objectType = "composite_type" as const;
 }
 
 export abstract class CreateCompositeTypeChange extends BaseCompositeTypeChange {

package/src/core/objects/type/enum/changes/enum.base.ts

@@ -8,7 +8,7 @@ abstract class BaseEnumChange extends BaseChange {
     | "comment"
     | "privilege"
     | "security_label";
-  readonly objectType: "enum" = "enum";
+  readonly objectType = "enum" as const;
 }
 
 export abstract class CreateEnumChange extends BaseEnumChange {

package/src/core/objects/type/range/changes/range.base.ts

@@ -8,7 +8,7 @@ abstract class BaseRangeChange extends BaseChange {
     | "comment"
     | "privilege"
     | "security_label";
-  readonly objectType: "range" = "range";
+  readonly objectType = "range" as const;
 }
 
 export abstract class CreateRangeChange extends BaseRangeChange {

package/src/core/objects/view/changes/view.base.ts

@@ -8,7 +8,7 @@ abstract class BaseViewChange extends BaseChange {
     | "comment"
     | "privilege"
     | "security_label";
-  readonly objectType: "view" = "view";
+  readonly objectType = "view" as const;
 }
 
 export abstract class CreateViewChange extends BaseViewChange {

package/src/core/plan/hierarchy.ts

@@ -322,7 +322,7 @@ function addClusterChange(cluster: ClusterGroup, change: Change): void {
       break;
     default: {
       const _exhaustive: never = objectType;
-      throw new Error(`Unhandled object type: ${_exhaustive}`);
+      throw new Error(`Unhandled object type: ${JSON.stringify(_exhaustive)}`);
     }
   }
 }
@@ -366,7 +366,7 @@ function addChildChange(schema: SchemaGroup, change: Change): void {
       break;
     default: {
       const _exhaustive: never = parentType;
-      throw new Error(`Unhandled parent type: ${_exhaustive}`);
+      throw new Error(`Unhandled parent type: ${JSON.stringify(_exhaustive)}`);
     }
   }
 
@@ -416,7 +416,7 @@ function addChildChange(schema: SchemaGroup, change: Change): void {
       break;
     default: {
       const _exhaustive: never = objectType;
-      throw new Error(`Unhandled object type: ${_exhaustive}`);
+      throw new Error(`Unhandled object type: ${JSON.stringify(_exhaustive)}`);
     }
   }
 }
@@ -568,7 +568,7 @@ function addSchemaLevelChange(
       break;
     default: {
       const _exhaustive: never = objectType;
-      throw new Error(`Unhandled object type: ${_exhaustive}`);
+      throw new Error(`Unhandled object type: ${JSON.stringify(_exhaustive)}`);
     }
   }
 }

package/src/core/postgres-config.test.ts

@@ -1,6 +1,7 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, spyOn, test } from "bun:test";
 import {
   connectWithRetry,
+  connectWithTimeout,
   isRetryableConnectError,
   poolConfigFromUrl,
 } from "./postgres-config.ts";
@@ -241,6 +242,43 @@ describe("connectWithRetry", () => {
   });
 });
 
+describe("connectWithTimeout", () => {
+  test("clears the timer when connect resolves before it fires", async () => {
+    const clearSpy = spyOn(globalThis, "clearTimeout");
+    try {
+      const sentinel = { client: true };
+      const result = await connectWithTimeout(
+        () => Promise.resolve(sentinel),
+        60_000,
+        "source",
+      );
+      expect(result).toBe(sentinel);
+      expect(clearSpy).toHaveBeenCalled();
+    } finally {
+      clearSpy.mockRestore();
+    }
+  });
+
+  test("rejects with a timeout error when connect is too slow", async () => {
+    await expect(
+      connectWithTimeout(() => new Promise<never>(() => {}), 5, "target"),
+    ).rejects.toThrow(/timed out after 5ms/);
+  });
+
+  test("clears the timer even when connect rejects", async () => {
+    const clearSpy = spyOn(globalThis, "clearTimeout");
+    try {
+      const boom = new Error("connect ECONNREFUSED");
+      await expect(
+        connectWithTimeout(() => Promise.reject(boom), 60_000, "target"),
+      ).rejects.toBe(boom);
+      expect(clearSpy).toHaveBeenCalled();
+    } finally {
+      clearSpy.mockRestore();
+    }
+  });
+});
+
 describe("poolConfigFromUrl", () => {
   describe("non-IPv6 URLs pass through as connectionString", () => {
     test("DNS hostname", () => {