@supabase/pg-delta 1.0.0-alpha.17 → 1.0.0-alpha.19

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/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,
@@ -996,6 +1000,8 @@ const rlsPolicy = new RlsPolicy({
   with_check_expression: null,
   owner: "owner1",
   comment: "rls policy comment",
+  referenced_relations: [],
+  referenced_procedures: [],
 });
 
 const rlsPolicyRestrictive = new RlsPolicy({
@@ -1009,6 +1015,8 @@ const rlsPolicyRestrictive = new RlsPolicy({
   with_check_expression: "status <> 'locked'",
   owner: "owner1",
   comment: null,
+  referenced_relations: [],
+  referenced_procedures: [],
 });
 
 const index = new Index({

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);
+  });
 });

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

@@ -1,9 +1,12 @@
 import type { Catalog } from "./catalog.model.ts";
 import type { Change } from "./change.types.ts";
 import {
+  AlterTableAddConstraint,
   AlterTableDropColumn,
   AlterTableDropConstraint,
+  AlterTableValidateConstraint,
 } from "./objects/table/changes/table.alter.ts";
+import { CreateCommentOnConstraint } from "./objects/table/changes/table.comment.ts";
 import { DropTable } from "./objects/table/changes/table.drop.ts";
 import { stableId } from "./objects/utils.ts";
 
@@ -52,6 +55,72 @@ function isSupersededByTableReplacement(
   return replacedTableIds.has(change.table.stableId);
 }
 
+/**
+ * Drop earlier duplicates of `AlterTableAddConstraint` /
+ * `AlterTableValidateConstraint` / `CreateCommentOnConstraint` targeting
+ * replaced tables, keeping only the last occurrence of each
+ * `(changeType, table.stableId, constraint.name)`.
+ *
+ * When `expandReplaceDependencies()` promotes a table to a full
+ * `DropTable + CreateTable` pair, it also emits one
+ * `AlterTableAddConstraint` (plus optional `VALIDATE CONSTRAINT` /
+ * `COMMENT ON CONSTRAINT`) per branch constraint. If `diffTables()` already
+ * emitted the same change for a shape flip or a new constraint on that
+ * table, the plan ends up with two identical `ALTER TABLE ... ADD
+ * CONSTRAINT ...` statements and PostgreSQL fails at apply time with
+ * `constraint "..." for relation "..." already exists`. Because
+ * `expandReplaceDependencies()` appends its additions after the original
+ * `diffTables()` output, the last occurrence is the expansion's emission —
+ * keeping it preserves correctness while removing the duplicate.
+ */
+function dropReplacedTableDuplicateConstraintChanges(
+  changes: Change[],
+  replacedTableIds: ReadonlySet<string>,
+): Change[] {
+  if (replacedTableIds.size === 0) return changes;
+
+  const keyFor = (change: Change): string | null => {
+    if (
+      !(change instanceof AlterTableAddConstraint) &&
+      !(change instanceof AlterTableValidateConstraint) &&
+      !(change instanceof CreateCommentOnConstraint)
+    ) {
+      return null;
+    }
+    if (!replacedTableIds.has(change.table.stableId)) return null;
+    const tag =
+      change instanceof AlterTableAddConstraint
+        ? "add"
+        : change instanceof AlterTableValidateConstraint
+          ? "validate"
+          : "comment";
+    return `${tag}:${constraintStableId(change.table, change.constraint.name)}`;
+  };
+
+  const seen = new Set<string>();
+  const reversedKept: Change[] = [];
+  let mutated = false;
+
+  // Walk backwards: the first encounter of each key corresponds to its LAST
+  // occurrence in the original order. `expandReplaceDependencies()` appends
+  // additions after the original changes, so "last wins" keeps the
+  // expansion's emission and drops the earlier diffTables duplicate.
+  for (let i = changes.length - 1; i >= 0; i--) {
+    const change = changes[i] as Change;
+    const key = keyFor(change);
+    if (key !== null) {
+      if (seen.has(key)) {
+        mutated = true;
+        continue;
+      }
+      seen.add(key);
+    }
+    reversedKept.push(change);
+  }
+
+  return mutated ? reversedKept.reverse() : changes;
+}
+
 function collectExplicitConstraintDropIds(changes: Change[]) {
   const explicitConstraintDropIds = new Set<string>();
 
@@ -84,6 +153,13 @@ function hasSameEntries(
  * - If replace expansion added `DropTable(T)+CreateTable(T)`, targeted
  *   `AlterTableDropColumn(T.*)` / `AlterTableDropConstraint(T.*)` changes are
  *   redundant and create an unbreakable drop-phase cycle, so we elide them.
+ * - When the same `DropTable+CreateTable` pair is present, the expansion
+ *   also emits one `AlterTableAddConstraint` / `AlterTableValidateConstraint`
+ *   / `CreateCommentOnConstraint` per branch constraint, which may collide
+ *   with the same change already emitted by `diffTables()` (for example on a
+ *   shape flip or a new constraint). We dedupe these keeping only the last
+ *   occurrence so the expansion's emission survives and the diffTables
+ *   duplicate is removed.
  * - If two dropped tables reference each other via FK, we insert dedicated
  *   `AlterTableDropConstraint` changes and teach the paired `DropTable`
  *   changes not to claim those FK stable IDs.
@@ -100,10 +176,15 @@ export function normalizePostDiffCycles({
   mainCatalog: Catalog;
   replacedTableIds?: ReadonlySet<string>;
 }): Change[] {
+  const dedupedChanges = dropReplacedTableDuplicateConstraintChanges(
+    changes,
+    replacedTableIds,
+  );
+
   const structurallyNormalizedChanges =
     replacedTableIds.size === 0
-      ? changes
-      : changes.filter(
+      ? dedupedChanges
+      : dedupedChanges.filter(
           (change) => !isSupersededByTableReplacement(change, replacedTableIds),
         );