@supabase/pg-delta 1.0.0-alpha.3 → 1.0.0-alpha.30

package/dist/core/sort/custom-constraints.js

@@ -1,5 +1,6 @@
-import { getSchema } from "../integrations/filter/extractors.js";
+import { getSchema } from "../change-utils.js";
 import { GrantRoleDefaultPrivileges, RevokeRoleDefaultPrivileges, } from "../objects/role/changes/role.privilege.js";
+import { AlterTableAlterColumnAddIdentity, AlterTableAlterColumnDropDefault, AlterTableAlterColumnDropIdentity, AlterTableAlterColumnSetDefault, } from "../objects/table/changes/table.alter.js";
 /**
  * Maps object type names to PostgreSQL default privilege objtype codes.
  * This mirrors the mapping in base.default-privileges.ts.
@@ -116,11 +117,74 @@ function generateDefaultPrivilegeConstraints(changes) {
     }
     return constraints;
 }
+function generateIdentityTransitionConstraints(changes) {
+    const constraints = [];
+    const dropDefaultByColumn = new Map();
+    const dropIdentityByColumn = new Map();
+    const addIdentityByColumn = new Map();
+    const setDefaultByColumn = new Map();
+    for (let i = 0; i < changes.length; i++) {
+        const change = changes[i];
+        const columnKey = "table" in change && "column" in change
+            ? `${change.table.schema}.${change.table.name}.${change.column.name}`
+            : null;
+        if (!columnKey)
+            continue;
+        if (change instanceof AlterTableAlterColumnDropDefault) {
+            const entries = dropDefaultByColumn.get(columnKey) ?? [];
+            entries.push(i);
+            dropDefaultByColumn.set(columnKey, entries);
+        }
+        else if (change instanceof AlterTableAlterColumnAddIdentity) {
+            const entries = addIdentityByColumn.get(columnKey) ?? [];
+            entries.push(i);
+            addIdentityByColumn.set(columnKey, entries);
+        }
+        else if (change instanceof AlterTableAlterColumnDropIdentity) {
+            const entries = dropIdentityByColumn.get(columnKey) ?? [];
+            entries.push(i);
+            dropIdentityByColumn.set(columnKey, entries);
+        }
+        else if (change instanceof AlterTableAlterColumnSetDefault) {
+            const entries = setDefaultByColumn.get(columnKey) ?? [];
+            entries.push(i);
+            setDefaultByColumn.set(columnKey, entries);
+        }
+    }
+    // These rules only order same-column ALTERs inside the create/alter phase.
+    // Sequence drops are handled separately in the earlier drop phase.
+    for (const [columnKey, dropDefaultIndexes] of dropDefaultByColumn) {
+        const addIdentityIndexes = addIdentityByColumn.get(columnKey) ?? [];
+        for (const sourceIndex of dropDefaultIndexes) {
+            for (const targetIndex of addIdentityIndexes) {
+                constraints.push({
+                    sourceChangeIndex: sourceIndex,
+                    targetChangeIndex: targetIndex,
+                    source: "custom",
+                });
+            }
+        }
+    }
+    for (const [columnKey, dropIdentityIndexes] of dropIdentityByColumn) {
+        const setDefaultIndexes = setDefaultByColumn.get(columnKey) ?? [];
+        for (const sourceIndex of dropIdentityIndexes) {
+            for (const targetIndex of setDefaultIndexes) {
+                constraints.push({
+                    sourceChangeIndex: sourceIndex,
+                    targetChangeIndex: targetIndex,
+                    source: "custom",
+                });
+            }
+        }
+    }
+    return constraints;
+}
 /**
  * All custom constraint generators.
  */
 const customConstraintGenerators = [
     generateDefaultPrivilegeConstraints,
+    generateIdentityTransitionConstraints,
 ];
 /**
  * Generate Constraints from custom constraint generators.

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;

package/dist/core/sort/cycle-breakers.js

@@ -0,0 +1,396 @@
+import { AlterPublicationDropTables } from "../objects/publication/changes/publication.alter.js";
+import { AlterTableDropColumn, AlterTableDropConstraint, } from "../objects/table/changes/table.alter.js";
+import { DropTable } from "../objects/table/changes/table.drop.js";
+import { stableId } from "../objects/utils.js";
+/**
+ * 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 function tryBreakCycleByChangeInjection(cycleNodeIndexes, phaseChanges) {
+    // ─── Branch A: FK cycle among DropTable changes ──────────────────────
+    // Triggered when N≥2 dropped tables reference each other via foreign
+    // keys. With no surviving table on either side, every FK constraint
+    // stable-id ends up tied back to a DropTable node, and every
+    // pg_depend row produces a hard explicit edge between two DropTables.
+    // Edge filtering can't break it — the edges are not weak.
+    //
+    // Example (3-cycle):
+    //   DROP TABLE a; DROP TABLE b; DROP TABLE c;
+    //   where  a.b_id REFERENCES b,  b.c_id REFERENCES c,  c.a_id REFERENCES a
+    //
+    // Fix: inject a dedicated `ALTER TABLE ... DROP CONSTRAINT fk` ahead of
+    // each DropTable in the cycle, and mark the constraint name on
+    // `DropTable.externallyDroppedConstraints` so the table drop won't try
+    // to re-claim the same constraint stable-id. The injected drops have
+    // their own stable-id ownership and run before any DropTable, breaking
+    // the cycle.
+    //
+    // This naturally handles any N (2-cycle, 3-cycle, …) because
+    // `findCycle` already gave us the full member list — no separate SCC
+    // enumeration needed.
+    const fkBroken = tryBreakFkCycle(cycleNodeIndexes, phaseChanges);
+    if (fkBroken)
+        return fkBroken;
+    // ─── Branch B: Publication ↔ Column on a surviving table ─────────────
+    // Triggered when a publication has an explicit column list and one of
+    // those columns is dropped on a table that itself is NOT being dropped
+    // (the table just loses one column).
+    //
+    // Example:
+    //   CREATE PUBLICATION p FOR TABLE lab_results (id, flash_summary);
+    //   ALTER TABLE lab_results DROP COLUMN flash_summary;
+    //
+    // Diff emits two drop-phase changes:
+    //   AlterPublicationDropTables(p, [lab_results])
+    //   AlterTableDropColumn(lab_results.flash_summary)
+    //
+    // The cycle:
+    //   pub:p → col:lab_results.flash_summary  (catalog, pg_depend)
+    //   col:lab_results.flash_summary → table:lab_results
+    //                                         (explicit, AlterTableDropColumn.requires)
+    //
+    // Fix: rebuild the AlterTableDropColumn with `omitTableRequirement=true`
+    // so it no longer requires `table:lab_results`. Safe because
+    // `lab_results` survives the migration; its lifetime trivially covers
+    // the column drop. The catalog edge `pub → col` correctly orders the
+    // publication drop before the column drop.
+    const pubColBroken = tryBreakPublicationColumnCycle(cycleNodeIndexes, phaseChanges);
+    if (pubColBroken)
+        return pubColBroken;
+    // ─── Branch C: Publication ↔ dropped FK chain ↔ constraint drop ──────
+    // Triggered when publication membership is being removed for tables in
+    // the same drop phase as a FK chain, and the chain ends at a separately
+    // emitted `AlterTableDropConstraint` on a table that is also being
+    // removed from the publication.
+    //
+    // Example (4-change cycle):
+    //   AlterPublicationDropTables(p, [labs, posts, post_attachments])
+    //   DropTable(post_attachments)
+    //   DropTable(posts)
+    //   AlterTableDropConstraint(labs.unique_lab_id)
+    //
+    // Cycle:
+    //   publication:p → table:post_attachments
+    //   post_attachments.post_id_fkey → column:posts.id
+    //   posts.lab_id_fkey → constraint:labs.unique_lab_id
+    //   constraint:labs.unique_lab_id → table:labs
+    //
+    // Fix: inject explicit FK drops for the FK constraints claimed by the
+    // DropTables in the cycle, including FKs that point at the terminal
+    // dropped constraint. The publication and terminal constraint changes
+    // stay unchanged; only the intermediate FK ownership is reassigned from
+    // DropTable to dedicated AlterTableDropConstraint changes.
+    const pubFkConstraintBroken = tryBreakPublicationFkConstraintDropCycle(cycleNodeIndexes, phaseChanges);
+    if (pubFkConstraintBroken)
+        return pubFkConstraintBroken;
+    // No known pattern. Returning null lets sortPhaseChanges throw the
+    // formatted CycleError with full diagnostic — better a clear bug
+    // report than silently shipping a broken plan.
+    return null;
+}
+/**
+ * Branch A worker — inject `AlterTableDropConstraint` for every FK linking
+ * two DropTables in the cycle.
+ *
+ * Returns the rewritten changes array, or `null` if the cycle does not
+ * match (e.g. mixed types, or no cross-cycle FK exists).
+ */
+function tryBreakFkCycle(cycleNodeIndexes, phaseChanges) {
+    // Guard: every member of the cycle must be a DropTable. Mixed cycles
+    // (e.g. DropTable + DropView, or DropTable + DropMaterializedView) are
+    // out of scope — they need a different breaker.
+    const cycleDropTables = [];
+    for (const nodeIndex of cycleNodeIndexes) {
+        const change = phaseChanges[nodeIndex];
+        if (!(change instanceof DropTable))
+            return null;
+        cycleDropTables.push(change);
+    }
+    const cycleTableIds = new Set(cycleDropTables.map((change) => change.table.stableId));
+    return injectFkConstraintDropsForDropTables({
+        phaseChanges,
+        dropTables: cycleDropTables,
+        shouldInject: (fk, tableId) => isCrossCycleFkConstraint(fk, tableId, cycleTableIds),
+    });
+}
+/**
+ * Shared FK-drop injection used by Branch A and Branch C. The caller owns
+ * the cycle-specific matcher; this helper only handles the mechanical
+ * rewrite: add dedicated `AlterTableDropConstraint` changes and rebuild
+ * affected `DropTable`s with updated `externallyDroppedConstraints`.
+ */
+function injectFkConstraintDropsForDropTables({ phaseChanges, dropTables, shouldInject, }) {
+    // For each DropTable in the cycle, find every FK whose referenced table
+    // is also in the cycle. Each such FK becomes one injected
+    // `AlterTableDropConstraint` and one entry on the source table's
+    // `externallyDroppedConstraints`.
+    //
+    // 2-cycle example: { A→B, B→A } — two FKs, two injected drops.
+    // 3-cycle example: { A→B, B→C, C→A } — three FKs, three injected drops.
+    const injectedDropsByTableId = new Map();
+    const updatedExternalsByTableId = new Map();
+    let didMutate = false;
+    for (const dropTable of dropTables) {
+        const tableId = dropTable.table.stableId;
+        const existingExternals = new Set(dropTable.externallyDroppedConstraints);
+        let tableMutated = false;
+        for (const fk of iterFkConstraints(dropTable.table.constraints)) {
+            if (!shouldInject(fk, tableId))
+                continue;
+            // Skip if a same-table `AlterTableDropConstraint` is already in the
+            // change list — could happen if a previous breaker iteration
+            // injected one, or the diff layer emitted one explicitly.
+            if (existingExternals.has(fk.name))
+                continue;
+            if (alreadyHasExplicitDrop(phaseChanges, tableId, fk.name))
+                continue;
+            const injected = new AlterTableDropConstraint({
+                table: dropTable.table,
+                constraint: fk,
+            });
+            const list = injectedDropsByTableId.get(tableId) ?? [];
+            list.push(injected);
+            injectedDropsByTableId.set(tableId, list);
+            existingExternals.add(fk.name);
+            tableMutated = true;
+            didMutate = true;
+        }
+        if (tableMutated) {
+            updatedExternalsByTableId.set(tableId, existingExternals);
+        }
+    }
+    if (!didMutate)
+        return null;
+    // Rebuild phaseChanges: keep all non-DropTable changes in place. For
+    // each DropTable in the cycle that gained injected drops, emit the
+    // injected drops first, then a fresh DropTable carrying the updated
+    // `externallyDroppedConstraints` so it stops claiming the FK
+    // stable-ids.
+    const rewritten = [];
+    for (const change of phaseChanges) {
+        if (!(change instanceof DropTable)) {
+            rewritten.push(change);
+            continue;
+        }
+        const tableId = change.table.stableId;
+        const injected = injectedDropsByTableId.get(tableId);
+        if (injected) {
+            rewritten.push(...injected);
+        }
+        const updatedExternals = updatedExternalsByTableId.get(tableId);
+        if (updatedExternals) {
+            rewritten.push(new DropTable({
+                table: change.table,
+                externallyDroppedConstraints: updatedExternals,
+            }));
+        }
+        else {
+            rewritten.push(change);
+        }
+    }
+    return rewritten;
+}
+/**
+ * Yield FK constraints on `constraints`.
+ *
+ * Partition clones are skipped because PostgreSQL drops them when the
+ * parent constraint is dropped.
+ */
+function* iterFkConstraints(constraints) {
+    for (const constraint of constraints) {
+        if (constraint.constraint_type !== "f")
+            continue;
+        if (constraint.is_partition_clone)
+            continue;
+        yield constraint;
+    }
+}
+/**
+ * True when `constraint` references another DropTable in the cycle.
+ *
+ * Self-referencing FKs are skipped — they create a self-loop in the
+ * dependency graph which the existing sort-phase handler resolves on its
+ * own; injecting an `AlterTableDropConstraint` for a self-FK would just
+ * add noise.
+ */
+function isCrossCycleFkConstraint(constraint, ownTableId, cycleTableIds) {
+    if (!constraint.foreign_key_schema || !constraint.foreign_key_table) {
+        return false;
+    }
+    const referencedId = stableId.table(constraint.foreign_key_schema, constraint.foreign_key_table);
+    if (referencedId === ownTableId)
+        return false;
+    return cycleTableIds.has(referencedId);
+}
+/**
+ * True iff `phaseChanges` already contains an explicit
+ * `AlterTableDropConstraint(table, constraint)` for the given pair —
+ * either emitted by the diff layer or by a previous breaker iteration.
+ * Avoids duplicate constraint drops.
+ */
+function alreadyHasExplicitDrop(phaseChanges, tableId, constraintName) {
+    for (const change of phaseChanges) {
+        if (!(change instanceof AlterTableDropConstraint))
+            continue;
+        if (change.table.stableId !== tableId)
+            continue;
+        if (change.constraint.name === constraintName)
+            return true;
+    }
+    return false;
+}
+/**
+ * Branch B worker — break the publication↔column cycle by rebuilding the
+ * `AlterTableDropColumn` change with `omitTableRequirement=true`.
+ *
+ * Returns the rewritten changes array, or `null` if the cycle does not
+ * match (e.g. table is also being dropped, or no `AlterPublicationDropTables`
+ * references the table).
+ */
+function tryBreakPublicationColumnCycle(cycleNodeIndexes, phaseChanges) {
+    // Find an `AlterTableDropColumn` and an `AlterPublicationDropTables` in
+    // the cycle that reference the same table. Both must be present —
+    // otherwise this is a different cycle shape.
+    let dropColumnIndex = -1;
+    let dropColumnChange = null;
+    let pubMatchesTable = false;
+    let pubChange = null;
+    for (const nodeIndex of cycleNodeIndexes) {
+        const change = phaseChanges[nodeIndex];
+        if (change instanceof AlterTableDropColumn &&
+            !change.omitTableRequirement) {
+            dropColumnIndex = nodeIndex;
+            dropColumnChange = change;
+        }
+        else if (change instanceof AlterPublicationDropTables) {
+            pubChange = change;
+        }
+    }
+    if (dropColumnChange === null || pubChange === null)
+        return null;
+    // Verify the publication is actually dropping membership for the same
+    // table whose column is being dropped. Without this check we'd risk
+    // rewriting an unrelated AlterTableDropColumn that happens to share a
+    // cycle with some other publication change.
+    const targetTableId = dropColumnChange.table.stableId;
+    for (const t of pubChange.tables) {
+        if (stableId.table(t.schema, t.name) === targetTableId) {
+            pubMatchesTable = true;
+            break;
+        }
+    }
+    if (!pubMatchesTable)
+        return null;
+    // Verify the table is NOT itself being dropped. If `DropTable(T)` is in
+    // the same phase, the existing structural rewrites in
+    // `post-diff-normalization.ts` (replace-expansion superseded filter)
+    // already prune the redundant `AlterTableDropColumn`, so we should not
+    // see this combination here. Be defensive and bail anyway — flipping
+    // `omitTableRequirement` when T is being dropped would let the column
+    // drop reorder against the table drop, which is unsafe.
+    for (const change of phaseChanges) {
+        if (change instanceof DropTable &&
+            change.table.stableId === targetTableId) {
+            return null;
+        }
+    }
+    // Replace the AlterTableDropColumn with a fresh instance carrying
+    // `omitTableRequirement=true`. All other changes pass through
+    // unchanged.
+    const rewritten = phaseChanges.slice();
+    rewritten[dropColumnIndex] = new AlterTableDropColumn({
+        table: dropColumnChange.table,
+        column: dropColumnChange.column,
+        omitTableRequirement: true,
+    });
+    return rewritten;
+}
+/**
+ * Branch C worker — break a publication membership removal cycle where
+ * dropped tables form a FK chain ending at a separately dropped referenced
+ * constraint.
+ */
+function tryBreakPublicationFkConstraintDropCycle(cycleNodeIndexes, phaseChanges) {
+    let pubChange = null;
+    let terminalConstraintDrop = null;
+    const dropTables = [];
+    for (const nodeIndex of cycleNodeIndexes) {
+        const change = phaseChanges[nodeIndex];
+        if (change instanceof AlterPublicationDropTables) {
+            if (pubChange !== null)
+                return null;
+            pubChange = change;
+        }
+        else if (change instanceof AlterTableDropConstraint) {
+            if (terminalConstraintDrop !== null)
+                return null;
+            terminalConstraintDrop = change;
+        }
+        else if (change instanceof DropTable) {
+            dropTables.push(change);
+        }
+        else {
+            return null;
+        }
+    }
+    if (pubChange === null ||
+        terminalConstraintDrop === null ||
+        dropTables.length === 0) {
+        return null;
+    }
+    const publicationTableIds = new Set(pubChange.tables.map((table) => stableId.table(table.schema, table.name)));
+    if (!publicationTableIds.has(terminalConstraintDrop.table.stableId)) {
+        return null;
+    }
+    // At least one dropped table must be a publication member — that's the
+    // publication → DropTable edge that pulls the publication change into the
+    // cycle (the back-edge is the terminal constraint's table, checked above).
+    // Don't require ALL of them: publications like supabase_realtime commonly
+    // contain only a subset of tables, so intermediate FK-chain tables may not
+    // be members (Sentry SUPABASE-API-7RS / CLI-1605).
+    if (!dropTables.some((dropTable) => publicationTableIds.has(dropTable.table.stableId))) {
+        return null;
+    }
+    const cycleDropTableIds = new Set(dropTables.map((change) => change.table.stableId));
+    let hasFkToTerminalConstraint = false;
+    for (const dropTable of dropTables) {
+        for (const fk of iterFkConstraints(dropTable.table.constraints)) {
+            if (fkReferencesConstraint(fk, terminalConstraintDrop)) {
+                hasFkToTerminalConstraint = true;
+                break;
+            }
+        }
+        if (hasFkToTerminalConstraint)
+            break;
+    }
+    if (!hasFkToTerminalConstraint)
+        return null;
+    return injectFkConstraintDropsForDropTables({
+        phaseChanges,
+        dropTables,
+        shouldInject: (fk, tableId) => isCrossCycleFkConstraint(fk, tableId, cycleDropTableIds) ||
+            fkReferencesConstraint(fk, terminalConstraintDrop),
+    });
+}
+function fkReferencesConstraint(fk, constraintDrop) {
+    if (fk.foreign_key_schema !== constraintDrop.table.schema ||
+        fk.foreign_key_table !== constraintDrop.table.name ||
+        fk.foreign_key_columns === null) {
+        return false;
+    }
+    return sameOrderedStrings(fk.foreign_key_columns, constraintDrop.constraint.key_columns);
+}
+function sameOrderedStrings(left, right) {
+    if (left.length !== right.length)
+        return false;
+    return left.every((value, index) => value === right[index]);
+}

package/dist/core/sort/debug-visualization.js

@@ -139,7 +139,7 @@ export function printDebugGraph(phaseChanges, graphData, edges, dependencyRows,
         const mermaidDiagram = generateMermaidDiagram(phaseChanges, graphData, edges, requirementSets, dependenciesByReferencedId);
         debugGraph("\n==== Mermaid (cycle detected) ====\n%s\n==== end ====", mermaidDiagram);
     }
-    catch (_error) {
+    catch {
         // ignore debug printing errors
     }
 }

package/dist/core/sort/graph-builder.js

@@ -56,7 +56,17 @@ export function convertExplicitRequirementsToConstraints(phaseChanges, graphData
         const requiredIds = graphData.explicitRequirementSets[consumerIndex];
         if (requiredIds.size === 0)
             continue;
+        // Collect dropped IDs for this change so we can skip requirements
+        // for stableIds that this change also drops.  A change that drops a
+        // stableId should not depend on another change that creates the same
+        // stableId, because the entity already exists in the source database.
+        // This prevents false ordering constraints such as Grant → Revoke
+        // when both operate on the same ACL stableId.
+        const droppedIds = new Set(phaseChanges[consumerIndex].drops);
         for (const requiredId of requiredIds) {
+            if (droppedIds.has(requiredId)) {
+                continue;
+            }
             const producerIndexes = graphData.changeIndexesByCreatedId.get(requiredId);
             if (!producerIndexes || producerIndexes.size === 0)
                 continue;
@@ -109,6 +119,12 @@ export function buildGraphData(phaseChanges, options) {
             for (const droppedId of changeItem.drops ?? []) {
                 createdIds.add(droppedId);
             }
+            // In-place mutations keep the object identity but invalidate
+            // dependents, so for drop-phase ordering they behave like producers of
+            // the invalidated ids without changing Change.drops.
+            for (const invalidatedId of changeItem.invalidates) {
+                createdIds.add(invalidatedId);
+            }
         }
         return createdIds;
     });

package/dist/core/sort/logical-sort.js

@@ -8,7 +8,7 @@
  * It groups related changes together while preserving the ability for the dependency
  * resolver to reorder within groups when necessary.
  */
-import { getSchema } from "../integrations/filter/extractors.js";
+import { getSchema } from "../change-utils.js";
 import { getExecutionPhase, isMetadataStableId } from "./utils.js";
 /**
  * Object type ordering for logical grouping.
@@ -145,6 +145,25 @@ function getMainStableId(change) {
         }
         return null;
     }
+    // For default_privilege operations: group by role + schema combination (before CREATE so we group and use tiebreaker)
+    if (change.scope === "default_privilege") {
+        if (change.requires.length > 0) {
+            let grantingRole = null;
+            let schemaId = null;
+            for (const id of change.requires) {
+                if (id.startsWith("role:")) {
+                    grantingRole = id;
+                }
+                else if (id.startsWith("schema:")) {
+                    schemaId = id;
+                }
+            }
+            if (schemaId && grantingRole) {
+                return `${grantingRole}:${schemaId}`;
+            }
+            return grantingRole ?? null;
+        }
+    }
     // For CREATE operations: check if creating a constraint (sub-entity of table)
     if (change.operation === "create" && change.creates.length > 0) {
         // Iterate through creates to find the first non-metadata stable ID
@@ -182,29 +201,6 @@ function getMainStableId(change) {
         // Fallback: if all drops are metadata, use first
         return change.drops[0] ?? null;
     }
-    // For default_privilege operations: group by role + schema combination
-    // This groups all "FOR ROLE X IN SCHEMA Y" statements together
-    if (change.scope === "default_privilege") {
-        if (change.requires.length > 0) {
-            // Iterate through requires to find role and schema
-            let grantingRole = null;
-            let schemaId = null;
-            for (const id of change.requires) {
-                if (id.startsWith("role:")) {
-                    grantingRole = id;
-                }
-                else if (id.startsWith("schema:")) {
-                    schemaId = id;
-                }
-            }
-            if (schemaId && grantingRole) {
-                // Create composite key: "role:postgres:schema:public"
-                return `${grantingRole}:${schemaId}`;
-            }
-            // If no schema, just group by role
-            return grantingRole ?? null;
-        }
-    }
     // For ALTER operations: check if creating/dropping a constraint
     // Skip this for privilege/comment/default_privilege scopes (handled above)
     if (change.operation === "alter") {
@@ -291,27 +287,6 @@ function getParentStableId(change) {
     // Fallback: return first requires if available
     return requires.length > 0 ? requires[0] : null;
 }
-/**
- * Extract schema name from a change.
- * Returns the schema name if present, or null for non-schema objects.
- *
- * Uses the getSchema helper which directly accesses schema properties from change objects.
- * For default_privilege changes, accesses the inSchema property directly.
- * For event_trigger changes, groups by their function's schema.
- */
-function extractSchemaFromChange(change) {
-    // Handle default_privilege changes specially (they have inSchema property)
-    if (change.scope === "default_privilege") {
-        // TypeScript doesn't know about inSchema, but we know it exists for default_privilege changes
-        return change.inSchema ?? null;
-    }
-    // Handle event_trigger changes specially - group by their function's schema
-    if (change.objectType === "event_trigger") {
-        return change.eventTrigger.function_schema;
-    }
-    // Use the getSchema helper for all other changes
-    return getSchema(change);
-}
 /**
  * Get the effective object type for sorting purposes.
  * For sub-entities, returns the parent's object type (table/view/materialized_view).
@@ -403,8 +378,8 @@ function sortPhase(changes, phase) {
         const changeA = a.change;
         const changeB = b.change;
         // 1. Compare schemas (group objects by schema)
-        const schemaA = extractSchemaFromChange(changeA);
-        const schemaB = extractSchemaFromChange(changeB);
+        const schemaA = getSchema(changeA);
+        const schemaB = getSchema(changeB);
         // Non-schema objects (roles, languages, extensions, etc.) sort first
         // Use a special prefix to ensure they come before schema objects
         const schemaKeyA = schemaA === null ? "::" : schemaA;
@@ -525,6 +500,18 @@ function sortPhase(changes, phase) {
         if (operationOrderA !== operationOrderB) {
             return operationOrderA - operationOrderB;
         }
+        // 6b. For default_privilege: deterministic tiebreaker by objtype then grantee (canonical order for objtype)
+        if (scopeA === "default_privilege" && scopeB === "default_privilege") {
+            const defPrivA = changeA;
+            const defPrivB = changeB;
+            const objtypeOrder = (code) => ({ n: 0, r: 1, S: 2, f: 3, T: 4 })[code] ?? 99;
+            const objtypeCompare = objtypeOrder(defPrivA.objtype) - objtypeOrder(defPrivB.objtype);
+            if (objtypeCompare !== 0)
+                return objtypeCompare;
+            const granteeCompare = defPrivA.grantee.localeCompare(defPrivB.grantee);
+            if (granteeCompare !== 0)
+                return granteeCompare;
+        }
         // 7. Preserve original order (stability)
         return a.originalIndex - b.originalIndex;
     });