@supabase/pg-delta 1.0.0-alpha.13 → 1.0.0-alpha.15

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,

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

@@ -835,6 +835,61 @@ describe.concurrent("table.diff", () => {
     ).toBe(true);
   });
 
+  test("postgres 17+ recreates a column when switching from regular to generated", () => {
+    const pg17Context = {
+      ...testContext,
+      version: 170000,
+    };
+
+    const regularColumn = {
+      name: "confirmed_at",
+      position: 1,
+      data_type: "timestamp with time zone",
+      data_type_str: "timestamp with time zone",
+      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,
+    };
+
+    const generatedColumn = {
+      ...regularColumn,
+      is_generated: true,
+      default: "LEAST(email_confirmed_at, phone_confirmed_at)",
+    };
+
+    const mainTable = new Table({
+      ...base,
+      name: "auth_users_like",
+      columns: [regularColumn],
+    });
+    const branchTable = new Table({
+      ...base,
+      name: "auth_users_like",
+      columns: [generatedColumn],
+    });
+
+    const changes = diffTables(
+      pg17Context,
+      { [mainTable.stableId]: mainTable },
+      { [branchTable.stableId]: branchTable },
+    );
+
+    expect(changes.some((c) => c instanceof AlterTableDropColumn)).toBe(true);
+    expect(changes.some((c) => c instanceof AlterTableAddColumn)).toBe(true);
+    expect(
+      changes.some((c) => c instanceof AlterTableAlterColumnSetDefault),
+    ).toBe(false);
+  });
+
   test("created table with privileges emits grant changes", () => {
     const t = new Table({
       ...base,

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

@@ -745,10 +745,18 @@ export function diffTables(
             // Set new default value
             const isGeneratedColumn = branchCol.is_generated;
             const isPostgresLowerThan17 = ctx.version < 170000;
+            const generatedStatusChanged =
+              mainCol.is_generated !== branchCol.is_generated;
 
-            if (isGeneratedColumn && isPostgresLowerThan17) {
+            if (
+              isGeneratedColumn &&
+              (isPostgresLowerThan17 || generatedStatusChanged)
+            ) {
               // For generated columns in < PostgreSQL 17, we need to drop and recreate
-              // instead of using SET EXPRESSION AS for computed columns
+              // instead of using SET EXPRESSION AS for computed columns. We also
+              // need to recreate the column when switching between regular and
+              // generated states because SET EXPRESSION only applies to existing
+              // generated columns.
               // cf: https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=5d06e99a3
               // cf: https://www.postgresql.org/docs/release/17.0/
               // > Allow ALTER TABLE to change a column's generation expression

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

@@ -0,0 +1,317 @@
+import { describe, expect, test } from "bun:test";
+import { Catalog, createEmptyCatalog } from "./catalog.model.ts";
+import type { Change } from "./change.types.ts";
+import {
+  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 { stableId } from "./objects/utils.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("injects explicit FK drops for mutually dependent dropped tables", async () => {
+    const baseline = await createEmptyCatalog(170000, "postgres");
+    const tableA = new Table({
+      ...baseTableProps,
+      name: "a",
+      columns: [
+        { ...integerColumn("id", 1), not_null: true },
+        integerColumn("b_id", 2),
+      ],
+      constraints: [
+        {
+          name: "a_b_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: ["b_id"],
+          foreign_key_columns: ["id"],
+          foreign_key_table: "b",
+          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: "b",
+          on_update: "a",
+          on_delete: "a",
+          match_type: "s",
+          check_expression: null,
+          owner: "postgres",
+          definition: "FOREIGN KEY (b_id) REFERENCES public.b(id)",
+          comment: null,
+        },
+      ],
+    });
+    const tableB = new Table({
+      ...baseTableProps,
+      name: "b",
+      columns: [
+        { ...integerColumn("id", 1), not_null: true },
+        integerColumn("a_id", 2),
+      ],
+      constraints: [
+        {
+          name: "b_a_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: ["a_id"],
+          foreign_key_columns: ["id"],
+          foreign_key_table: "a",
+          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: "a",
+          on_update: "a",
+          on_delete: "a",
+          match_type: "s",
+          check_expression: null,
+          owner: "postgres",
+          definition: "FOREIGN KEY (a_id) REFERENCES public.a(id)",
+          comment: null,
+        },
+      ],
+    });
+    const mainCatalog = new Catalog({
+      ...baseline,
+      tables: {
+        [tableA.stableId]: tableA,
+        [tableB.stableId]: tableB,
+      },
+    });
+    const changes: Change[] = [
+      new DropTable({ table: tableA }),
+      new DropTable({ table: tableB }),
+    ];
+
+    const normalized = normalizePostDiffCycles({
+      changes,
+      mainCatalog,
+    });
+
+    const explicitConstraintDrops = normalized.filter(
+      (change) => change instanceof AlterTableDropConstraint,
+    );
+    expect(explicitConstraintDrops).toHaveLength(2);
+
+    const normalizedDropTableA = normalized.find(
+      (change) =>
+        change instanceof DropTable &&
+        change.table.stableId === tableA.stableId,
+    );
+    const normalizedDropTableB = normalized.find(
+      (change) =>
+        change instanceof DropTable &&
+        change.table.stableId === tableB.stableId,
+    );
+    if (!(normalizedDropTableA instanceof DropTable)) {
+      throw new Error("expected normalized DropTable(public.a)");
+    }
+    if (!(normalizedDropTableB instanceof DropTable)) {
+      throw new Error("expected normalized DropTable(public.b)");
+    }
+
+    expect(
+      normalizedDropTableA.externallyDroppedConstraints.has("a_b_fkey"),
+    ).toBe(true);
+    expect(
+      normalizedDropTableB.externallyDroppedConstraints.has("b_a_fkey"),
+    ).toBe(true);
+    expect(
+      normalizedDropTableA.requires.includes(
+        stableId.constraint("public", "a", "a_b_fkey"),
+      ),
+    ).toBe(false);
+    expect(
+      normalizedDropTableB.requires.includes(
+        stableId.constraint("public", "b", "b_a_fkey"),
+      ),
+    ).toBe(false);
+  });
+
+  test("prunes same-table drop-column and drop-constraint ALTERs for replaced tables only", async () => {
+    const baseline = await createEmptyCatalog(170000, "postgres");
+    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_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 mainCatalog = new Catalog({
+      ...baseline,
+      tables: { [mainChildren.stableId]: mainChildren },
+    });
+
+    const normalized = normalizePostDiffCycles({
+      changes,
+      mainCatalog,
+      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);
+  });
+});

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

@@ -0,0 +1,236 @@
+import type { Catalog } from "./catalog.model.ts";
+import type { Change } from "./change.types.ts";
+import {
+  AlterTableDropColumn,
+  AlterTableDropConstraint,
+} from "./objects/table/changes/table.alter.ts";
+import { DropTable } from "./objects/table/changes/table.drop.ts";
+import { stableId } from "./objects/utils.ts";
+
+function constraintStableId(
+  table: { schema: string; name: string },
+  constraintName: string,
+) {
+  return stableId.constraint(table.schema, table.name, constraintName);
+}
+
+/**
+ * Yield FK constraints on `table` whose referenced table is also dropped in the
+ * final plan. Self-references are left alone because the sort phase already
+ * handles the resulting self-loop correctly.
+ */
+function* iterCrossDropFkConstraints(
+  table: Catalog["tables"][string],
+  droppedSet: ReadonlySet<string>,
+) {
+  for (const constraint of table.constraints) {
+    if (constraint.constraint_type !== "f") continue;
+    if (constraint.is_partition_clone) continue;
+    if (!constraint.foreign_key_schema || !constraint.foreign_key_table) {
+      continue;
+    }
+    const referencedId = stableId.table(
+      constraint.foreign_key_schema,
+      constraint.foreign_key_table,
+    );
+    if (referencedId === table.stableId) continue;
+    if (!droppedSet.has(referencedId)) continue;
+    yield { constraint, referencedId };
+  }
+}
+
+function isSupersededByTableReplacement(
+  change: Change,
+  replacedTableIds: ReadonlySet<string>,
+): boolean {
+  if (
+    !(change instanceof AlterTableDropColumn) &&
+    !(change instanceof AlterTableDropConstraint)
+  ) {
+    return false;
+  }
+  return replacedTableIds.has(change.table.stableId);
+}
+
+function collectExplicitConstraintDropIds(changes: Change[]) {
+  const explicitConstraintDropIds = new Set<string>();
+
+  for (const change of changes) {
+    if (!(change instanceof AlterTableDropConstraint)) continue;
+    explicitConstraintDropIds.add(
+      constraintStableId(change.table, change.constraint.name),
+    );
+  }
+
+  return explicitConstraintDropIds;
+}
+
+function hasSameEntries(
+  left: ReadonlySet<string>,
+  right: ReadonlySet<string>,
+): boolean {
+  if (left.size !== right.size) return false;
+  for (const value of left) {
+    if (!right.has(value)) return false;
+  }
+  return true;
+}
+
+/**
+ * Normalize change-list cycles that only become apparent after all object
+ * diffs have been collected.
+ *
+ * This pass intentionally handles whole-plan interactions only:
+ * - 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.
+ * - 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.
+ *
+ * Object-local PostgreSQL semantics (for example owned-sequence cascades) stay
+ * in the corresponding `diff*` function instead of this pass.
+ */
+export function normalizePostDiffCycles({
+  changes,
+  mainCatalog,
+  replacedTableIds = new Set<string>(),
+}: {
+  changes: Change[];
+  mainCatalog: Catalog;
+  replacedTableIds?: ReadonlySet<string>;
+}): Change[] {
+  const structurallyNormalizedChanges =
+    replacedTableIds.size === 0
+      ? changes
+      : changes.filter(
+          (change) => !isSupersededByTableReplacement(change, replacedTableIds),
+        );
+
+  const dropTableChanges = structurallyNormalizedChanges.filter(
+    (change): change is DropTable => change instanceof DropTable,
+  );
+
+  if (dropTableChanges.length < 2) {
+    return structurallyNormalizedChanges;
+  }
+
+  const droppedSet = new Set(
+    dropTableChanges.map((change) => change.table.stableId),
+  );
+  const droppedFkTargets = new Map<string, Set<string>>();
+
+  for (const dropTableChange of dropTableChanges) {
+    const mainTable =
+      mainCatalog.tables[dropTableChange.table.stableId] ??
+      dropTableChange.table;
+    const targets = new Set<string>();
+
+    for (const { referencedId } of iterCrossDropFkConstraints(
+      mainTable,
+      droppedSet,
+    )) {
+      targets.add(referencedId);
+    }
+
+    droppedFkTargets.set(mainTable.stableId, targets);
+  }
+
+  const explicitConstraintDropIds = collectExplicitConstraintDropIds(
+    structurallyNormalizedChanges,
+  );
+  const injectedConstraintDropsByTableId = new Map<
+    string,
+    AlterTableDropConstraint[]
+  >();
+  const externallyDroppedConstraintsByTableId = new Map<
+    string,
+    ReadonlySet<string>
+  >();
+  let didMutate = structurallyNormalizedChanges !== changes;
+
+  for (const dropTableChange of dropTableChanges) {
+    const mainTable =
+      mainCatalog.tables[dropTableChange.table.stableId] ??
+      dropTableChange.table;
+    const externallyDroppedConstraints = new Set(
+      dropTableChange.externallyDroppedConstraints,
+    );
+
+    for (const { constraint, referencedId } of iterCrossDropFkConstraints(
+      mainTable,
+      droppedSet,
+    )) {
+      const isMutual =
+        droppedFkTargets.get(referencedId)?.has(mainTable.stableId) === true;
+      if (!isMutual) continue;
+
+      const droppedConstraintStableId = constraintStableId(
+        mainTable,
+        constraint.name,
+      );
+      externallyDroppedConstraints.add(constraint.name);
+
+      if (!explicitConstraintDropIds.has(droppedConstraintStableId)) {
+        const injectedDrop = new AlterTableDropConstraint({
+          table: mainTable,
+          constraint,
+        });
+        const existingDrops =
+          injectedConstraintDropsByTableId.get(mainTable.stableId) ?? [];
+        existingDrops.push(injectedDrop);
+        injectedConstraintDropsByTableId.set(mainTable.stableId, existingDrops);
+        explicitConstraintDropIds.add(droppedConstraintStableId);
+        didMutate = true;
+      }
+    }
+
+    if (
+      !hasSameEntries(
+        dropTableChange.externallyDroppedConstraints,
+        externallyDroppedConstraints,
+      )
+    ) {
+      externallyDroppedConstraintsByTableId.set(
+        mainTable.stableId,
+        externallyDroppedConstraints,
+      );
+      didMutate = true;
+    }
+  }
+
+  if (!didMutate) {
+    return changes;
+  }
+
+  const normalizedChanges: Change[] = [];
+
+  for (const change of structurallyNormalizedChanges) {
+    if (!(change instanceof DropTable)) {
+      normalizedChanges.push(change);
+      continue;
+    }
+
+    const injectedConstraintDrops =
+      injectedConstraintDropsByTableId.get(change.table.stableId) ?? [];
+    if (injectedConstraintDrops.length > 0) {
+      normalizedChanges.push(...injectedConstraintDrops);
+    }
+
+    const externallyDroppedConstraints =
+      externallyDroppedConstraintsByTableId.get(change.table.stableId);
+    if (!externallyDroppedConstraints) {
+      normalizedChanges.push(change);
+      continue;
+    }
+
+    normalizedChanges.push(
+      new DropTable({
+        table: change.table,
+        externallyDroppedConstraints,
+      }),
+    );
+  }
+
+  return normalizedChanges;
+}