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

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

@@ -7,10 +7,21 @@ import { CreateSequence } from "./objects/sequence/changes/sequence.create.ts";
 import { DropSequence } from "./objects/sequence/changes/sequence.drop.ts";
 import { diffSequences } from "./objects/sequence/sequence.diff.ts";
 import { Sequence } from "./objects/sequence/sequence.model.ts";
-import { AlterTableAlterColumnSetDefault } from "./objects/table/changes/table.alter.ts";
+import {
+  AlterTableAlterColumnSetDefault,
+  AlterTableChangeOwner,
+  AlterTableDropColumn,
+  AlterTableDropConstraint,
+  AlterTableEnableRowLevelSecurity,
+  AlterTableSetReplicaIdentity,
+} from "./objects/table/changes/table.alter.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 { CreateEnum } from "./objects/type/enum/changes/enum.create.ts";
+import { DropEnum } from "./objects/type/enum/changes/enum.drop.ts";
+import { Enum } from "./objects/type/enum/enum.model.ts";
 
 function mockChange(overrides: {
   creates?: string[];
@@ -43,8 +54,9 @@ describe("expandReplaceDependencies", () => {
       mainCatalog: catalog,
       branchCatalog: catalog,
     });
-    expect(result).toHaveLength(1);
-    expect(result).toBe(changes);
+    expect(result.changes).toHaveLength(1);
+    expect(result.changes).toBe(changes);
+    expect(result.replacedTableIds.size).toBe(0);
   });
 
   test("returns changes unchanged when replace roots have no dependents in catalog", async () => {
@@ -60,8 +72,9 @@ describe("expandReplaceDependencies", () => {
       mainCatalog: catalog,
       branchCatalog: catalog,
     });
-    expect(result).toHaveLength(1);
-    expect(result[0]).toBe(changes[0]);
+    expect(result.changes).toHaveLength(1);
+    expect(result.changes[0]).toBe(changes[0]);
+    expect(result.replacedTableIds.size).toBe(0);
   });
 
   test("returns same array reference when replaceRoots.size is 0", async () => {
@@ -74,7 +87,8 @@ describe("expandReplaceDependencies", () => {
       mainCatalog: catalog,
       branchCatalog: catalog,
     });
-    expect(result).toBe(changes);
+    expect(result.changes).toBe(changes);
+    expect(result.replacedTableIds.size).toBe(0);
   });
 
   test("does not replace the owning table for an owned sequence recreation", async () => {
@@ -187,9 +201,234 @@ describe("expandReplaceDependencies", () => {
     expect(changes[0]).toBeInstanceOf(DropSequence);
     expect(changes[1]).toBeInstanceOf(CreateSequence);
     expect(changes[3]).toBeInstanceOf(AlterTableAlterColumnSetDefault);
-    expect(expanded.some((change) => change instanceof DropTable)).toBe(false);
-    expect(expanded.some((change) => change instanceof CreateTable)).toBe(
+    expect(expanded.changes.some((change) => change instanceof DropTable)).toBe(
       false,
     );
+    expect(
+      expanded.changes.some((change) => change instanceof CreateTable),
+    ).toBe(false);
+    expect(expanded.replacedTableIds.size).toBe(0);
+  });
+
+  test("reports replaced tables for downstream post-diff normalization", async () => {
+    // Reproduction guard for the enum-replacement expansion case: the expander
+    // must report which dependent tables it promoted to DropTable+CreateTable,
+    // but the pruning of same-table AlterTableDropColumn/DropConstraint belongs
+    // to the later post-diff normalization pass, not this expansion step.
+    const baseline = await createEmptyCatalog(170000, "postgres");
+    const mainEnum = new Enum({
+      schema: "public",
+      name: "item_status",
+      owner: "postgres",
+      labels: [
+        { sort_order: 1, label: "draft" },
+        { sort_order: 2, label: "published" },
+        { sort_order: 3, label: "archived" },
+      ],
+      comment: null,
+      privileges: [],
+    });
+    const branchEnum = new Enum({
+      ...mainEnum,
+      labels: [
+        { sort_order: 1, label: "draft" },
+        { sort_order: 2, label: "published" },
+      ],
+    });
+    const columnTemplate = {
+      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,
+    };
+    const mainChildren = new Table({
+      schema: "public",
+      name: "children",
+      persistence: "p",
+      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",
+      is_partition: false,
+      options: null,
+      partition_bound: null,
+      partition_by: null,
+      owner: "postgres",
+      comment: null,
+      parent_schema: null,
+      parent_name: null,
+      columns: [
+        { ...columnTemplate, name: "id", position: 1, not_null: true },
+        { ...columnTemplate, name: "parent_ref", position: 2 },
+        {
+          ...columnTemplate,
+          name: "status",
+          position: 3,
+          data_type: "item_status",
+          data_type_str: "public.item_status",
+          is_custom_type: true,
+          custom_type_type: "e",
+          custom_type_category: "E",
+          custom_type_schema: "public",
+          custom_type_name: "item_status",
+        },
+      ],
+      privileges: [],
+    });
+    const branchChildren = new Table({
+      ...mainChildren,
+      columns: [
+        { ...columnTemplate, name: "id", position: 1, not_null: true },
+        {
+          ...columnTemplate,
+          name: "status",
+          position: 2,
+          data_type: "item_status",
+          data_type_str: "public.item_status",
+          is_custom_type: true,
+          custom_type_type: "e",
+          custom_type_category: "E",
+          custom_type_schema: "public",
+          custom_type_name: "item_status",
+        },
+      ],
+    });
+
+    // Pre-existing planner output: the enum replacement from diffEnums plus
+    // targeted ALTER TABLE statements from diffTables. The two cycle-forming
+    // ALTERs (drop-column, drop-constraint) must be elided. The privilege
+    // ALTER and the owner / RLS / replica-identity ALTERs must all survive.
+    const droppedColumn = mainChildren.columns.find(
+      (c) => c.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_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 DropEnum({ enum: mainEnum }),
+      new CreateEnum({ enum: branchEnum }),
+      preExistingDropColumn,
+      preExistingDropConstraint,
+      preExistingChangeOwner,
+      preExistingEnableRls,
+      preExistingReplicaIdentity,
+      preExistingGrant,
+    ];
+
+    const mainCatalog = new Catalog({
+      ...baseline,
+      enums: { [mainEnum.stableId]: mainEnum },
+      tables: { [mainChildren.stableId]: mainChildren },
+      // pg_depend: column children.status depends on type item_status.
+      depends: [
+        {
+          dependent_stable_id: "column:public.children.status",
+          referenced_stable_id: mainEnum.stableId,
+          deptype: "n",
+        },
+      ],
+    });
+    const branchCatalog = new Catalog({
+      ...baseline,
+      enums: { [branchEnum.stableId]: branchEnum },
+      tables: { [branchChildren.stableId]: branchChildren },
+      depends: [],
+    });
+
+    const expanded = expandReplaceDependencies({
+      changes,
+      mainCatalog,
+      branchCatalog,
+    });
+
+    // The replace-table pair was added.
+    expect(expanded.changes.some((c) => c instanceof DropTable)).toBe(true);
+    expect(expanded.changes.some((c) => c instanceof CreateTable)).toBe(true);
+    expect(expanded.replacedTableIds.has(mainChildren.stableId)).toBe(true);
+    // Expansion itself keeps the pre-existing ALTERs; the post-diff cycle pass
+    // decides which of them are superseded by the replacement.
+    expect(expanded.changes).toContain(preExistingDropColumn);
+    expect(expanded.changes).toContain(preExistingDropConstraint);
+    expect(
+      expanded.changes.some((c) => c instanceof AlterTableDropColumn),
+    ).toBe(true);
+    expect(
+      expanded.changes.some((c) => c instanceof AlterTableDropConstraint),
+    ).toBe(true);
+    // The enum replace roots are still present.
+    expect(expanded.changes.some((c) => c instanceof DropEnum)).toBe(true);
+    expect(expanded.changes.some((c) => c instanceof CreateEnum)).toBe(true);
+    // Non-cycle object-scope ALTERs are carried through untouched.
+    expect(expanded.changes).toContain(preExistingChangeOwner);
+    expect(expanded.changes).toContain(preExistingEnableRls);
+    expect(expanded.changes).toContain(preExistingReplicaIdentity);
+    // Privilege-scope ALTER on the recreated table survives.
+    expect(expanded.changes).toContain(preExistingGrant);
+    expect(expanded.replacedTableIds.has("table:public.parents")).toBe(false);
   });
 });

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

@@ -70,8 +70,14 @@ type ResolvedObject =
  * replaced so that destructive drops succeed. Uses dependency edges from pg_depend
  * (already captured in Catalog.depends) plus change metadata (creates/drops/requires).
  *
- * New changes are appended; ordering is handled later by the sorter.
+ * New changes are appended; ordering and any multi-statement cycle normalization
+ * are handled later by post-diff helpers and the sorter.
  */
+interface ExpandReplaceDependenciesResult {
+  changes: Change[];
+  replacedTableIds: ReadonlySet<string>;
+}
+
 export function expandReplaceDependencies({
   changes,
   mainCatalog,
@@ -80,7 +86,7 @@ export function expandReplaceDependencies({
   changes: Change[];
   mainCatalog: Catalog;
   branchCatalog: Catalog;
-}): Change[] {
+}): ExpandReplaceDependenciesResult {
   const createdIds = new Set<string>();
   const droppedIds = new Set<string>();
 
@@ -97,7 +103,10 @@ export function expandReplaceDependencies({
   }
 
   if (replaceRoots.size === 0) {
-    return changes;
+    return {
+      changes,
+      replacedTableIds: new Set<string>(),
+    };
   }
 
   // Build referenced -> dependents adjacency from main catalog dependencies.
@@ -115,6 +124,12 @@ export function expandReplaceDependencies({
   const visitedTargets = new Set<string>();
   const visitedRefs = new Set<string>(replaceRoots);
   const queue: string[] = [...replaceRoots];
+  // Tables being replaced by an expansion-added DropTable+CreateTable pair.
+  // Any pre-existing targeted AlterTable*(T) object-scope change is superseded
+  // by the replacement and must be removed to avoid contradictions (e.g. an
+  // AlterTableDropColumn on a table that is about to be dropped) and the
+  // associated drop-phase cycle with the catalog constraint→column edge.
+  const tablesReplacedByExpansion = new Set<string>();
 
   while (queue.length > 0) {
     const refId = queue.shift() as string;
@@ -178,6 +193,13 @@ export function expandReplaceDependencies({
 
       additions.push(...replacementChanges);
 
+      // If we added a DropTable(T) for an existing table, mark T so any
+      // pre-existing object-scope AlterTable*(T) changes get dropped below —
+      // the DropTable+CreateTable pair supersedes all structural alterations.
+      if (resolved.kind === "table" && addDrop) {
+        tablesReplacedByExpansion.add(targetId);
+      }
+
       // Track new creates/drops so we don't duplicate work for downstream dependents.
       for (const change of replacementChanges) {
         for (const id of change.creates ?? []) createdIds.add(id);
@@ -187,10 +209,16 @@ export function expandReplaceDependencies({
   }
 
   if (additions.length === 0) {
-    return changes;
+    return {
+      changes,
+      replacedTableIds: tablesReplacedByExpansion,
+    };
   }
 
-  return [...changes, ...additions];
+  return {
+    changes: [...changes, ...additions],
+    replacedTableIds: tablesReplacedByExpansion,
+  };
 }
 
 function isOwnedSequenceColumnDependency(

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

@@ -198,28 +198,130 @@ describe.concurrent("sequence.diff", () => {
     expect(changes).toHaveLength(0);
   });
 
-  test("generate DROP SEQUENCE when owned by table that still exists", () => {
+  test("generate DROP SEQUENCE when owned by table/column that still exists", () => {
     const ownedSequence = new Sequence({
       ...base,
       owned_by_schema: "public",
       owned_by_table: "users",
       owned_by_column: "id",
     });
-    // When the owning table still exists in branch catalog,
-    // DROP SEQUENCE should be generated
+    const branchTable = new Table({
+      schema: "public",
+      name: "users",
+      persistence: "p",
+      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",
+      is_partition: false,
+      options: null,
+      partition_bound: null,
+      partition_by: null,
+      owner: "test",
+      comment: null,
+      parent_schema: null,
+      parent_name: null,
+      columns: [
+        {
+          name: "id",
+          position: 1,
+          data_type: "bigint",
+          data_type_str: "bigint",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: true,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: null,
+          comment: null,
+        },
+      ],
+      privileges: [],
+    });
+    // When the owning table AND the owning column still exist in branch catalog,
+    // DROP SEQUENCE should be generated (sequence is orphaned and needs explicit drop).
     const changes = diffSequences(
       testContext,
       { [ownedSequence.stableId]: ownedSequence },
-      {}, // branch has no sequences
-      {
-        "table:public.users": {} as Table, // table still exists
-      },
+      {},
+      { [branchTable.stableId]: branchTable },
     );
-    // Should generate DROP SEQUENCE since table still exists
     expect(changes).toHaveLength(1);
     expect(changes[0]).toBeInstanceOf(DropSequence);
   });
 
+  test("skip DROP SEQUENCE when owning column is dropped but table survives", () => {
+    // Reproduction guard for the DropSequence ↔ AlterTableDropColumn cycle:
+    // dropping a SERIAL column on a surviving table leaves PG to cascade-drop
+    // the owned sequence. Emitting DROP SEQUENCE here would both fail at apply
+    // time AND form an unbreakable drop-phase cycle with AlterTableDropColumn.
+    const ownedSequence = new Sequence({
+      ...base,
+      owned_by_schema: "public",
+      owned_by_table: "widgets",
+      owned_by_column: "id",
+    });
+    const branchTable = new Table({
+      schema: "public",
+      name: "widgets",
+      persistence: "p",
+      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",
+      is_partition: false,
+      options: null,
+      partition_bound: null,
+      partition_by: null,
+      owner: "test",
+      comment: null,
+      parent_schema: null,
+      parent_name: null,
+      // `id` column has been dropped in branch; only `label` remains.
+      columns: [
+        {
+          name: "label",
+          position: 1,
+          data_type: "text",
+          data_type_str: "text",
+          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,
+        },
+      ],
+      privileges: [],
+    });
+    const changes = diffSequences(
+      testContext,
+      { [ownedSequence.stableId]: ownedSequence },
+      {},
+      { [branchTable.stableId]: branchTable },
+    );
+    expect(changes).toHaveLength(0);
+  });
+
   test("create with comment emits CreateCommentOnSequence", () => {
     const s = new Sequence({ ...base, comment: "my seq" });
     const changes = diffSequences(testContext, {}, { [s.stableId]: s });

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

@@ -116,18 +116,28 @@ export function diffSequences(
 
   for (const sequenceId of dropped) {
     const sequence = main[sequenceId];
-    // Skip generating DROP SEQUENCE if the sequence is owned by a table that's being dropped.
-    // PostgreSQL automatically drops sequences owned by tables when the table is dropped,
-    // so generating DROP SEQUENCE would cause an error (sequence doesn't exist).
+    // Skip generating DROP SEQUENCE if the sequence is owned by a table/column that's being dropped.
+    // PostgreSQL automatically cascades owned sequences when the owning table OR the owning
+    // column is dropped (via OWNED BY). Emitting DROP SEQUENCE in those cases would either
+    // fail at apply time (sequence already gone) or — in the column-drop case — create an
+    // unbreakable DropSequence ↔ AlterTableDropColumn cycle in the drop-phase sort graph.
     if (
       sequence.owned_by_schema &&
       sequence.owned_by_table &&
       sequence.owned_by_column
     ) {
       const ownedByTableId = `table:${sequence.owned_by_schema}.${sequence.owned_by_table}`;
-      // If the owning table doesn't exist in branch catalog, it's being dropped
-      // and will auto-drop this sequence, so skip generating DROP SEQUENCE
-      if (!(ownedByTableId in branchTables)) {
+      const ownedByTable = branchTables[ownedByTableId];
+      // Owning table is dropped → PG auto-drops the owned sequence.
+      if (!ownedByTable) {
+        continue;
+      }
+      // Owning column is dropped (table survives) → PG still auto-drops the owned
+      // sequence as part of the column drop, so we must not emit DROP SEQUENCE.
+      const ownedByColumnExists = ownedByTable.columns?.some(
+        (col) => col.name === sequence.owned_by_column,
+      );
+      if (!ownedByColumnExists) {
         continue;
       }
     }

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

@@ -16,10 +16,31 @@ import { DropTableChange } from "./table.base.ts";
 export class DropTable extends DropTableChange {
   public readonly table: Table;
   public readonly scope = "object" as const;
+  /**
+   * Names of constraints on this table that are dropped explicitly by a
+   * separate `AlterTableDropConstraint` change. Those constraints must not be
+   * claimed by `DropTable.drops` / `.requires`, otherwise catalog edges tied
+   * to the constraint stableId will attach to this DropTable node instead of
+   * the dedicated AlterTableDropConstraint node. When two tables with mutual
+   * FK references are dropped in the same phase, that misattribution
+   * produces an unbreakable cycle between the two DropTable changes.
+   */
+  public readonly externallyDroppedConstraints: ReadonlySet<string>;
 
-  constructor(props: { table: Table }) {
+  constructor(props: {
+    table: Table;
+    externallyDroppedConstraints?: ReadonlySet<string>;
+  }) {
     super();
     this.table = props.table;
+    this.externallyDroppedConstraints =
+      props.externallyDroppedConstraints ?? new Set();
+  }
+
+  private get claimedConstraints() {
+    return this.table.constraints.filter(
+      (constraint) => !this.externallyDroppedConstraints.has(constraint.name),
+    );
   }
 
   get drops() {
@@ -29,8 +50,10 @@ export class DropTable extends DropTableChange {
         stableId.column(this.table.schema, this.table.name, column.name),
       ),
       // Include constraint stableIds so FK relationships that only exist at the
-      // constraint level still affect whole-table drop ordering.
-      ...this.table.constraints.map((constraint) =>
+      // constraint level still affect whole-table drop ordering. Skip any
+      // constraint that the diff layer is dropping via a dedicated
+      // AlterTableDropConstraint change — that node owns the stableId.
+      ...this.claimedConstraints.map((constraint) =>
         stableId.constraint(
           this.table.schema,
           this.table.name,
@@ -48,7 +71,7 @@ export class DropTable extends DropTableChange {
       ),
       // Mirror the dropped constraint ids in requires so drop-phase graph
       // consumers can connect catalog FK edges back to this table drop.
-      ...this.table.constraints.map((constraint) =>
+      ...this.claimedConstraints.map((constraint) =>
         stableId.constraint(
           this.table.schema,
           this.table.name,