@supabase/pg-delta 1.0.0-alpha.23 → 1.0.0-alpha.24

package/dist/core/post-diff-normalization.d.ts

@@ -15,6 +15,13 @@ import type { Table } from "./objects/table/table.model.ts";
  *   `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.
+ * - Prunes `DropSequence(S)` changes when `S` is `OWNED BY` a column on a
+ *   table promoted to `DropTable + CreateTable` by the expander. The
+ *   `DROP TABLE` cascade drops the sequence at apply time; emitting an
+ *   explicit `DROP SEQUENCE` in the same drop phase both duplicates the
+ *   cascade and forms an unbreakable `DropSequence ↔ DropTable` cycle on
+ *   the bidirectional pg_depend edges between the sequence and the
+ *   owning column.
  * - Dedupes duplicate `AlterTableAddConstraint` /
  *   `AlterTableValidateConstraint` / `CreateCommentOnConstraint` changes
  *   produced when `diffTables()` and `expandReplaceDependencies()` both

package/dist/core/post-diff-normalization.js

@@ -1,5 +1,6 @@
 import { CreateIndex } from "./objects/index/changes/index.create.js";
 import { DropIndex } from "./objects/index/changes/index.drop.js";
+import { DropSequence } from "./objects/sequence/changes/sequence.drop.js";
 import { AlterTableAddConstraint, AlterTableDropColumn, AlterTableDropConstraint, AlterTableSetReplicaIdentity, AlterTableValidateConstraint, } from "./objects/table/changes/table.alter.js";
 import { CreateCommentOnConstraint } from "./objects/table/changes/table.comment.js";
 import { stableId } from "./objects/utils.js";
@@ -7,11 +8,32 @@ function constraintStableId(table, constraintName) {
     return stableId.constraint(table.schema, table.name, constraintName);
 }
 function isSupersededByTableReplacement(change, replacedTableIds) {
-    if (!(change instanceof AlterTableDropColumn) &&
-        !(change instanceof AlterTableDropConstraint)) {
-        return false;
+    if (change instanceof AlterTableDropColumn ||
+        change instanceof AlterTableDropConstraint) {
+        return replacedTableIds.has(change.table.stableId);
     }
-    return replacedTableIds.has(change.table.stableId);
+    // `DropSequence(S)` is superseded when S is OWNED BY a column on a table
+    // that `expandReplaceDependencies` has promoted to `DropTable + CreateTable`
+    // in the same plan. PostgreSQL cascade-drops the OWNED BY sequence as part
+    // of the DROP TABLE, so the explicit DROP SEQUENCE is redundant and — more
+    // importantly — closes an unbreakable `DropSequence ↔ DropTable` cycle in
+    // the drop phase via the bidirectional pg_depend edges between the
+    // sequence and its owning column (`column → sequence` for the DEFAULT
+    // nextval reference, `sequence → column` for the OWNED BY auto-dependency).
+    // The alpha.15 short-circuit in `diffSequences.dropped` only suppresses
+    // `DropSequence` when the owning table itself is gone from `branchTables`;
+    // here the table survives in branch and the replacement is added later by
+    // the expander, so this whole-plan rewrite has to happen post-diff.
+    if (change instanceof DropSequence) {
+        if (!change.sequence.owned_by_schema ||
+            !change.sequence.owned_by_table ||
+            !change.sequence.owned_by_column) {
+            return false;
+        }
+        const ownedByTableId = stableId.table(change.sequence.owned_by_schema, change.sequence.owned_by_table);
+        return replacedTableIds.has(ownedByTableId);
+    }
+    return false;
 }
 /**
  * Drop earlier duplicates of `AlterTableAddConstraint` /
@@ -179,6 +201,13 @@ function restoreReplicaIdentityAfterIndexReplace(changes, branchTables) {
  *   `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.
+ * - Prunes `DropSequence(S)` changes when `S` is `OWNED BY` a column on a
+ *   table promoted to `DropTable + CreateTable` by the expander. The
+ *   `DROP TABLE` cascade drops the sequence at apply time; emitting an
+ *   explicit `DROP SEQUENCE` in the same drop phase both duplicates the
+ *   cascade and forms an unbreakable `DropSequence ↔ DropTable` cycle on
+ *   the bidirectional pg_depend edges between the sequence and the
+ *   owning column.
  * - Dedupes duplicate `AlterTableAddConstraint` /
  *   `AlterTableValidateConstraint` / `CreateCommentOnConstraint` changes
  *   produced when `diffTables()` and `expandReplaceDependencies()` both

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

@@ -66,6 +66,32 @@ export function tryBreakCycleByChangeInjection(cycleNodeIndexes, phaseChanges) {
     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.
@@ -90,6 +116,19 @@ function tryBreakFkCycle(cycleNodeIndexes, phaseChanges) {
         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
@@ -100,11 +139,13 @@ function tryBreakFkCycle(cycleNodeIndexes, phaseChanges) {
     const injectedDropsByTableId = new Map();
     const updatedExternalsByTableId = new Map();
     let didMutate = false;
-    for (const dropTable of cycleDropTables) {
+    for (const dropTable of dropTables) {
         const tableId = dropTable.table.stableId;
         const existingExternals = new Set(dropTable.externallyDroppedConstraints);
         let tableMutated = false;
-        for (const fk of iterCrossCycleFkConstraints(dropTable.table.constraints, tableId, cycleTableIds)) {
+        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.
@@ -159,31 +200,37 @@ function tryBreakFkCycle(cycleNodeIndexes, phaseChanges) {
     return rewritten;
 }
 /**
- * Yield FK constraints on `constraints` whose referenced table is also a
- * member of the cycle (i.e. an FK strictly between two cycle DropTables).
+ * Yield FK constraints on `constraints`.
  *
- * 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.
+ * Partition clones are skipped because PostgreSQL drops them when the
+ * parent constraint is dropped.
  */
-function* iterCrossCycleFkConstraints(constraints, ownTableId, cycleTableIds) {
+function* iterFkConstraints(constraints) {
     for (const constraint of 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 === ownTableId)
-            continue;
-        if (!cycleTableIds.has(referencedId))
-            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 —
@@ -267,3 +314,78 @@ function tryBreakPublicationColumnCycle(cycleNodeIndexes, phaseChanges) {
     });
     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;
+    }
+    for (const dropTable of dropTables) {
+        if (!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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supabase/pg-delta",
-  "version": "1.0.0-alpha.23",
+  "version": "1.0.0-alpha.24",
   "description": "PostgreSQL migrations made easy",
   "type": "module",
   "sideEffects": false,

package/src/core/post-diff-normalization.test.ts

@@ -3,6 +3,12 @@ import type { Change } from "./change.types.ts";
 import { CreateIndex } from "./objects/index/changes/index.create.ts";
 import { DropIndex } from "./objects/index/changes/index.drop.ts";
 import { Index, type IndexProps } from "./objects/index/index.model.ts";
+import { CreateSequence } from "./objects/sequence/changes/sequence.create.ts";
+import { DropSequence } from "./objects/sequence/changes/sequence.drop.ts";
+import {
+  Sequence,
+  type SequenceProps,
+} from "./objects/sequence/sequence.model.ts";
 import {
   AlterTableAddConstraint,
   AlterTableChangeOwner,
@@ -304,6 +310,123 @@ describe("normalizePostDiffChanges", () => {
     ).toHaveLength(1);
   });
 
+  describe("DropSequence pruning on replaced tables", () => {
+    const baseSequenceProps: SequenceProps = {
+      schema: "public",
+      name: "project_link_type_id_seq",
+      data_type: "integer",
+      start_value: 1,
+      minimum_value: 1n,
+      maximum_value: 2147483647n,
+      increment: 1,
+      cycle_option: false,
+      cache_size: 1,
+      persistence: "p",
+      owned_by_schema: "public",
+      owned_by_table: "project_link_type",
+      owned_by_column: "id",
+      comment: null,
+      privileges: [],
+      owner: "postgres",
+    };
+
+    test("prunes DropSequence when its OWNED BY table is in replacedTableIds", () => {
+      const replacedTable = new Table({
+        ...baseTableProps,
+        name: "project_link_type",
+        columns: [{ ...integerColumn("id", 1), not_null: true }],
+      });
+      const ownedSequence = new Sequence(baseSequenceProps);
+
+      const dropSequence = new DropSequence({ sequence: ownedSequence });
+      const dropTable = new DropTable({ table: replacedTable });
+      const createTable = new CreateTable({ table: replacedTable });
+
+      const changes: Change[] = [dropSequence, dropTable, createTable];
+
+      const normalized = normalizePostDiffChanges({
+        changes,
+        replacedTableIds: new Set([replacedTable.stableId]),
+      });
+
+      expect(normalized.some((change) => change instanceof DropSequence)).toBe(
+        false,
+      );
+      expect(normalized).toContain(dropTable);
+      expect(normalized).toContain(createTable);
+    });
+
+    test("keeps DropSequence whose OWNED BY table is not in replacedTableIds", () => {
+      const survivingTable = new Table({
+        ...baseTableProps,
+        name: "project_link_type",
+        columns: [{ ...integerColumn("id", 1), not_null: true }],
+      });
+      const ownedSequence = new Sequence(baseSequenceProps);
+
+      const dropSequence = new DropSequence({ sequence: ownedSequence });
+
+      const normalized = normalizePostDiffChanges({
+        changes: [dropSequence],
+        // Different table is being replaced; the sequence's OWNED BY does
+        // not match, so DropSequence must survive.
+        replacedTableIds: new Set([
+          `table:${survivingTable.schema}.unrelated_table` as const,
+        ]),
+      });
+
+      expect(normalized).toContain(dropSequence);
+    });
+
+    test("keeps DropSequence with no OWNED BY when replacedTableIds is non-empty", () => {
+      const orphanSequence = new Sequence({
+        ...baseSequenceProps,
+        owned_by_schema: null,
+        owned_by_table: null,
+        owned_by_column: null,
+      });
+
+      const dropSequence = new DropSequence({ sequence: orphanSequence });
+
+      const normalized = normalizePostDiffChanges({
+        changes: [dropSequence],
+        replacedTableIds: new Set(["table:public.project_link_type" as const]),
+      });
+
+      expect(normalized).toContain(dropSequence);
+    });
+
+    test("keeps unrelated CreateSequence and DropSequence even when its non-owning table is replaced", () => {
+      const sequenceA = new Sequence(baseSequenceProps);
+      const sequenceB = new Sequence({
+        ...baseSequenceProps,
+        name: "unrelated_seq",
+        owned_by_schema: null,
+        owned_by_table: null,
+        owned_by_column: null,
+      });
+
+      const dropOwned = new DropSequence({ sequence: sequenceA });
+      const createUnrelated = new CreateSequence({ sequence: sequenceB });
+
+      const replacedTable = new Table({
+        ...baseTableProps,
+        name: "project_link_type",
+        columns: [{ ...integerColumn("id", 1), not_null: true }],
+      });
+
+      const normalized = normalizePostDiffChanges({
+        changes: [dropOwned, createUnrelated],
+        replacedTableIds: new Set([replacedTable.stableId]),
+      });
+
+      expect(normalized.some((change) => change instanceof DropSequence)).toBe(
+        false,
+      );
+      expect(normalized).toContain(createUnrelated);
+    });
+  });
+
   describe("restoreReplicaIdentityAfterIndexReplace", () => {
     const baseIndexProps: IndexProps = {
       schema: "public",

package/src/core/post-diff-normalization.ts

@@ -1,6 +1,7 @@
 import type { Change } from "./change.types.ts";
 import { CreateIndex } from "./objects/index/changes/index.create.ts";
 import { DropIndex } from "./objects/index/changes/index.drop.ts";
+import { DropSequence } from "./objects/sequence/changes/sequence.drop.ts";
 import {
   AlterTableAddConstraint,
   AlterTableDropColumn,
@@ -24,12 +25,40 @@ function isSupersededByTableReplacement(
   replacedTableIds: ReadonlySet<string>,
 ): boolean {
   if (
-    !(change instanceof AlterTableDropColumn) &&
-    !(change instanceof AlterTableDropConstraint)
+    change instanceof AlterTableDropColumn ||
+    change instanceof AlterTableDropConstraint
   ) {
-    return false;
+    return replacedTableIds.has(change.table.stableId);
   }
-  return replacedTableIds.has(change.table.stableId);
+
+  // `DropSequence(S)` is superseded when S is OWNED BY a column on a table
+  // that `expandReplaceDependencies` has promoted to `DropTable + CreateTable`
+  // in the same plan. PostgreSQL cascade-drops the OWNED BY sequence as part
+  // of the DROP TABLE, so the explicit DROP SEQUENCE is redundant and — more
+  // importantly — closes an unbreakable `DropSequence ↔ DropTable` cycle in
+  // the drop phase via the bidirectional pg_depend edges between the
+  // sequence and its owning column (`column → sequence` for the DEFAULT
+  // nextval reference, `sequence → column` for the OWNED BY auto-dependency).
+  // The alpha.15 short-circuit in `diffSequences.dropped` only suppresses
+  // `DropSequence` when the owning table itself is gone from `branchTables`;
+  // here the table survives in branch and the replacement is added later by
+  // the expander, so this whole-plan rewrite has to happen post-diff.
+  if (change instanceof DropSequence) {
+    if (
+      !change.sequence.owned_by_schema ||
+      !change.sequence.owned_by_table ||
+      !change.sequence.owned_by_column
+    ) {
+      return false;
+    }
+    const ownedByTableId = stableId.table(
+      change.sequence.owned_by_schema,
+      change.sequence.owned_by_table,
+    );
+    return replacedTableIds.has(ownedByTableId);
+  }
+
+  return false;
 }
 
 /**
@@ -219,6 +248,13 @@ function restoreReplicaIdentityAfterIndexReplace(
  *   `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.
+ * - Prunes `DropSequence(S)` changes when `S` is `OWNED BY` a column on a
+ *   table promoted to `DropTable + CreateTable` by the expander. The
+ *   `DROP TABLE` cascade drops the sequence at apply time; emitting an
+ *   explicit `DROP SEQUENCE` in the same drop phase both duplicates the
+ *   cascade and forms an unbreakable `DropSequence ↔ DropTable` cycle on
+ *   the bidirectional pg_depend edges between the sequence and the
+ *   owning column.
  * - Dedupes duplicate `AlterTableAddConstraint` /
  *   `AlterTableValidateConstraint` / `CreateCommentOnConstraint` changes
  *   produced when `diffTables()` and `expandReplaceDependencies()` both

package/src/core/sort/cycle-breakers.test.ts

@@ -62,7 +62,9 @@ function fkConstraint(props: {
   fkColumn: string;
   targetSchema: string;
   targetTable: string;
+  targetColumn?: string;
 }) {
+  const targetColumn = props.targetColumn ?? "id";
   return {
     name: props.name,
     constraint_type: "f" as const,
@@ -78,7 +80,7 @@ function fkConstraint(props: {
     parent_table_schema: null,
     parent_table_name: null,
     key_columns: [props.fkColumn],
-    foreign_key_columns: ["id"],
+    foreign_key_columns: [targetColumn],
     foreign_key_table: props.targetTable,
     foreign_key_schema: props.targetSchema,
     foreign_key_table_is_partition: false,
@@ -91,7 +93,41 @@ function fkConstraint(props: {
     match_type: "s" as const,
     check_expression: null,
     owner: "postgres",
-    definition: `FOREIGN KEY (${props.fkColumn}) REFERENCES ${props.targetSchema}.${props.targetTable}(id)`,
+    definition: `FOREIGN KEY (${props.fkColumn}) REFERENCES ${props.targetSchema}.${props.targetTable}(${targetColumn})`,
+    comment: null,
+  };
+}
+
+function uniqueConstraint(name: string, column: string) {
+  return {
+    name,
+    constraint_type: "u" as const,
+    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: [column],
+    foreign_key_columns: null,
+    foreign_key_table: null,
+    foreign_key_schema: null,
+    foreign_key_table_is_partition: null,
+    foreign_key_parent_schema: null,
+    foreign_key_parent_table: null,
+    foreign_key_effective_schema: null,
+    foreign_key_effective_table: null,
+    on_update: null,
+    on_delete: null,
+    match_type: null,
+    check_expression: null,
+    owner: "postgres",
+    definition: `UNIQUE (${column})`,
     comment: null,
   };
 }
@@ -448,6 +484,204 @@ describe("tryBreakCycleByChangeInjection", () => {
     expect(broken).toBeNull();
   });
 
+  test("publication FK-chain constraint-drop 3-cycle: injects terminal FK drop", () => {
+    // Schema:
+    //   publication p includes labs and posts
+    //   posts.lab_id REFERENCES labs(id)
+    // Diff drops posts and drops labs.unique_lab_id while also removing both
+    // tables from the publication. The FK edge from posts to the terminal
+    // constraint drop forms:
+    //   AlterPublicationDropTables → DropTable(posts)
+    //   DropTable(posts) → AlterTableDropConstraint(labs.unique_lab_id)
+    //   AlterTableDropConstraint(labs.unique_lab_id) → AlterPublicationDropTables
+    const tableLabs = new Table({
+      ...baseTableProps,
+      name: "labs",
+      columns: [{ ...integerColumn("id", 1), not_null: true }],
+      constraints: [uniqueConstraint("unique_lab_id", "id")],
+    });
+    const tablePosts = new Table({
+      ...baseTableProps,
+      name: "posts",
+      columns: [
+        { ...integerColumn("id", 1), not_null: true },
+        integerColumn("lab_id", 2),
+      ],
+      constraints: [
+        fkConstraint({
+          name: "posts_lab_id_fkey",
+          fkColumn: "lab_id",
+          targetSchema: "public",
+          targetTable: "labs",
+        }),
+      ],
+    });
+    const publication = new Publication({
+      name: "p",
+      owner: "postgres",
+      comment: null,
+      all_tables: false,
+      publish_insert: true,
+      publish_update: true,
+      publish_delete: true,
+      publish_truncate: true,
+      publish_via_partition_root: false,
+      tables: [
+        { schema: "public", name: "labs", columns: null, row_filter: null },
+        { schema: "public", name: "posts", columns: null, row_filter: null },
+      ],
+      schemas: [],
+    });
+
+    const terminalDrop = new AlterTableDropConstraint({
+      table: tableLabs,
+      constraint: tableLabs.constraints[0],
+    });
+    const changes: Change[] = [
+      new AlterPublicationDropTables({
+        publication,
+        tables: publication.tables,
+      }),
+      new DropTable({ table: tablePosts }),
+      terminalDrop,
+    ];
+
+    const broken = tryBreakCycleByChangeInjection([0, 1, 2], changes);
+    if (broken === null) throw new Error("expected breaker to fire");
+
+    const injectedDrops = broken.filter(
+      (change): change is AlterTableDropConstraint =>
+        change instanceof AlterTableDropConstraint &&
+        change.table.stableId === tablePosts.stableId,
+    );
+    expect(injectedDrops).toHaveLength(1);
+    expect(injectedDrops[0].constraint.name).toBe("posts_lab_id_fkey");
+
+    const rewrittenPostsDrop = broken.find(
+      (change): change is DropTable =>
+        change instanceof DropTable &&
+        change.table.stableId === tablePosts.stableId,
+    );
+    if (!rewrittenPostsDrop) throw new Error("missing rewritten DropTable");
+    expect(
+      rewrittenPostsDrop.externallyDroppedConstraints.has("posts_lab_id_fkey"),
+    ).toBe(true);
+    expect(broken).toContain(terminalDrop);
+  });
+
+  test("publication FK-chain constraint-drop 4-cycle: injects FK drops along the dropped-table chain", () => {
+    // Schema:
+    //   publication p includes labs, posts, and post_attachments
+    //   post_attachments.post_id REFERENCES posts(id)
+    //   posts.lab_id REFERENCES labs(id)
+    // Diff drops post_attachments and posts, drops labs.unique_lab_id,
+    // and removes all three tables from the publication.
+    const tableLabs = new Table({
+      ...baseTableProps,
+      name: "labs",
+      columns: [{ ...integerColumn("id", 1), not_null: true }],
+      constraints: [uniqueConstraint("unique_lab_id", "id")],
+    });
+    const tablePosts = new Table({
+      ...baseTableProps,
+      name: "posts",
+      columns: [
+        { ...integerColumn("id", 1), not_null: true },
+        integerColumn("lab_id", 2),
+      ],
+      constraints: [
+        fkConstraint({
+          name: "posts_lab_id_fkey",
+          fkColumn: "lab_id",
+          targetSchema: "public",
+          targetTable: "labs",
+        }),
+      ],
+    });
+    const tablePostAttachments = new Table({
+      ...baseTableProps,
+      name: "post_attachments",
+      columns: [
+        { ...integerColumn("id", 1), not_null: true },
+        integerColumn("post_id", 2),
+      ],
+      constraints: [
+        fkConstraint({
+          name: "post_attachments_post_id_fkey",
+          fkColumn: "post_id",
+          targetSchema: "public",
+          targetTable: "posts",
+        }),
+      ],
+    });
+    const publication = new Publication({
+      name: "p",
+      owner: "postgres",
+      comment: null,
+      all_tables: false,
+      publish_insert: true,
+      publish_update: true,
+      publish_delete: true,
+      publish_truncate: true,
+      publish_via_partition_root: false,
+      tables: [
+        { schema: "public", name: "labs", columns: null, row_filter: null },
+        {
+          schema: "public",
+          name: "post_attachments",
+          columns: null,
+          row_filter: null,
+        },
+        { schema: "public", name: "posts", columns: null, row_filter: null },
+      ],
+      schemas: [],
+    });
+
+    const terminalDrop = new AlterTableDropConstraint({
+      table: tableLabs,
+      constraint: tableLabs.constraints[0],
+    });
+    const changes: Change[] = [
+      new AlterPublicationDropTables({
+        publication,
+        tables: publication.tables,
+      }),
+      new DropTable({ table: tablePostAttachments }),
+      new DropTable({ table: tablePosts }),
+      terminalDrop,
+    ];
+
+    const broken = tryBreakCycleByChangeInjection([0, 1, 2, 3], changes);
+    if (broken === null) throw new Error("expected breaker to fire");
+
+    const injectedDropNames = broken
+      .filter(
+        (change): change is AlterTableDropConstraint =>
+          change instanceof AlterTableDropConstraint && change !== terminalDrop,
+      )
+      .map((change) => change.constraint.name)
+      .sort();
+    expect(injectedDropNames).toEqual([
+      "post_attachments_post_id_fkey",
+      "posts_lab_id_fkey",
+    ]);
+
+    for (const [tableId, constraintName] of [
+      [tablePostAttachments.stableId, "post_attachments_post_id_fkey"],
+      [tablePosts.stableId, "posts_lab_id_fkey"],
+    ] as const) {
+      const rewrittenDrop = broken.find(
+        (change): change is DropTable =>
+          change instanceof DropTable && change.table.stableId === tableId,
+      );
+      if (!rewrittenDrop) throw new Error(`missing DropTable for ${tableId}`);
+      expect(
+        rewrittenDrop.externallyDroppedConstraints.has(constraintName),
+      ).toBe(true);
+    }
+    expect(broken).toContain(terminalDrop);
+  });
+
   test("returns null for a cycle with no recognised pattern (e.g. publication-only)", () => {
     // Cycle of `AlterPublicationSetOwner` changes — neither FK nor
     // publication-column shape. Breaker must bail so the formatted

package/src/core/sort/cycle-breakers.ts

@@ -78,6 +78,35 @@ export function tryBreakCycleByChangeInjection(
   );
   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.
@@ -109,6 +138,34 @@ function tryBreakFkCycle(
     cycleDropTables.map((change) => change.table.stableId),
   );
 
+  return injectFkConstraintDropsForDropTables({
+    phaseChanges,
+    dropTables: cycleDropTables,
+    shouldInject: (fk, tableId) =>
+      isCrossCycleFkConstraint(fk, tableId, cycleTableIds),
+  });
+}
+
+type FkConstraintPredicate = (
+  fk: TableConstraintProps,
+  tableId: string,
+) => boolean;
+
+/**
+ * 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,
+}: {
+  phaseChanges: readonly Change[];
+  dropTables: readonly DropTable[];
+  shouldInject: FkConstraintPredicate;
+}): Change[] | null {
   // 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
@@ -120,16 +177,14 @@ function tryBreakFkCycle(
   const updatedExternalsByTableId = new Map<string, Set<string>>();
   let didMutate = false;
 
-  for (const dropTable of cycleDropTables) {
+  for (const dropTable of dropTables) {
     const tableId = dropTable.table.stableId;
     const existingExternals = new Set(dropTable.externallyDroppedConstraints);
     let tableMutated = false;
 
-    for (const fk of iterCrossCycleFkConstraints(
-      dropTable.table.constraints,
-      tableId,
-      cycleTableIds,
-    )) {
+    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.
@@ -187,35 +242,45 @@ function tryBreakFkCycle(
 }
 
 /**
- * Yield FK constraints on `constraints` whose referenced table is also a
- * member of the cycle (i.e. an FK strictly between two cycle DropTables).
+ * Yield FK constraints on `constraints`.
  *
- * 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.
+ * Partition clones are skipped because PostgreSQL drops them when the
+ * parent constraint is dropped.
  */
-function* iterCrossCycleFkConstraints(
+function* iterFkConstraints(
   constraints: readonly TableConstraintProps[],
-  ownTableId: string,
-  cycleTableIds: ReadonlySet<string>,
 ): Iterable<TableConstraintProps> {
   for (const constraint of 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 === ownTableId) continue;
-    if (!cycleTableIds.has(referencedId)) 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: TableConstraintProps,
+  ownTableId: string,
+  cycleTableIds: ReadonlySet<string>,
+): boolean {
+  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 —
@@ -309,3 +374,98 @@ function tryBreakPublicationColumnCycle(
   });
   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: readonly number[],
+  phaseChanges: readonly Change[],
+): Change[] | null {
+  let pubChange: AlterPublicationDropTables | null = null;
+  let terminalConstraintDrop: AlterTableDropConstraint | null = null;
+  const dropTables: DropTable[] = [];
+
+  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<string>(
+    pubChange.tables.map((table) => stableId.table(table.schema, table.name)),
+  );
+  if (!publicationTableIds.has(terminalConstraintDrop.table.stableId)) {
+    return null;
+  }
+
+  for (const dropTable of dropTables) {
+    if (!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: TableConstraintProps,
+  constraintDrop: AlterTableDropConstraint,
+): boolean {
+  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: readonly string[], right: readonly string[]) {
+  if (left.length !== right.length) return false;
+  return left.every((value, index) => value === right[index]);
+}

package/src/core/sort/sort-changes.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 type { PgDepend } from "../depend.ts";
+import { AlterPublicationDropTables } from "../objects/publication/changes/publication.alter.ts";
+import { Publication } from "../objects/publication/publication.model.ts";
+import { AlterTableDropConstraint } from "../objects/table/changes/table.alter.ts";
+import { DropTable } from "../objects/table/changes/table.drop.ts";
+import { Table } from "../objects/table/table.model.ts";
+import { sortChanges } from "./sort-changes.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",
+    data_type_str: "integer",
+    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,
+  };
+}
+
+function fkConstraint(props: {
+  name: string;
+  fkColumn: string;
+  targetTable: string;
+  targetColumn?: string;
+}) {
+  const targetColumn = props.targetColumn ?? "id";
+  return {
+    name: props.name,
+    constraint_type: "f" as const,
+    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: [props.fkColumn],
+    foreign_key_columns: [targetColumn],
+    foreign_key_table: props.targetTable,
+    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: props.targetTable,
+    on_update: "a" as const,
+    on_delete: "a" as const,
+    match_type: "s" as const,
+    check_expression: null,
+    owner: "postgres",
+    definition: `FOREIGN KEY (${props.fkColumn}) REFERENCES public.${props.targetTable}(${targetColumn})`,
+    comment: null,
+  };
+}
+
+function uniqueConstraint(name: string, column: string) {
+  return {
+    name,
+    constraint_type: "u" as const,
+    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: [column],
+    foreign_key_columns: null,
+    foreign_key_table: null,
+    foreign_key_schema: null,
+    foreign_key_table_is_partition: null,
+    foreign_key_parent_schema: null,
+    foreign_key_parent_table: null,
+    foreign_key_effective_schema: null,
+    foreign_key_effective_table: null,
+    on_update: null,
+    on_delete: null,
+    match_type: null,
+    check_expression: null,
+    owner: "postgres",
+    definition: `UNIQUE (${column})`,
+    comment: null,
+  };
+}
+
+function table(
+  name: string,
+  constraints: ConstructorParameters<typeof Table>[0]["constraints"] = [],
+) {
+  return new Table({
+    ...baseTableProps,
+    name,
+    columns: [
+      { ...integerColumn("id", 1), not_null: true },
+      integerColumn("post_id", 2),
+      integerColumn("lab_id", 3),
+    ],
+    constraints,
+  });
+}
+
+async function catalogWithDepends(depends: PgDepend[]) {
+  const base = await createEmptyCatalog(170000, "postgres");
+  return new Catalog({ ...base, depends });
+}
+
+function changeLabel(change: Change) {
+  if (change instanceof AlterTableDropConstraint) {
+    return `${change.constructor.name}:${change.table.name}.${change.constraint.name}`;
+  }
+  if (change instanceof DropTable) {
+    return `${change.constructor.name}:${change.table.name}`;
+  }
+  return change.constructor.name;
+}
+
+describe("sortChanges", () => {
+  test("breaks publication FK-chain constraint-drop cycle with one dropped table", async () => {
+    const labs = table("labs", [uniqueConstraint("unique_lab_id", "id")]);
+    const posts = table("posts", [
+      fkConstraint({
+        name: "posts_lab_id_fkey",
+        fkColumn: "lab_id",
+        targetTable: "labs",
+      }),
+    ]);
+    const publication = new Publication({
+      name: "supabase_realtime",
+      owner: "postgres",
+      comment: null,
+      all_tables: false,
+      publish_insert: true,
+      publish_update: true,
+      publish_delete: true,
+      publish_truncate: true,
+      publish_via_partition_root: false,
+      tables: [
+        {
+          schema: "public",
+          name: "labs",
+          columns: null,
+          row_filter: null,
+        },
+        {
+          schema: "public",
+          name: "posts",
+          columns: null,
+          row_filter: null,
+        },
+      ],
+      schemas: [],
+    });
+    const changes: Change[] = [
+      new AlterPublicationDropTables({
+        publication,
+        tables: publication.tables,
+      }),
+      new DropTable({ table: posts }),
+      new AlterTableDropConstraint({
+        table: labs,
+        constraint: labs.constraints[0],
+      }),
+    ];
+    const mainCatalog = await catalogWithDepends([
+      {
+        dependent_stable_id: "publication:supabase_realtime",
+        referenced_stable_id: "table:public.posts",
+        deptype: "n",
+      },
+      {
+        dependent_stable_id: "constraint:public.posts.posts_lab_id_fkey",
+        referenced_stable_id: "constraint:public.labs.unique_lab_id",
+        deptype: "n",
+      },
+    ]);
+    const branchCatalog = await catalogWithDepends([]);
+
+    const sorted = sortChanges({ mainCatalog, branchCatalog }, changes);
+
+    expect(sorted.map(changeLabel)).toContain(
+      "AlterTableDropConstraint:posts.posts_lab_id_fkey",
+    );
+  });
+
+  test("breaks publication FK-chain constraint-drop cycle in the drop phase", async () => {
+    const labs = table("labs", [uniqueConstraint("unique_lab_id", "id")]);
+    const posts = table("posts", [
+      fkConstraint({
+        name: "posts_lab_id_fkey",
+        fkColumn: "lab_id",
+        targetTable: "labs",
+      }),
+    ]);
+    const postAttachments = table("post_attachments", [
+      fkConstraint({
+        name: "post_attachments_post_id_fkey",
+        fkColumn: "post_id",
+        targetTable: "posts",
+      }),
+    ]);
+    const publication = new Publication({
+      name: "supabase_realtime",
+      owner: "postgres",
+      comment: null,
+      all_tables: false,
+      publish_insert: true,
+      publish_update: true,
+      publish_delete: true,
+      publish_truncate: true,
+      publish_via_partition_root: false,
+      tables: [
+        {
+          schema: "public",
+          name: "labs",
+          columns: null,
+          row_filter: null,
+        },
+        {
+          schema: "public",
+          name: "post_attachments",
+          columns: null,
+          row_filter: null,
+        },
+        {
+          schema: "public",
+          name: "posts",
+          columns: null,
+          row_filter: null,
+        },
+      ],
+      schemas: [],
+    });
+    const changes: Change[] = [
+      new AlterPublicationDropTables({
+        publication,
+        tables: publication.tables,
+      }),
+      new DropTable({ table: postAttachments }),
+      new DropTable({ table: posts }),
+      new AlterTableDropConstraint({
+        table: labs,
+        constraint: labs.constraints[0],
+      }),
+    ];
+    const mainCatalog = await catalogWithDepends([
+      {
+        dependent_stable_id: "publication:supabase_realtime",
+        referenced_stable_id: "table:public.post_attachments",
+        deptype: "n",
+      },
+      {
+        dependent_stable_id:
+          "constraint:public.post_attachments.post_attachments_post_id_fkey",
+        referenced_stable_id: "column:public.posts.id",
+        deptype: "n",
+      },
+      {
+        dependent_stable_id: "constraint:public.posts.posts_lab_id_fkey",
+        referenced_stable_id: "constraint:public.labs.unique_lab_id",
+        deptype: "n",
+      },
+    ]);
+    const branchCatalog = await catalogWithDepends([]);
+
+    const sorted = sortChanges({ mainCatalog, branchCatalog }, changes);
+
+    expect(sorted.map(changeLabel)).toContain(
+      "AlterTableDropConstraint:post_attachments.post_attachments_post_id_fkey",
+    );
+    expect(sorted.map(changeLabel)).toContain(
+      "AlterTableDropConstraint:posts.posts_lab_id_fkey",
+    );
+  });
+});