@supabase/pg-delta 1.0.0-alpha.16 → 1.0.0-alpha.18

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

@@ -144,12 +144,13 @@ describe.concurrent("procedure.diff", () => {
     expect(changes[0]).toBeInstanceOf(AlterProcedureSetParallel);
   });
 
-  test("create or replace when non-alterable property changes", () => {
+  test("create or replace when body-only non-alterable property changes", () => {
+    // Changing only the language (or source) is OR-REPLACE-safe: no DROP needed.
     const main = new Procedure(base);
     const branch = new Procedure({
       ...base,
-      return_type: "text",
       language: "plpgsql",
+      source_code: "BEGIN RETURN 1; END",
     });
     const changes = diffProcedures(
       testContext,
@@ -158,6 +159,82 @@ describe.concurrent("procedure.diff", () => {
     );
     expect(changes).toHaveLength(1);
     expect(changes[0]).toBeInstanceOf(CreateProcedure);
+    expect((changes[0] as CreateProcedure).orReplace).toBe(true);
+  });
+
+  test("drop + create when return type changes", () => {
+    // `CREATE OR REPLACE FUNCTION` cannot change the return type.
+    const main = new Procedure(base);
+    const branch = new Procedure({ ...base, return_type: "text" });
+    const changes = diffProcedures(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(DropProcedure);
+    expect(changes[1]).toBeInstanceOf(CreateProcedure);
+    expect((changes[1] as CreateProcedure).orReplace).toBe(false);
+  });
+
+  test("drop + create when parameter name changes but type is identical", () => {
+    // Same argument_types means same stableId (altered path), but
+    // `CREATE OR REPLACE` rejects changing an IN parameter's name.
+    const main = new Procedure({
+      ...base,
+      argument_count: 1,
+      argument_names: ["p"],
+      argument_types: ["int4"],
+      all_argument_types: ["int4"],
+      argument_modes: ["i"],
+    });
+    const branch = new Procedure({
+      ...base,
+      argument_count: 1,
+      argument_names: ["renamed"],
+      argument_types: ["int4"],
+      all_argument_types: ["int4"],
+      argument_modes: ["i"],
+    });
+    const changes = diffProcedures(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(DropProcedure);
+    expect(changes[1]).toBeInstanceOf(CreateProcedure);
+    expect((changes[1] as CreateProcedure).orReplace).toBe(false);
+  });
+
+  test("drop + create when a parameter default is removed", () => {
+    // `CREATE OR REPLACE` rejects removing parameter defaults.
+    const main = new Procedure({
+      ...base,
+      argument_count: 1,
+      argument_default_count: 1,
+      argument_names: ["p"],
+      argument_types: ["int4"],
+      all_argument_types: ["int4"],
+      argument_modes: ["i"],
+      argument_defaults: "0",
+    });
+    const branch = new Procedure({
+      ...base,
+      argument_count: 1,
+      argument_default_count: 0,
+      argument_names: ["p"],
+      argument_types: ["int4"],
+      all_argument_types: ["int4"],
+      argument_modes: ["i"],
+      argument_defaults: null,
+    });
+    const changes = diffProcedures(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(DropProcedure);
+    expect(changes[1]).toBeInstanceOf(CreateProcedure);
+    expect((changes[1] as CreateProcedure).orReplace).toBe(false);
   });
 
   test("create or replace also emits a procedure comment when the comment changes", () => {
@@ -183,4 +260,25 @@ describe.concurrent("procedure.diff", () => {
       changes.some((change) => change instanceof CreateCommentOnProcedure),
     ).toBe(true);
   });
+
+  test("signature change re-emits comment even when comment itself is unchanged", () => {
+    // DROP destroys the old comment, so the new CREATE path must re-emit it.
+    const main = new Procedure({ ...base, comment: "hello" });
+    const branch = new Procedure({
+      ...base,
+      return_type: "text",
+      comment: "hello",
+    });
+    const changes = diffProcedures(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes.some((change) => change instanceof DropProcedure)).toBe(
+      true,
+    );
+    expect(
+      changes.some((change) => change instanceof CreateCommentOnProcedure),
+    ).toBe(true);
+  });
 });

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

@@ -49,8 +49,7 @@ export function diffProcedures(
 
   const changes: ProcedureChange[] = [];
 
-  for (const procedureId of created) {
-    const proc = branch[procedureId];
+  const appendCreateProcedureChanges = (proc: Procedure) => {
     changes.push(new CreateProcedure({ procedure: proc }));
 
     // OWNER: If the procedure should be owned by someone other than the current user,
@@ -112,6 +111,10 @@ export function diffProcedures(
         ctx.version,
       ) as ProcedureChange[]),
     );
+  };
+
+  for (const procedureId of created) {
+    appendCreateProcedureChanges(branch[procedureId]);
   }
 
   for (const procedureId of dropped) {
@@ -122,22 +125,18 @@ export function diffProcedures(
     const mainProcedure = main[procedureId];
     const branchProcedure = branch[procedureId];
 
-    // Check if non-alterable properties have changed
-    // These require dropping and recreating the procedure
-    const NON_ALTERABLE_FIELDS: Array<keyof Procedure> = [
+    // Fields that are part of the function's identity/signature. PostgreSQL
+    // rejects `CREATE OR REPLACE FUNCTION` for any of these changes with
+    // errors such as:
+    //   - cannot change return type of existing function
+    //   - cannot change name of input parameter "..."
+    //   - cannot change whether a procedure has output parameters
+    //   - cannot remove parameter defaults from existing function
+    // These require `DROP FUNCTION` followed by `CREATE FUNCTION`.
+    const SIGNATURE_BREAKING_FIELDS: Array<keyof Procedure> = [
       "kind",
       "return_type",
       "return_type_schema",
-      "language",
-      // The following properties are alterable in SQL, but our generator may choose
-      // to replace on changes not covered by explicit ALTER actions. Keep them out here
-      // to allow ALTER for those we implement below.
-      // security_definer,
-      // volatility,
-      // parallel_safety,
-      // is_strict,
-      // leakproof,
-      // Returns-set is part of the signature and not alterable
       "returns_set",
       "argument_count",
       "argument_default_count",
@@ -146,26 +145,45 @@ export function diffProcedures(
       "all_argument_types",
       "argument_modes",
       "argument_defaults",
+    ];
+    // Fields where `CREATE OR REPLACE` is sufficient - body replacement only.
+    // Other fields (security_definer, volatility, parallel_safety, is_strict,
+    // leakproof, config) are alterable via dedicated ALTER actions below.
+    const OR_REPLACEABLE_NON_ALTERABLE_FIELDS: Array<keyof Procedure> = [
+      "language",
       "source_code",
       "binary_path",
       "sql_body",
-      // config is alterable via SET/RESET
     ];
-    const nonAlterablePropsChanged = hasNonAlterableChanges(
+    const signatureChanged = hasNonAlterableChanges(
       mainProcedure,
       branchProcedure,
-      NON_ALTERABLE_FIELDS,
+      SIGNATURE_BREAKING_FIELDS,
       {
         argument_names: deepEqual,
         argument_types: deepEqual,
         all_argument_types: deepEqual,
         argument_modes: deepEqual,
-        config: deepEqual,
       },
     );
+    const nonAlterablePropsChanged =
+      signatureChanged ||
+      hasNonAlterableChanges(
+        mainProcedure,
+        branchProcedure,
+        OR_REPLACEABLE_NON_ALTERABLE_FIELDS,
+      );
 
-    if (nonAlterablePropsChanged) {
-      // Replace the entire procedure
+    if (signatureChanged) {
+      // PostgreSQL cannot change an existing function's signature via
+      // `CREATE OR REPLACE`. Drop the old signature, then recreate.
+      // `expandReplaceDependencies` will cascade the replacement to dependent
+      // objects (views, triggers, column defaults) via pg_depend edges.
+      changes.push(new DropProcedure({ procedure: mainProcedure }));
+      appendCreateProcedureChanges(branchProcedure);
+    } else if (nonAlterablePropsChanged) {
+      // Body-only non-alterable change - `CREATE OR REPLACE` preserves the
+      // function OID and keeps dependent objects attached.
       changes.push(
         new CreateProcedure({ procedure: branchProcedure, orReplace: true }),
       );

package/src/core/objects/table/changes/table.alter.test.ts

@@ -766,6 +766,7 @@ describe.concurrent("table", () => {
         validated: true,
         is_local: true,
         no_inherit: false,
+        is_temporal: false,
         is_partition_clone: false,
         parent_constraint_schema: null,
         parent_constraint_name: null,

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

@@ -112,6 +112,7 @@ describe.concurrent("table.diff", () => {
           validated: false,
           is_local: true,
           no_inherit: false,
+          is_temporal: false,
           is_partition_clone: false,
           parent_constraint_schema: null,
           parent_constraint_name: null,
@@ -328,6 +329,7 @@ describe.concurrent("table.diff", () => {
       validated: false,
       is_local: true,
       no_inherit: false,
+      is_temporal: false,
       is_partition_clone: false,
       parent_constraint_schema: null,
       parent_constraint_name: null,
@@ -453,6 +455,7 @@ describe.concurrent("table.diff", () => {
           validated: true,
           is_local: true,
           no_inherit: false,
+          is_temporal: false,
           is_partition_clone: false,
           parent_constraint_schema: null,
           parent_constraint_name: null,
@@ -531,6 +534,7 @@ describe.concurrent("table.diff", () => {
           validated: true,
           is_local: true,
           no_inherit: false,
+          is_temporal: false,
           is_partition_clone: false,
           parent_constraint_schema: null,
           parent_constraint_name: null,
@@ -606,6 +610,104 @@ describe.concurrent("table.diff", () => {
     );
   });
 
+  test("altered temporal constraint metadata triggers drop+add", () => {
+    const tMain = new Table({
+      ...base,
+      name: "t_temporal",
+      columns: [
+        {
+          name: "room_id",
+          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,
+        },
+        {
+          name: "booking_period",
+          position: 2,
+          data_type: "tstzrange",
+          data_type_str: "tstzrange",
+          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: [
+        {
+          name: "bookings_pkey",
+          constraint_type: "p",
+          deferrable: false,
+          initially_deferred: false,
+          validated: true,
+          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: ["room_id", "booking_period"],
+          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: null,
+          owner: "o1",
+          definition: "PRIMARY KEY (room_id, booking_period)",
+        },
+      ],
+    });
+    const tBranch = new Table({
+      ...tMain,
+      constraints: [
+        {
+          ...tMain.constraints[0],
+          is_temporal: true,
+          definition: "PRIMARY KEY (room_id, booking_period WITHOUT OVERLAPS)",
+        },
+      ],
+    });
+    const changes = diffTables(
+      testContext,
+      { [tMain.stableId]: tMain },
+      { [tBranch.stableId]: tBranch },
+    );
+    expect(changes.some((c) => c instanceof AlterTableDropConstraint)).toBe(
+      true,
+    );
+    expect(changes.some((c) => c instanceof AlterTableAddConstraint)).toBe(
+      true,
+    );
+  });
+
   test("columns added/dropped/altered (type, default, not null)", () => {
     const main = new Table({ ...base, name: "t2", columns: [] });
     const withCol = new Table({

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

@@ -130,6 +130,7 @@ function createAlterConstraintChange(mainTable: Table, branchTable: Table) {
       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) !==

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

@@ -56,6 +56,7 @@ const tableConstraintPropsSchema = z.object({
   validated: z.boolean(),
   is_local: z.boolean(),
   no_inherit: z.boolean(),
+  is_temporal: z.boolean(),
   is_partition_clone: z.boolean(),
   parent_constraint_schema: z.string().nullable(),
   parent_constraint_name: z.string().nullable(),
@@ -284,6 +285,7 @@ select
           'validated', c.convalidated,
           'is_local', c.conislocal,
           'no_inherit', c.connoinherit,
+          'is_temporal', coalesce((to_jsonb(c)->>'conperiod')::boolean, false),
 
           -- NEW: propagated-to-partition tagging (PG15+)
           'is_partition_clone', (c.conparentid <> 0::oid),

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

@@ -67,6 +67,11 @@ export function diffTriggers(
       continue;
     }
 
+    // Note: column_numbers is excluded because it contains pg_trigger.tgattr
+    // attnums that differ between databases when physical column layouts
+    // diverge but logical (named) columns match. The definition field
+    // (pg_get_triggerdef) already captures the UPDATE OF column list by name,
+    // so we compare by definition instead.
     const NON_ALTERABLE_FIELDS: Array<keyof Trigger> = [
       "function_schema",
       "function_name",
@@ -76,18 +81,18 @@ export function diffTriggers(
       "deferrable",
       "initially_deferred",
       "argument_count",
-      "column_numbers",
       "arguments",
       "when_condition",
       "old_table",
       "new_table",
       "owner",
+      "definition", // Compare by definition instead of column_numbers (tgattr)
     ];
     const shouldReplace = hasNonAlterableChanges(
       mainTrigger,
       branchTrigger,
       NON_ALTERABLE_FIELDS,
-      { column_numbers: deepEqual, arguments: deepEqual },
+      { arguments: deepEqual },
     );
     if (shouldReplace) {
       const tableStableId = stableId.table(

package/src/core/objects/trigger/trigger.model.ts

@@ -134,7 +134,10 @@ export class Trigger extends BasePgModel {
       deferrable: this.deferrable,
       initially_deferred: this.initially_deferred,
       argument_count: this.argument_count,
-      column_numbers: this.column_numbers,
+      // column_numbers excluded: contains pg_trigger.tgattr attnums that differ
+      // between databases when physical column layouts diverge but logical
+      // (named) columns match. The definition field (pg_get_triggerdef) captures
+      // the UPDATE OF column list by name, so we compare by definition instead.
       arguments: this.arguments,
       when_condition: this.when_condition,
       old_table: this.old_table,
@@ -145,6 +148,7 @@ export class Trigger extends BasePgModel {
       parent_table_name: this.parent_table_name,
       is_on_partitioned_table: this.is_on_partitioned_table,
       owner: this.owner,
+      definition: this.definition,
       comment: this.comment,
     };
   }

package/src/core/plan/sql-format/fixtures.ts

@@ -578,6 +578,7 @@ const pkConstraint = {
   validated: true,
   is_local: true,
   no_inherit: false,
+  is_temporal: false,
   is_partition_clone: false,
   parent_constraint_schema: null,
   parent_constraint_name: null,
@@ -609,6 +610,7 @@ const uniqueConstraint = {
   validated: true,
   is_local: true,
   no_inherit: false,
+  is_temporal: false,
   is_partition_clone: false,
   parent_constraint_schema: null,
   parent_constraint_name: null,
@@ -639,6 +641,7 @@ const fkConstraint = {
   validated: true,
   is_local: true,
   no_inherit: false,
+  is_temporal: false,
   is_partition_clone: false,
   parent_constraint_schema: null,
   parent_constraint_name: null,
@@ -670,6 +673,7 @@ const checkConstraint = {
   validated: true,
   is_local: true,
   no_inherit: true,
+  is_temporal: false,
   is_partition_clone: false,
   parent_constraint_schema: null,
   parent_constraint_name: null,

package/src/core/post-diff-cycle-breaking.test.ts

@@ -2,12 +2,15 @@ import { describe, expect, test } from "bun:test";
 import { Catalog, createEmptyCatalog } from "./catalog.model.ts";
 import type { Change } from "./change.types.ts";
 import {
+  AlterTableAddConstraint,
   AlterTableChangeOwner,
   AlterTableDropColumn,
   AlterTableDropConstraint,
   AlterTableEnableRowLevelSecurity,
   AlterTableSetReplicaIdentity,
+  AlterTableValidateConstraint,
 } 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";
 import { GrantTablePrivileges } from "./objects/table/changes/table.privilege.ts";
@@ -77,6 +80,7 @@ describe("normalizePostDiffCycles", () => {
           validated: true,
           is_local: true,
           no_inherit: false,
+          is_temporal: false,
           is_partition_clone: false,
           parent_constraint_schema: null,
           parent_constraint_name: null,
@@ -117,6 +121,7 @@ describe("normalizePostDiffCycles", () => {
           validated: true,
           is_local: true,
           no_inherit: false,
+          is_temporal: false,
           is_partition_clone: false,
           parent_constraint_schema: null,
           parent_constraint_name: null,
@@ -237,6 +242,7 @@ describe("normalizePostDiffCycles", () => {
         validated: true,
         is_local: true,
         no_inherit: false,
+        is_temporal: false,
         is_partition_clone: false,
         parent_constraint_schema: null,
         parent_constraint_name: null,
@@ -314,4 +320,140 @@ describe("normalizePostDiffCycles", () => {
     expect(normalized).toContain(preExistingReplicaIdentity);
     expect(normalized).toContain(preExistingGrant);
   });
+
+  test("dedupes duplicate constraint Add/Validate/Comment on replaced tables keeping last occurrence", async () => {
+    const baseline = await createEmptyCatalog(170000, "postgres");
+    const branchChildren = new Table({
+      ...baseTableProps,
+      name: "children",
+      columns: [
+        { ...integerColumn("id", 1), not_null: true },
+        integerColumn("parent_ref", 2),
+      ],
+    });
+    const otherTable = new Table({
+      ...baseTableProps,
+      name: "other",
+      columns: [{ ...integerColumn("id", 1), not_null: true }],
+    });
+
+    const fkConstraint = {
+      name: "children_parent_ref_fkey",
+      constraint_type: "f" as const,
+      deferrable: false,
+      initially_deferred: false,
+      validated: false,
+      is_local: true,
+      no_inherit: false,
+      is_temporal: true,
+      is_partition_clone: false,
+      parent_constraint_schema: null,
+      parent_constraint_name: null,
+      parent_table_schema: null,
+      parent_table_name: null,
+      key_columns: ["parent_ref"],
+      foreign_key_columns: ["id"],
+      foreign_key_table: "parents",
+      foreign_key_schema: "public",
+      foreign_key_table_is_partition: false,
+      foreign_key_parent_schema: null,
+      foreign_key_parent_table: null,
+      foreign_key_effective_schema: "public",
+      foreign_key_effective_table: "parents",
+      on_update: "a" as const,
+      on_delete: "a" as const,
+      match_type: "s" as const,
+      check_expression: null,
+      owner: "postgres",
+      definition:
+        "FOREIGN KEY (parent_ref, PERIOD valid_period) REFERENCES public.parents(id, PERIOD valid_period)",
+      comment: "fk comment",
+    };
+    const otherConstraint = {
+      ...fkConstraint,
+      name: "other_unique",
+      constraint_type: "u" as const,
+      foreign_key_table: null,
+      foreign_key_schema: null,
+      foreign_key_effective_schema: null,
+      foreign_key_effective_table: null,
+      foreign_key_columns: [],
+      key_columns: ["id"],
+      definition: "UNIQUE (id)",
+    };
+
+    const diffTablesAdd = new AlterTableAddConstraint({
+      table: branchChildren,
+      constraint: fkConstraint,
+    });
+    const diffTablesValidate = new AlterTableValidateConstraint({
+      table: branchChildren,
+      constraint: fkConstraint,
+    });
+    const diffTablesComment = new CreateCommentOnConstraint({
+      table: branchChildren,
+      constraint: fkConstraint,
+    });
+    const expansionAdd = new AlterTableAddConstraint({
+      table: branchChildren,
+      constraint: fkConstraint,
+    });
+    const expansionValidate = new AlterTableValidateConstraint({
+      table: branchChildren,
+      constraint: fkConstraint,
+    });
+    const expansionComment = new CreateCommentOnConstraint({
+      table: branchChildren,
+      constraint: fkConstraint,
+    });
+    const soloOtherTableAdd = new AlterTableAddConstraint({
+      table: otherTable,
+      constraint: otherConstraint,
+    });
+
+    const changes: Change[] = [
+      new DropTable({ table: branchChildren }),
+      new CreateTable({ table: branchChildren }),
+      diffTablesAdd,
+      diffTablesValidate,
+      diffTablesComment,
+      soloOtherTableAdd,
+      expansionAdd,
+      expansionValidate,
+      expansionComment,
+    ];
+
+    const mainCatalog = new Catalog({
+      ...baseline,
+      tables: { [branchChildren.stableId]: branchChildren },
+    });
+
+    const normalized = normalizePostDiffCycles({
+      changes,
+      mainCatalog,
+      replacedTableIds: new Set([branchChildren.stableId]),
+    });
+
+    expect(normalized).not.toContain(diffTablesAdd);
+    expect(normalized).not.toContain(diffTablesValidate);
+    expect(normalized).not.toContain(diffTablesComment);
+    expect(normalized).toContain(expansionAdd);
+    expect(normalized).toContain(expansionValidate);
+    expect(normalized).toContain(expansionComment);
+    expect(normalized).toContain(soloOtherTableAdd);
+
+    expect(
+      normalized.filter((change) => change instanceof AlterTableAddConstraint),
+    ).toHaveLength(2);
+    expect(
+      normalized.filter(
+        (change) => change instanceof AlterTableValidateConstraint,
+      ),
+    ).toHaveLength(1);
+    expect(
+      normalized.filter(
+        (change) => change instanceof CreateCommentOnConstraint,
+      ),
+    ).toHaveLength(1);
+  });
 });