@supabase/pg-delta 1.0.0-alpha.27 → 1.0.0-alpha.29

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

@@ -30,6 +30,71 @@ import {
 import type { ViewChange } from "./changes/view.types.ts";
 import type { View } from "./view.model.ts";
 
+export function buildCreateViewChanges(
+  ctx: Pick<
+    ObjectDiffContext,
+    "version" | "currentUser" | "defaultPrivilegeState"
+  >,
+  view: View,
+): ViewChange[] {
+  const changes: ViewChange[] = [new CreateView({ view })];
+
+  // OWNER: If the view should be owned by someone other than the current user,
+  // emit ALTER VIEW ... OWNER TO after creation
+  if (view.owner !== ctx.currentUser) {
+    changes.push(new AlterViewChangeOwner({ view, owner: view.owner }));
+  }
+
+  if (view.comment !== null) {
+    changes.push(new CreateCommentOnView({ view }));
+  }
+
+  for (const label of view.security_labels) {
+    changes.push(new CreateSecurityLabelOnView({ view, securityLabel: label }));
+  }
+
+  // PRIVILEGES: For created objects, compare against default privileges state
+  // The migration script will run ALTER DEFAULT PRIVILEGES before CREATE (via constraint spec),
+  // so objects are created with the default privileges state in effect.
+  // We compare default privileges against desired privileges to generate REVOKE/GRANT statements
+  // needed to reach the final desired state.
+  const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(
+    ctx.currentUser,
+    "view",
+    view.schema ?? "",
+  );
+  const creatorFilteredDefaults =
+    view.owner !== ctx.currentUser
+      ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+      : effectiveDefaults;
+  const desiredPrivileges = view.privileges;
+  // Filter out owner privileges - owner always has ALL privileges implicitly
+  // and shouldn't be compared. Use the view owner as the reference.
+  const privilegeResults = diffPrivileges(
+    creatorFilteredDefaults,
+    desiredPrivileges,
+    view.owner,
+  );
+
+  changes.push(
+    ...(emitColumnPrivilegeChanges(
+      privilegeResults,
+      view,
+      view,
+      "view",
+      {
+        Grant: GrantViewPrivileges,
+        Revoke: RevokeViewPrivileges,
+        RevokeGrantOption: RevokeGrantOptionViewPrivileges,
+      },
+      effectiveDefaults,
+      ctx.version,
+    ) as ViewChange[]),
+  );
+
+  return changes;
+}
+
 /**
  * Diff two sets of views from main and branch catalogs.
  *
@@ -49,67 +114,9 @@ export function diffViews(
   const { created, dropped, altered } = diffObjects(main, branch);
 
   const changes: ViewChange[] = [];
-  const appendCreateViewChanges = (view: View) => {
-    changes.push(new CreateView({ view }));
-
-    // OWNER: If the view should be owned by someone other than the current user,
-    // emit ALTER VIEW ... OWNER TO after creation
-    if (view.owner !== ctx.currentUser) {
-      changes.push(new AlterViewChangeOwner({ view, owner: view.owner }));
-    }
-
-    if (view.comment !== null) {
-      changes.push(new CreateCommentOnView({ view }));
-    }
-
-    for (const label of view.security_labels) {
-      changes.push(
-        new CreateSecurityLabelOnView({ view, securityLabel: label }),
-      );
-    }
-
-    // PRIVILEGES: For created objects, compare against default privileges state
-    // The migration script will run ALTER DEFAULT PRIVILEGES before CREATE (via constraint spec),
-    // so objects are created with the default privileges state in effect.
-    // We compare default privileges against desired privileges to generate REVOKE/GRANT statements
-    // needed to reach the final desired state.
-    const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(
-      ctx.currentUser,
-      "view",
-      view.schema ?? "",
-    );
-    const creatorFilteredDefaults =
-      view.owner !== ctx.currentUser
-        ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
-        : effectiveDefaults;
-    const desiredPrivileges = view.privileges;
-    // Filter out owner privileges - owner always has ALL privileges implicitly
-    // and shouldn't be compared. Use the view owner as the reference.
-    const privilegeResults = diffPrivileges(
-      creatorFilteredDefaults,
-      desiredPrivileges,
-      view.owner,
-    );
-
-    changes.push(
-      ...(emitColumnPrivilegeChanges(
-        privilegeResults,
-        view,
-        view,
-        "view",
-        {
-          Grant: GrantViewPrivileges,
-          Revoke: RevokeViewPrivileges,
-          RevokeGrantOption: RevokeGrantOptionViewPrivileges,
-        },
-        effectiveDefaults,
-        ctx.version,
-      ) as ViewChange[]),
-    );
-  };
 
   for (const viewId of created) {
-    appendCreateViewChanges(branch[viewId]);
+    changes.push(...buildCreateViewChanges(ctx, branch[viewId]));
   }
 
   for (const viewId of dropped) {
@@ -153,7 +160,7 @@ export function diffViews(
       )
     ) {
       changes.push(new DropView({ view: mainView }));
-      appendCreateViewChanges(branchView);
+      changes.push(...buildCreateViewChanges(ctx, branchView));
     } else if (nonAlterablePropsChanged) {
       // Replace the entire view using CREATE OR REPLACE to avoid drop when possible
       changes.push(new CreateView({ view: branchView, orReplace: true }));

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

@@ -682,6 +682,132 @@ describe("tryBreakCycleByChangeInjection", () => {
     expect(broken).toContain(terminalDrop);
   });
 
+  test("publication FK-chain 4-cycle with partial publication membership: injects FK drops", () => {
+    // Sentry SUPABASE-API-7RS / CLI-1605. Same shape as the previous test,
+    // but the publication only contains the terminal constraint's table
+    // (trades) and the first dropped table (public_offering_events) — the
+    // intermediate FK-chain table (trade_status_events) was never a member
+    // of supabase_realtime. The breaker must not require every dropped
+    // table in the cycle to be a publication member; the pub edge only
+    // needs one of them.
+    //
+    // Schema:
+    //   trades.trade_id UNIQUE (trades_trade_id_key) — table survives
+    //   trade_status_events.trade_id REFERENCES trades(trade_id)
+    //   public_offering_events.source_event_id REFERENCES trade_status_events(id)
+    //   publication supabase_realtime: trades, public_offering_events only
+    const tableTrades = new Table({
+      ...baseTableProps,
+      name: "trades",
+      columns: [
+        { ...integerColumn("id", 1), not_null: true },
+        { ...integerColumn("trade_id", 2), not_null: true },
+      ],
+      constraints: [uniqueConstraint("trades_trade_id_key", "trade_id")],
+    });
+    const tableTradeStatusEvents = new Table({
+      ...baseTableProps,
+      name: "trade_status_events",
+      columns: [
+        { ...integerColumn("id", 1), not_null: true },
+        integerColumn("trade_id", 2),
+      ],
+      constraints: [
+        fkConstraint({
+          name: "trade_status_events_trade_id_fkey",
+          fkColumn: "trade_id",
+          targetSchema: "public",
+          targetTable: "trades",
+          targetColumn: "trade_id",
+        }),
+      ],
+    });
+    const tablePublicOfferingEvents = new Table({
+      ...baseTableProps,
+      name: "public_offering_events",
+      columns: [
+        { ...integerColumn("id", 1), not_null: true },
+        integerColumn("source_event_id", 2),
+      ],
+      constraints: [
+        fkConstraint({
+          name: "public_offering_events_source_event_id_fkey",
+          fkColumn: "source_event_id",
+          targetSchema: "public",
+          targetTable: "trade_status_events",
+        }),
+      ],
+    });
+    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: "public_offering_events",
+          columns: null,
+          row_filter: null,
+        },
+        { schema: "public", name: "trades", columns: null, row_filter: null },
+      ],
+      schemas: [],
+    });
+
+    const terminalDrop = new AlterTableDropConstraint({
+      table: tableTrades,
+      constraint: tableTrades.constraints[0],
+    });
+    const changes: Change[] = [
+      new AlterPublicationDropTables({
+        publication,
+        tables: publication.tables,
+      }),
+      new DropTable({ table: tablePublicOfferingEvents }),
+      new DropTable({ table: tableTradeStatusEvents }),
+      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([
+      "public_offering_events_source_event_id_fkey",
+      "trade_status_events_trade_id_fkey",
+    ]);
+
+    for (const [tableId, constraintName] of [
+      [
+        tablePublicOfferingEvents.stableId,
+        "public_offering_events_source_event_id_fkey",
+      ],
+      [tableTradeStatusEvents.stableId, "trade_status_events_trade_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

@@ -418,8 +418,18 @@ function tryBreakPublicationFkConstraintDropCycle(
     return null;
   }
 
-  for (const dropTable of dropTables) {
-    if (!publicationTableIds.has(dropTable.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(

package/src/core/sort/graph-builder.ts

@@ -156,6 +156,12 @@ export function buildGraphData(
         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/src/core/sort/sort-changes.test.ts

@@ -4,9 +4,15 @@ 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 {
+  AlterTableAlterColumnType,
+  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 { CreateView } from "../objects/view/changes/view.create.ts";
+import { DropView } from "../objects/view/changes/view.drop.ts";
+import { View } from "../objects/view/view.model.ts";
 import { sortChanges } from "./sort-changes.ts";
 
 const baseTableProps = {
@@ -142,6 +148,29 @@ function table(
   });
 }
 
+function view(name: string, columns = [integerColumn("id", 1)]) {
+  return new View({
+    schema: "public",
+    name,
+    definition: "SELECT id FROM users",
+    row_security: false,
+    force_row_security: false,
+    has_indexes: false,
+    has_rules: true,
+    has_triggers: false,
+    has_subclasses: false,
+    is_populated: true,
+    replica_identity: "d",
+    is_partition: false,
+    options: null,
+    partition_bound: null,
+    owner: "postgres",
+    comment: null,
+    columns,
+    privileges: [],
+  });
+}
+
 async function catalogWithDepends(depends: PgDepend[]) {
   const base = await createEmptyCatalog(170000, "postgres");
   // oxlint-disable-next-line typescript/no-misused-spread
@@ -159,6 +188,49 @@ function changeLabel(change: Change) {
 }
 
 describe("sortChanges", () => {
+  test("orders dependent view drop before drop-phase column type rewrite", async () => {
+    const branchTable = table("users");
+    const mainColumn = {
+      ...integerColumn("age", 4),
+      data_type: "numeric",
+      data_type_str: "numeric",
+    };
+    const branchColumn = integerColumn("age", 4);
+    const dependentView = view("user_ages", [
+      integerColumn("id", 1),
+      mainColumn,
+    ]);
+    const recreatedView = view("user_ages", [
+      integerColumn("id", 1),
+      branchColumn,
+    ]);
+    const changes: Change[] = [
+      new AlterTableAlterColumnType({
+        table: branchTable,
+        column: branchColumn,
+        previousColumn: mainColumn,
+      }),
+      new DropView({ view: dependentView }),
+      new CreateView({ view: recreatedView }),
+    ];
+    const mainCatalog = await catalogWithDepends([
+      {
+        dependent_stable_id: dependentView.stableId,
+        referenced_stable_id: "column:public.users.age",
+        deptype: "n",
+      },
+    ]);
+    const branchCatalog = await catalogWithDepends([]);
+
+    const sorted = sortChanges({ mainCatalog, branchCatalog }, changes);
+
+    expect(sorted.map(changeLabel)).toEqual([
+      "DropView",
+      "AlterTableAlterColumnType",
+      "CreateView",
+    ]);
+  });
+
   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", [