@supabase/pg-delta 1.0.0-alpha.2 → 1.0.0-alpha.21

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

@@ -0,0 +1,303 @@
+import { describe, expect, test } from "bun:test";
+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";
+import { Table } from "./objects/table/table.model.ts";
+import { normalizePostDiffCycles } from "./post-diff-cycle-breaking.ts";
+
+const baseTableProps = {
+  schema: "public",
+  persistence: "p" as const,
+  row_security: false,
+  force_row_security: false,
+  has_indexes: false,
+  has_rules: false,
+  has_triggers: false,
+  has_subclasses: false,
+  is_populated: true,
+  replica_identity: "d" as const,
+  is_partition: false,
+  options: null,
+  partition_bound: null,
+  partition_by: null,
+  owner: "postgres",
+  comment: null,
+  parent_schema: null,
+  parent_name: null,
+  privileges: [],
+};
+
+function integerColumn(name: string, position: number) {
+  return {
+    name,
+    position,
+    data_type: "integer" as const,
+    data_type_str: "integer",
+    is_custom_type: false as const,
+    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,
+  };
+}
+
+describe("normalizePostDiffCycles", () => {
+  test("prunes same-table drop-column and drop-constraint ALTERs for replaced tables only", async () => {
+    const mainChildren = new Table({
+      ...baseTableProps,
+      name: "children",
+      columns: [
+        { ...integerColumn("id", 1), not_null: true },
+        integerColumn("parent_ref", 2),
+        integerColumn("status", 3),
+      ],
+    });
+    const branchChildren = new Table({
+      ...baseTableProps,
+      name: "children",
+      columns: [
+        { ...integerColumn("id", 1), not_null: true },
+        integerColumn("status", 2),
+      ],
+    });
+
+    const droppedColumn = mainChildren.columns.find(
+      (column) => column.name === "parent_ref",
+    );
+    if (!droppedColumn) throw new Error("test setup: parent_ref missing");
+
+    const preExistingDropColumn = new AlterTableDropColumn({
+      table: mainChildren,
+      column: droppedColumn,
+    });
+    const preExistingDropConstraint = new AlterTableDropConstraint({
+      table: mainChildren,
+      constraint: {
+        name: "children_parent_ref_fkey",
+        constraint_type: "f",
+        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: ["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",
+        on_delete: "a",
+        match_type: "s",
+        check_expression: null,
+        owner: "postgres",
+        definition: "FOREIGN KEY (parent_ref) REFERENCES public.parents(id)",
+        comment: null,
+      },
+    });
+    const preExistingChangeOwner = new AlterTableChangeOwner({
+      table: branchChildren,
+      owner: "new_owner",
+    });
+    const preExistingEnableRls = new AlterTableEnableRowLevelSecurity({
+      table: branchChildren,
+    });
+    const preExistingReplicaIdentity = new AlterTableSetReplicaIdentity({
+      table: branchChildren,
+      mode: "f",
+    });
+    const preExistingGrant = new GrantTablePrivileges({
+      table: branchChildren,
+      grantee: "reader",
+      privileges: [{ privilege: "SELECT", grantable: false }],
+    });
+    const changes: Change[] = [
+      new DropTable({ table: mainChildren }),
+      new CreateTable({ table: branchChildren }),
+      preExistingDropColumn,
+      preExistingDropConstraint,
+      preExistingChangeOwner,
+      preExistingEnableRls,
+      preExistingReplicaIdentity,
+      preExistingGrant,
+    ];
+
+    const normalized = normalizePostDiffCycles({
+      changes,
+      replacedTableIds: new Set([mainChildren.stableId]),
+    });
+
+    expect(normalized.some((change) => change instanceof DropTable)).toBe(true);
+    expect(normalized.some((change) => change instanceof CreateTable)).toBe(
+      true,
+    );
+    expect(normalized).not.toContain(preExistingDropColumn);
+    expect(normalized).not.toContain(preExistingDropConstraint);
+    expect(
+      normalized.some((change) => change instanceof AlterTableDropColumn),
+    ).toBe(false);
+    expect(
+      normalized.some((change) => change instanceof AlterTableDropConstraint),
+    ).toBe(false);
+    expect(normalized).toContain(preExistingChangeOwner);
+    expect(normalized).toContain(preExistingEnableRls);
+    expect(normalized).toContain(preExistingReplicaIdentity);
+    expect(normalized).toContain(preExistingGrant);
+  });
+
+  test("dedupes duplicate constraint Add/Validate/Comment on replaced tables keeping last occurrence", async () => {
+    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 normalized = normalizePostDiffCycles({
+      changes,
+      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

@@ -0,0 +1,138 @@
+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 { stableId } from "./objects/utils.ts";
+
+function constraintStableId(
+  table: { schema: string; name: string },
+  constraintName: string,
+) {
+  return stableId.constraint(table.schema, table.name, constraintName);
+}
+
+function isSupersededByTableReplacement(
+  change: Change,
+  replacedTableIds: ReadonlySet<string>,
+): boolean {
+  if (
+    !(change instanceof AlterTableDropColumn) &&
+    !(change instanceof AlterTableDropConstraint)
+  ) {
+    return false;
+  }
+  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;
+}
+
+/**
+ * Apply structural rewrites to the change list that are only obvious once
+ * every object diff has been collected. This pass does NOT prevent dependency
+ * cycles — that responsibility now lives in the sort phase, where
+ * `sortPhaseChanges` invokes `tryBreakCycleByChangeInjection` lazily on cycles
+ * that edge filtering can't break (FK SCC of dropped tables,
+ * AlterPublicationDropTables ↔ AlterTableDropColumn, …).
+ *
+ * Concretely, this pass:
+ *
+ * - Prunes `AlterTableDropColumn(T.*)` / `AlterTableDropConstraint(T.*)`
+ *   changes that are made redundant by an expansion-emitted
+ *   `DropTable(T) + CreateTable(T)` pair. Without this, the apply phase
+ *   would try to drop a column that no longer exists in the freshly
+ *   recreated table.
+ * - Dedupes duplicate `AlterTableAddConstraint` /
+ *   `AlterTableValidateConstraint` / `CreateCommentOnConstraint` changes
+ *   produced when `diffTables()` and `expandReplaceDependencies()` both
+ *   emit the same constraint operation for a replaced table. Last write
+ *   wins so the expansion's emission survives.
+ *
+ * Object-local PostgreSQL semantics (for example owned-sequence cascades)
+ * stay in the corresponding `diff*` function instead of this pass.
+ */
+export function normalizePostDiffCycles({
+  changes,
+  replacedTableIds = new Set<string>(),
+}: {
+  changes: Change[];
+  replacedTableIds?: ReadonlySet<string>;
+}): Change[] {
+  const dedupedChanges = dropReplacedTableDuplicateConstraintChanges(
+    changes,
+    replacedTableIds,
+  );
+
+  if (replacedTableIds.size === 0) return dedupedChanges;
+
+  return dedupedChanges.filter(
+    (change) => !isSupersededByTableReplacement(change, replacedTableIds),
+  );
+}