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

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

@@ -556,11 +556,21 @@ export class AlterTableDropColumn extends AlterTableChange {
   public readonly table: Table;
   public readonly column: ColumnProps;
   public readonly scope = "object" as const;
-
-  constructor(props: { table: Table; column: ColumnProps }) {
+  // Drop the implicit `requires(table)` edge. Only set by the lazy
+  // cycle-breaker for the publication↔column case, where the table survives
+  // the migration and the edge is therefore artificial. See
+  // `sort/cycle-breakers.ts` for the full justification.
+  public readonly omitTableRequirement: boolean;
+
+  constructor(props: {
+    table: Table;
+    column: ColumnProps;
+    omitTableRequirement?: boolean;
+  }) {
     super();
     this.table = props.table;
     this.column = props.column;
+    this.omitTableRequirement = props.omitTableRequirement ?? false;
   }
 
   get drops() {
@@ -570,10 +580,12 @@ export class AlterTableDropColumn extends AlterTableChange {
   }
 
   get requires() {
-    return [
-      this.table.stableId,
-      stableId.column(this.table.schema, this.table.name, this.column.name),
-    ];
+    const colId = stableId.column(
+      this.table.schema,
+      this.table.name,
+      this.column.name,
+    );
+    return this.omitTableRequirement ? [colId] : [this.table.stableId, colId];
   }
 
   serialize(_options?: SerializeOptions): string {
@@ -592,12 +604,18 @@ export class AlterTableDropColumn extends AlterTableChange {
 export class AlterTableAlterColumnType extends AlterTableChange {
   public readonly table: Table;
   public readonly column: ColumnProps;
+  public readonly previousColumn?: ColumnProps;
   public readonly scope = "object" as const;
 
-  constructor(props: { table: Table; column: ColumnProps }) {
+  constructor(props: {
+    table: Table;
+    column: ColumnProps;
+    previousColumn?: ColumnProps;
+  }) {
     super();
     this.table = props.table;
     this.column = props.column;
+    this.previousColumn = props.previousColumn;
   }
 
   get requires() {
@@ -607,6 +625,14 @@ export class AlterTableAlterColumnType extends AlterTableChange {
   }
 
   serialize(_options?: SerializeOptions): string {
+    // previousColumn is optional so direct serializer tests/fixtures can keep
+    // emitting canonical ALTER TYPE SQL without forcing a USING expression.
+    // When provided, we can detect true type changes and add USING for casts
+    // PostgreSQL cannot perform automatically.
+    const hasTypeChangedWithPreviousDefinition =
+      this.previousColumn?.data_type_str !== undefined &&
+      this.previousColumn.data_type_str !== this.column.data_type_str;
+
     const parts: string[] = [
       "ALTER TABLE",
       `${this.table.schema}.${this.table.name}`,
@@ -618,6 +644,9 @@ export class AlterTableAlterColumnType extends AlterTableChange {
     if (this.column.collation) {
       parts.push("COLLATE", this.column.collation);
     }
+    if (hasTypeChangedWithPreviousDefinition) {
+      parts.push("USING", `${this.column.name}::${this.column.data_type_str}`);
+    }
     return parts.join(" ");
   }
 }

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

@@ -767,6 +767,9 @@ describe.concurrent("table.diff", () => {
     expect(
       typeChanges.some((c) => c instanceof AlterTableAlterColumnType),
     ).toBe(true);
+    expect(typeChanges.map((c) => c.serialize())).toContain(
+      "ALTER TABLE public.t2 ALTER COLUMN a TYPE text USING a::text",
+    );
 
     const defaultAdded = new Table({
       ...base,
@@ -817,6 +820,46 @@ describe.concurrent("table.diff", () => {
     expect(
       notNullDropped.some((c) => c instanceof AlterTableAlterColumnDropNotNull),
     ).toBe(true);
+
+    const withDefault = new Table({
+      ...base,
+      name: "t2",
+      columns: [
+        {
+          ...withCol.columns[0],
+          data_type: "text",
+          data_type_str: "text",
+          default: "'active'",
+        },
+      ],
+    });
+    const typeChangedWithDefault = new Table({
+      ...base,
+      name: "t2",
+      columns: [
+        {
+          ...withDefault.columns[0],
+          data_type: "USER-DEFINED",
+          data_type_str: "test_schema.status",
+          is_custom_type: true,
+          custom_type_type: "e",
+          custom_type_category: "E",
+          custom_type_schema: "test_schema",
+          custom_type_name: "status",
+          default: "'active'::test_schema.status",
+        },
+      ],
+    });
+    const typeChangesWithDefault = diffTables(
+      testContext,
+      { [withDefault.stableId]: withDefault },
+      { [typeChangedWithDefault.stableId]: typeChangedWithDefault },
+    );
+    expect(typeChangesWithDefault.map((c) => c.serialize())).toEqual([
+      "ALTER TABLE public.t2 ALTER COLUMN a DROP DEFAULT",
+      "ALTER TABLE public.t2 ALTER COLUMN a TYPE test_schema.status USING a::test_schema.status",
+      "ALTER TABLE public.t2 ALTER COLUMN a SET DEFAULT 'active'::test_schema.status",
+    ]);
   });
 
   test("identity transitions emit drop/add/set-generated changes", () => {

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

@@ -701,19 +701,39 @@ export function diffTables(
       const branchCol = branchCols.get(name);
       if (!branchCol) continue;
 
+      const columnTypeChanged =
+        mainCol.data_type_str !== branchCol.data_type_str;
+      const columnCollationChanged = mainCol.collation !== branchCol.collation;
+      const needsDefaultSafeFlow =
+        columnTypeChanged && mainCol.default !== null;
+
       // TYPE or COLLATION change
-      if (
-        mainCol.data_type_str !== branchCol.data_type_str ||
-        mainCol.collation !== branchCol.collation
-      ) {
+      if (columnTypeChanged || columnCollationChanged) {
         // Skip if parent has the same type/collation change
         if (!parentHasSameColumnPropertyChange(name, "type")) {
+          if (needsDefaultSafeFlow) {
+            changes.push(
+              new AlterTableAlterColumnDropDefault({
+                table: branchTable,
+                column: branchCol,
+              }),
+            );
+          }
           changes.push(
             new AlterTableAlterColumnType({
               table: branchTable,
               column: branchCol,
+              previousColumn: mainCol,
             }),
           );
+          if (needsDefaultSafeFlow && branchCol.default !== null) {
+            changes.push(
+              new AlterTableAlterColumnSetDefault({
+                table: branchTable,
+                column: branchCol,
+              }),
+            );
+          }
         }
       }
 
@@ -734,6 +754,10 @@ export function diffTables(
       if (mainCol.default !== branchCol.default) {
         // Skip if parent has the same default change
         if (!parentHasSameColumnPropertyChange(name, "default")) {
+          if (needsDefaultSafeFlow) {
+            // Defaults were already dropped/re-set in the type-change flow above.
+            continue;
+          }
           if (branchCol.default === null) {
             // Drop default value
             changes.push(

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

@@ -296,13 +296,16 @@ select
 
           'key_columns',
             case
-              when c.conkey is not null then (
-                select json_agg(quote_ident(att.attname) order by pk.ordinality)
-                from unnest(c.conkey) with ordinality as pk(attnum, ordinality)
-                join pg_attribute att
-                  on att.attrelid = c.conrelid
-                and att.attnum = pk.attnum
-                and att.attisdropped = false
+              when c.conkey is not null then coalesce(
+                (
+                  select json_agg(quote_ident(att.attname) order by pk.ordinality)
+                  from unnest(c.conkey) with ordinality as pk(attnum, ordinality)
+                  join pg_attribute att
+                    on att.attrelid = c.conrelid
+                  and att.attnum = pk.attnum
+                  and att.attisdropped = false
+                ),
+                '[]'::json
               )
               else '[]'::json
             end,

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

@@ -1,5 +1,4 @@
 import { describe, expect, test } from "bun:test";
-import { Catalog, createEmptyCatalog } from "./catalog.model.ts";
 import type { Change } from "./change.types.ts";
 import {
   AlterTableAddConstraint,
@@ -15,7 +14,6 @@ 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 = {
@@ -62,149 +60,7 @@ function integerColumn(name: string, position: number) {
 }
 
 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_temporal: 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_temporal: 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",
@@ -292,14 +148,9 @@ describe("normalizePostDiffCycles", () => {
       preExistingReplicaIdentity,
       preExistingGrant,
     ];
-    const mainCatalog = new Catalog({
-      ...baseline,
-      tables: { [mainChildren.stableId]: mainChildren },
-    });
 
     const normalized = normalizePostDiffCycles({
       changes,
-      mainCatalog,
       replacedTableIds: new Set([mainChildren.stableId]),
     });
 
@@ -322,7 +173,6 @@ describe("normalizePostDiffCycles", () => {
   });
 
   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",
@@ -423,14 +273,8 @@ describe("normalizePostDiffCycles", () => {
       expansionComment,
     ];
 
-    const mainCatalog = new Catalog({
-      ...baseline,
-      tables: { [branchChildren.stableId]: branchChildren },
-    });
-
     const normalized = normalizePostDiffCycles({
       changes,
-      mainCatalog,
       replacedTableIds: new Set([branchChildren.stableId]),
     });
 

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

@@ -1,4 +1,3 @@
-import type { Catalog } from "./catalog.model.ts";
 import type { Change } from "./change.types.ts";
 import {
   AlterTableAddConstraint,
@@ -7,7 +6,6 @@ import {
   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";
 
 function constraintStableId(
@@ -17,31 +15,6 @@ function constraintStableId(
   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>,
@@ -121,59 +94,35 @@ function dropReplacedTableDuplicateConstraintChanges(
   return mutated ? reversedKept.reverse() : changes;
 }
 
-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.
+ * 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:
  *
- * 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.
- * - 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.
+ * - 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.
+ * 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 dedupedChanges = dropReplacedTableDuplicateConstraintChanges(
@@ -181,137 +130,9 @@ export function normalizePostDiffCycles({
     replacedTableIds,
   );
 
-  const structurallyNormalizedChanges =
-    replacedTableIds.size === 0
-      ? dedupedChanges
-      : dedupedChanges.filter(
-          (change) => !isSupersededByTableReplacement(change, replacedTableIds),
-        );
+  if (replacedTableIds.size === 0) return dedupedChanges;
 
-  const dropTableChanges = structurallyNormalizedChanges.filter(
-    (change): change is DropTable => change instanceof DropTable,
+  return dedupedChanges.filter(
+    (change) => !isSupersededByTableReplacement(change, replacedTableIds),
   );
-
-  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;
 }