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

package/dist/core/catalog.diff.js

@@ -161,7 +161,6 @@ export function diffCatalogs(main, branch, options) {
     });
     filteredChanges = normalizePostDiffCycles({
         changes: expandedDependencies.changes,
-        mainCatalog: main,
         replacedTableIds: expandedDependencies.replacedTableIds,
     });
     debugCatalog("changes catalog diff: %O", stringifyWithBigInt(filteredChanges, 2));

package/dist/core/objects/publication/changes/publication.alter.d.ts

@@ -37,7 +37,7 @@ export declare class AlterPublicationAddTables extends AlterPublicationChange {
 export declare class AlterPublicationDropTables extends AlterPublicationChange {
     readonly publication: Publication;
     readonly scope: "object";
-    private readonly tables;
+    readonly tables: PublicationTableProps[];
     constructor(props: {
         publication: Publication;
         tables: PublicationTableProps[];

package/dist/core/objects/sequence/sequence.diff.js

@@ -87,10 +87,7 @@ export function diffSequences(ctx, main, branch, branchTables = {}) {
         const branchSequence = branch[sequenceId];
         // Check if non-alterable properties have changed
         // These require dropping and recreating the sequence
-        const NON_ALTERABLE_FIELDS = [
-            "data_type",
-            "persistence",
-        ];
+        const NON_ALTERABLE_FIELDS = ["persistence"];
         const nonAlterablePropsChanged = hasNonAlterableChanges(mainSequence, branchSequence, NON_ALTERABLE_FIELDS);
         if (nonAlterablePropsChanged) {
             // Replace the entire sequence (drop + create)
@@ -131,7 +128,8 @@ export function diffSequences(ctx, main, branch, branchTables = {}) {
         }
         else {
             // Only alterable properties changed - emit ALTER for options/owner
-            const optionsChanged = mainSequence.increment !== branchSequence.increment ||
+            const optionsChanged = mainSequence.data_type !== branchSequence.data_type ||
+                mainSequence.increment !== branchSequence.increment ||
                 mainSequence.minimum_value !== branchSequence.minimum_value ||
                 mainSequence.maximum_value !== branchSequence.maximum_value ||
                 mainSequence.start_value !== branchSequence.start_value ||
@@ -139,6 +137,16 @@ export function diffSequences(ctx, main, branch, branchTables = {}) {
                 mainSequence.cycle_option !== branchSequence.cycle_option;
             if (optionsChanged) {
                 const options = [];
+                // `AS <type>` must come before any MIN/MAX/RESTART clauses per the
+                // PG ALTER SEQUENCE grammar. Valid types are smallint, integer,
+                // bigint — the same set CREATE SEQUENCE accepts — so the universe
+                // of legal transitions is closed. PG enforces last_value range at
+                // apply time when shrinking; that's the desired behavior because
+                // the previous Drop+Create path silently reset last_value to 1
+                // (data-loss bug, see Sentry SUPABASE-API-7RS).
+                if (mainSequence.data_type !== branchSequence.data_type) {
+                    options.push("AS", branchSequence.data_type);
+                }
                 if (mainSequence.increment !== branchSequence.increment) {
                     options.push("INCREMENT BY", String(branchSequence.increment));
                 }

package/dist/core/objects/table/changes/table.alter.d.ts

@@ -250,9 +250,11 @@ export declare class AlterTableDropColumn extends AlterTableChange {
     readonly table: Table;
     readonly column: ColumnProps;
     readonly scope: "object";
+    readonly omitTableRequirement: boolean;
     constructor(props: {
         table: Table;
         column: ColumnProps;
+        omitTableRequirement?: boolean;
     });
     get drops(): `column:${string}.${string}.${string}`[];
     get requires(): (`column:${string}.${string}.${string}` | `table:${string}`)[];
@@ -264,10 +266,12 @@ export declare class AlterTableDropColumn extends AlterTableChange {
 export declare class AlterTableAlterColumnType extends AlterTableChange {
     readonly table: Table;
     readonly column: ColumnProps;
+    readonly previousColumn?: ColumnProps;
     readonly scope: "object";
     constructor(props: {
         table: Table;
         column: ColumnProps;
+        previousColumn?: ColumnProps;
     });
     get requires(): `column:${string}.${string}.${string}`[];
     serialize(_options?: SerializeOptions): string;

package/dist/core/objects/table/changes/table.alter.js

@@ -386,10 +386,16 @@ export class AlterTableDropColumn extends AlterTableChange {
     table;
     column;
     scope = "object";
+    // 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.
+    omitTableRequirement;
     constructor(props) {
         super();
         this.table = props.table;
         this.column = props.column;
+        this.omitTableRequirement = props.omitTableRequirement ?? false;
     }
     get drops() {
         return [
@@ -397,10 +403,8 @@ 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) {
         return [
@@ -417,11 +421,13 @@ export class AlterTableDropColumn extends AlterTableChange {
 export class AlterTableAlterColumnType extends AlterTableChange {
     table;
     column;
+    previousColumn;
     scope = "object";
     constructor(props) {
         super();
         this.table = props.table;
         this.column = props.column;
+        this.previousColumn = props.previousColumn;
     }
     get requires() {
         return [
@@ -429,6 +435,12 @@ export class AlterTableAlterColumnType extends AlterTableChange {
         ];
     }
     serialize(_options) {
+        // 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 = [
             "ALTER TABLE",
             `${this.table.schema}.${this.table.name}`,
@@ -440,6 +452,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/dist/core/objects/table/table.diff.js

@@ -451,15 +451,30 @@ export function diffTables(ctx, main, branch) {
             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,
+                        }));
+                    }
                 }
             }
             // PostgreSQL rejects SET DEFAULT while the column still has identity metadata,
@@ -476,6 +491,10 @@ export function diffTables(ctx, main, branch) {
             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(new AlterTableAlterColumnDropDefault({

package/dist/core/objects/table/table.model.js

@@ -265,13 +265,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/dist/core/post-diff-cycle-breaking.d.ts

@@ -1,29 +1,29 @@
-import type { Catalog } from "./catalog.model.ts";
 import type { Change } from "./change.types.ts";
 /**
- * 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, …).
  *
- * 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.
+ * Concretely, this pass:
  *
- * Object-local PostgreSQL semantics (for example owned-sequence cascades) stay
- * in the corresponding `diff*` function instead of 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 declare function normalizePostDiffCycles({ changes, mainCatalog, replacedTableIds, }: {
+export declare function normalizePostDiffCycles({ changes, replacedTableIds, }: {
     changes: Change[];
-    mainCatalog: Catalog;
     replacedTableIds?: ReadonlySet<string>;
 }): Change[];

package/dist/core/post-diff-cycle-breaking.js

@@ -1,32 +1,9 @@
 import { AlterTableAddConstraint, AlterTableDropColumn, AlterTableDropConstraint, AlterTableValidateConstraint, } from "./objects/table/changes/table.alter.js";
 import { CreateCommentOnConstraint } from "./objects/table/changes/table.comment.js";
-import { DropTable } from "./objects/table/changes/table.drop.js";
 import { stableId } from "./objects/utils.js";
 function constraintStableId(table, constraintName) {
     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, droppedSet) {
-    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, replacedTableIds) {
     if (!(change instanceof AlterTableDropColumn) &&
         !(change instanceof AlterTableDropConstraint)) {
@@ -91,119 +68,33 @@ function dropReplacedTableDuplicateConstraintChanges(changes, replacedTableIds)
     }
     return mutated ? reversedKept.reverse() : changes;
 }
-function collectExplicitConstraintDropIds(changes) {
-    const explicitConstraintDropIds = new Set();
-    for (const change of changes) {
-        if (!(change instanceof AlterTableDropConstraint))
-            continue;
-        explicitConstraintDropIds.add(constraintStableId(change.table, change.constraint.name));
-    }
-    return explicitConstraintDropIds;
-}
-function hasSameEntries(left, right) {
-    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, …).
  *
- * 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.
+ * Concretely, this pass:
  *
- * Object-local PostgreSQL semantics (for example owned-sequence cascades) stay
- * in the corresponding `diff*` function instead of 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, mainCatalog, replacedTableIds = new Set(), }) {
+export function normalizePostDiffCycles({ changes, replacedTableIds = new Set(), }) {
     const dedupedChanges = dropReplacedTableDuplicateConstraintChanges(changes, replacedTableIds);
-    const structurallyNormalizedChanges = replacedTableIds.size === 0
-        ? dedupedChanges
-        : dedupedChanges.filter((change) => !isSupersededByTableReplacement(change, replacedTableIds));
-    const dropTableChanges = structurallyNormalizedChanges.filter((change) => change instanceof DropTable);
-    if (dropTableChanges.length < 2) {
-        return structurallyNormalizedChanges;
-    }
-    const droppedSet = new Set(dropTableChanges.map((change) => change.table.stableId));
-    const droppedFkTargets = new Map();
-    for (const dropTableChange of dropTableChanges) {
-        const mainTable = mainCatalog.tables[dropTableChange.table.stableId] ??
-            dropTableChange.table;
-        const targets = new Set();
-        for (const { referencedId } of iterCrossDropFkConstraints(mainTable, droppedSet)) {
-            targets.add(referencedId);
-        }
-        droppedFkTargets.set(mainTable.stableId, targets);
-    }
-    const explicitConstraintDropIds = collectExplicitConstraintDropIds(structurallyNormalizedChanges);
-    const injectedConstraintDropsByTableId = new Map();
-    const externallyDroppedConstraintsByTableId = new Map();
-    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 = [];
-    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;
+    if (replacedTableIds.size === 0)
+        return dedupedChanges;
+    return dedupedChanges.filter((change) => !isSupersededByTableReplacement(change, replacedTableIds));
 }

package/dist/core/sort/cycle-breakers.d.ts

@@ -0,0 +1,15 @@
+import type { Change } from "../change.types.ts";
+/**
+ * Try to break an unbreakable cycle by INJECTING NEW CHANGES or REWRITING
+ * existing ones (rather than removing graph edges).
+ *
+ * Called by `sortPhaseChanges` when its edge-removal cycle handler has seen
+ * the same cycle twice — i.e. weak-edge filtering exhausted itself but the
+ * cycle is still there. At that point we know the cycle is composed of
+ * "hard" edges (explicit `requires` or pg_depend rows) that can only be
+ * broken by changing the change list itself.
+ *
+ * Returns a rewritten `phaseChanges` array, or `null` if no breaker matches
+ * (in which case the caller throws the existing CycleError).
+ */
+export declare function tryBreakCycleByChangeInjection(cycleNodeIndexes: readonly number[], phaseChanges: readonly Change[]): Change[] | null;