@supabase/pg-delta 1.0.0-alpha.17 → 1.0.0-alpha.19

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

@@ -1,4 +1,5 @@
-import { AlterTableDropColumn, AlterTableDropConstraint, } from "./objects/table/changes/table.alter.js";
+import { AlterTableAddConstraint, AlterTableDropColumn, AlterTableDropConstraint, AlterTableValidateConstraint, } from "./objects/table/changes/table.alter.js";
+import { CreateCommentOnConstraint } from "./objects/table/changes/table.comment.js";
 import { DropTable } from "./objects/table/changes/table.drop.js";
 import { stableId } from "./objects/utils.js";
 function constraintStableId(table, constraintName) {
@@ -33,6 +34,63 @@ function isSupersededByTableReplacement(change, replacedTableIds) {
     }
     return replacedTableIds.has(change.table.stableId);
 }
+/**
+ * Drop earlier duplicates of `AlterTableAddConstraint` /
+ * `AlterTableValidateConstraint` / `CreateCommentOnConstraint` targeting
+ * replaced tables, keeping only the last occurrence of each
+ * `(changeType, table.stableId, constraint.name)`.
+ *
+ * When `expandReplaceDependencies()` promotes a table to a full
+ * `DropTable + CreateTable` pair, it also emits one
+ * `AlterTableAddConstraint` (plus optional `VALIDATE CONSTRAINT` /
+ * `COMMENT ON CONSTRAINT`) per branch constraint. If `diffTables()` already
+ * emitted the same change for a shape flip or a new constraint on that
+ * table, the plan ends up with two identical `ALTER TABLE ... ADD
+ * CONSTRAINT ...` statements and PostgreSQL fails at apply time with
+ * `constraint "..." for relation "..." already exists`. Because
+ * `expandReplaceDependencies()` appends its additions after the original
+ * `diffTables()` output, the last occurrence is the expansion's emission —
+ * keeping it preserves correctness while removing the duplicate.
+ */
+function dropReplacedTableDuplicateConstraintChanges(changes, replacedTableIds) {
+    if (replacedTableIds.size === 0)
+        return changes;
+    const keyFor = (change) => {
+        if (!(change instanceof AlterTableAddConstraint) &&
+            !(change instanceof AlterTableValidateConstraint) &&
+            !(change instanceof CreateCommentOnConstraint)) {
+            return null;
+        }
+        if (!replacedTableIds.has(change.table.stableId))
+            return null;
+        const tag = change instanceof AlterTableAddConstraint
+            ? "add"
+            : change instanceof AlterTableValidateConstraint
+                ? "validate"
+                : "comment";
+        return `${tag}:${constraintStableId(change.table, change.constraint.name)}`;
+    };
+    const seen = new Set();
+    const reversedKept = [];
+    let mutated = false;
+    // Walk backwards: the first encounter of each key corresponds to its LAST
+    // occurrence in the original order. `expandReplaceDependencies()` appends
+    // additions after the original changes, so "last wins" keeps the
+    // expansion's emission and drops the earlier diffTables duplicate.
+    for (let i = changes.length - 1; i >= 0; i--) {
+        const change = changes[i];
+        const key = keyFor(change);
+        if (key !== null) {
+            if (seen.has(key)) {
+                mutated = true;
+                continue;
+            }
+            seen.add(key);
+        }
+        reversedKept.push(change);
+    }
+    return mutated ? reversedKept.reverse() : changes;
+}
 function collectExplicitConstraintDropIds(changes) {
     const explicitConstraintDropIds = new Set();
     for (const change of changes) {
@@ -59,6 +117,13 @@ function hasSameEntries(left, right) {
  * - If replace expansion added `DropTable(T)+CreateTable(T)`, targeted
  *   `AlterTableDropColumn(T.*)` / `AlterTableDropConstraint(T.*)` changes are
  *   redundant and create an unbreakable drop-phase cycle, so we elide them.
+ * - When the same `DropTable+CreateTable` pair is present, the expansion
+ *   also emits one `AlterTableAddConstraint` / `AlterTableValidateConstraint`
+ *   / `CreateCommentOnConstraint` per branch constraint, which may collide
+ *   with the same change already emitted by `diffTables()` (for example on a
+ *   shape flip or a new constraint). We dedupe these keeping only the last
+ *   occurrence so the expansion's emission survives and the diffTables
+ *   duplicate is removed.
  * - If two dropped tables reference each other via FK, we insert dedicated
  *   `AlterTableDropConstraint` changes and teach the paired `DropTable`
  *   changes not to claim those FK stable IDs.
@@ -67,9 +132,10 @@ function hasSameEntries(left, right) {
  * in the corresponding `diff*` function instead of this pass.
  */
 export function normalizePostDiffCycles({ changes, mainCatalog, replacedTableIds = new Set(), }) {
+    const dedupedChanges = dropReplacedTableDuplicateConstraintChanges(changes, replacedTableIds);
     const structurallyNormalizedChanges = replacedTableIds.size === 0
-        ? changes
-        : changes.filter((change) => !isSupersededByTableReplacement(change, replacedTableIds));
+        ? dedupedChanges
+        : dedupedChanges.filter((change) => !isSupersededByTableReplacement(change, replacedTableIds));
     const dropTableChanges = structurallyNormalizedChanges.filter((change) => change instanceof DropTable);
     if (dropTableChanges.length < 2) {
         return structurallyNormalizedChanges;

package/package.json

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

package/src/core/catalog.snapshot.test.ts

@@ -428,6 +428,8 @@ describe("catalog snapshot serde", () => {
       with_check_expression: null,
       owner: "postgres",
       comment: null,
+      referenced_relations: [],
+      referenced_procedures: [],
     });
 
     const target = new Catalog({

package/src/core/expand-replace-dependencies.test.ts

@@ -3,6 +3,9 @@ import { Catalog, createEmptyCatalog } from "./catalog.model.ts";
 import type { Change } from "./change.types.ts";
 import { expandReplaceDependencies } from "./expand-replace-dependencies.ts";
 import { DefaultPrivilegeState } from "./objects/base.default-privileges.ts";
+import { CreateProcedure } from "./objects/procedure/changes/procedure.create.ts";
+import { DropProcedure } from "./objects/procedure/changes/procedure.drop.ts";
+import { Procedure } from "./objects/procedure/procedure.model.ts";
 import { CreateSequence } from "./objects/sequence/changes/sequence.create.ts";
 import { DropSequence } from "./objects/sequence/changes/sequence.drop.ts";
 import { diffSequences } from "./objects/sequence/sequence.diff.ts";
@@ -22,6 +25,9 @@ import { Table } from "./objects/table/table.model.ts";
 import { CreateEnum } from "./objects/type/enum/changes/enum.create.ts";
 import { DropEnum } from "./objects/type/enum/changes/enum.drop.ts";
 import { Enum } from "./objects/type/enum/enum.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";
 
 function mockChange(overrides: {
   creates?: string[];
@@ -330,6 +336,7 @@ describe("expandReplaceDependencies", () => {
         validated: true,
         is_local: true,
         no_inherit: false,
+        is_temporal: false,
         is_partition_clone: false,
         parent_constraint_schema: null,
         parent_constraint_name: null,
@@ -431,4 +438,115 @@ describe("expandReplaceDependencies", () => {
     expect(expanded.changes).toContain(preExistingGrant);
     expect(expanded.replacedTableIds.has("table:public.parents")).toBe(false);
   });
+
+  test("promotes dependent view when a procedure's parameter types change", async () => {
+    // Procedure stableIds are signature-qualified, so a parameter-type change
+    // produces different stableIds in `createdIds` and `droppedIds`. The
+    // expander must still treat the (schema, name)-matched pair as a replace
+    // root so a dependent view is promoted from `CREATE OR REPLACE VIEW` to
+    // `DROP VIEW` + `CREATE VIEW` (otherwise `DROP FUNCTION` fails with
+    // "cannot drop function because other objects depend on it").
+    const baseline = await createEmptyCatalog(170000, "postgres");
+    const procedureBase = {
+      schema: "public",
+      name: "format_id",
+      kind: "f" as const,
+      return_type: "text",
+      return_type_schema: "pg_catalog",
+      language: "sql",
+      security_definer: false,
+      volatility: "i" as const,
+      parallel_safety: "u" as const,
+      execution_cost: 100,
+      result_rows: 0,
+      is_strict: false,
+      leakproof: false,
+      returns_set: false,
+      argument_count: 1,
+      argument_default_count: 0,
+      argument_names: ["id"],
+      all_argument_types: null,
+      argument_modes: null,
+      argument_defaults: null,
+      source_code: "SELECT 'id:' || id::text",
+      binary_path: null,
+      sql_body: null,
+      config: null,
+      owner: "postgres",
+      comment: null,
+      privileges: [],
+    };
+    const mainProcedure = new Procedure({
+      ...procedureBase,
+      argument_types: ["int4"],
+      definition: "CREATE FUNCTION public.format_id(id integer) ...",
+    });
+    const branchProcedure = new Procedure({
+      ...procedureBase,
+      argument_types: ["int8"],
+      definition: "CREATE FUNCTION public.format_id(id bigint) ...",
+    });
+    const viewBase = {
+      schema: "public",
+      name: "items_formatted",
+      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,
+      owner: "postgres",
+      comment: null,
+      columns: [],
+      privileges: [],
+    };
+    const mainView = new View({
+      ...viewBase,
+      definition: "SELECT public.format_id(id) FROM public.items",
+    });
+    const branchView = new View({
+      ...viewBase,
+      definition: "SELECT public.format_id(id::bigint) FROM public.items",
+    });
+
+    const changes: Change[] = [
+      new DropProcedure({ procedure: mainProcedure }),
+      new CreateProcedure({ procedure: branchProcedure }),
+      // view.diff emits this because pg_get_viewdef text differs after the
+      // underlying function signature changes.
+      new CreateView({ view: branchView, orReplace: true }),
+    ];
+
+    const mainCatalog = new Catalog({
+      ...baseline,
+      procedures: { [mainProcedure.stableId]: mainProcedure },
+      views: { [mainView.stableId]: mainView },
+      depends: [
+        {
+          dependent_stable_id: mainView.stableId,
+          referenced_stable_id: mainProcedure.stableId,
+          deptype: "n",
+        },
+      ],
+    });
+    const branchCatalog = new Catalog({
+      ...baseline,
+      procedures: { [branchProcedure.stableId]: branchProcedure },
+      views: { [branchView.stableId]: branchView },
+      depends: [],
+    });
+
+    const expanded = expandReplaceDependencies({
+      changes,
+      mainCatalog,
+      branchCatalog,
+    });
+
+    expect(expanded.changes.some((c) => c instanceof DropView)).toBe(true);
+  });
 });

package/src/core/expand-replace-dependencies.ts

@@ -2,6 +2,8 @@ import type { Catalog } from "./catalog.model.ts";
 import type { Change } from "./change.types.ts";
 import { CreateDomain } from "./objects/domain/changes/domain.create.ts";
 import { DropDomain } from "./objects/domain/changes/domain.drop.ts";
+import { CreateIndex } from "./objects/index/changes/index.create.ts";
+import { DropIndex } from "./objects/index/changes/index.drop.ts";
 import { CreateMaterializedView } from "./objects/materialized-view/changes/materialized-view.create.ts";
 import { DropMaterializedView } from "./objects/materialized-view/changes/materialized-view.drop.ts";
 import { CreateProcedure } from "./objects/procedure/changes/procedure.create.ts";
@@ -34,6 +36,12 @@ type ResolvedObject =
       main: Catalog["views"][string];
       branch: Catalog["views"][string];
     }
+  | {
+      kind: "index";
+      main: Catalog["indexes"][string];
+      branch: Catalog["indexes"][string];
+      branchIndexableObject: Catalog["indexableObjects"][string] | undefined;
+    }
   | {
       kind: "materialized_view";
       main: Catalog["materializedViews"][string];
@@ -102,6 +110,25 @@ export function expandReplaceDependencies({
     }
   }
 
+  // Procedure stableIds are signature-qualified
+  // (`procedure:schema.name(argtypes)`), so a function whose parameter types
+  // change has different ids in `createdIds` and `droppedIds` and would not
+  // appear in the intersection above. Treat any dropped procedure whose
+  // `(schema, name)` matches a created procedure as a replace root so
+  // dependents referencing the old signature via pg_depend get promoted to
+  // DROP+CREATE.
+  const createdProcedureNames = new Set<string>();
+  for (const id of createdIds) {
+    const key = parseProcedureSchemaName(id);
+    if (key) createdProcedureNames.add(key);
+  }
+  for (const id of droppedIds) {
+    const key = parseProcedureSchemaName(id);
+    if (key && createdProcedureNames.has(key)) {
+      replaceRoots.add(id);
+    }
+  }
+
   if (replaceRoots.size === 0) {
     return {
       changes,
@@ -259,6 +286,13 @@ function isOwnedSequenceColumnDependency(
   );
 }
 
+function parseProcedureSchemaName(stableId: string): string | null {
+  if (!stableId.startsWith("procedure:")) return null;
+  const paren = stableId.indexOf("(");
+  if (paren === -1) return null;
+  return stableId.slice("procedure:".length, paren);
+}
+
 function normalizeDependentId(dependentId: string): string | null {
   let id = dependentId;
 
@@ -320,6 +354,20 @@ function resolveObjectForStableId(
     return main && branch ? { kind: "materialized_view", main, branch } : null;
   }
 
+  if (stableId.startsWith("index:")) {
+    const main = mainCatalog.indexes[stableId];
+    const branch = branchCatalog.indexes[stableId];
+    return main && branch
+      ? {
+          kind: "index",
+          main,
+          branch,
+          branchIndexableObject:
+            branchCatalog.indexableObjects[branch.tableStableId],
+        }
+      : null;
+  }
+
   if (stableId.startsWith("procedure:")) {
     const main = mainCatalog.procedures[stableId];
     const branch = branchCatalog.procedures[stableId];
@@ -421,6 +469,36 @@ function buildReplaceChanges(
           ? [new CreateMaterializedView({ materializedView: resolved.branch })]
           : []),
       ];
+    case "index":
+      // Constraint-owned, primary, and partition-attached indexes are managed
+      // by the owning constraint or parent-index DDL, not standalone
+      // CREATE INDEX / DROP INDEX. The `case "table":` branch above already
+      // recreates constraints via AlterTableAddConstraint; emitting a
+      // standalone drop/create here would fail in PostgreSQL
+      // ("cannot drop index ... because constraint ... requires it") or
+      // duplicate the index the constraint recreates. Skip matches
+      // diffIndexes (packages/pg-delta/src/core/objects/index/index.diff.ts).
+      if (
+        resolved.main.is_owned_by_constraint ||
+        resolved.main.is_primary ||
+        resolved.main.is_index_partition ||
+        resolved.branch.is_owned_by_constraint ||
+        resolved.branch.is_primary ||
+        resolved.branch.is_index_partition
+      ) {
+        return null;
+      }
+      return [
+        ...(addDrop ? [new DropIndex({ index: resolved.main })] : []),
+        ...(addCreate
+          ? [
+              new CreateIndex({
+                index: resolved.branch,
+                indexableObject: resolved.branchIndexableObject,
+              }),
+            ]
+          : []),
+      ];
     case "procedure":
       return [
         ...(addDrop ? [new DropProcedure({ procedure: resolved.main })] : []),

package/src/core/objects/index/index.model.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, test } from "bun:test";
+import type { Pool } from "pg";
+import { extractIndexes, Index } from "./index.model.ts";
+
+// Minimal fields required by indexPropsSchema; individual tests override the
+// fields relevant to each scenario.
+const baseRow = {
+  schema: "public",
+  table_name: '"users"',
+  storage_params: [] as string[],
+  statistics_target: [] as number[],
+  index_type: "btree",
+  tablespace: null,
+  is_unique: false,
+  is_primary: false,
+  is_exclusion: false,
+  nulls_not_distinct: false,
+  immediate: true,
+  is_clustered: false,
+  is_replica_identity: false,
+  key_columns: [1],
+  column_collations: [null],
+  operator_classes: ["default"],
+  column_options: [0],
+  index_expressions: null,
+  partial_predicate: null,
+  is_owned_by_constraint: false,
+  table_relkind: "r" as const,
+  is_partitioned_index: false,
+  is_index_partition: false,
+  parent_index_name: null,
+  comment: null,
+  owner: "postgres",
+};
+
+const mockPool = (rows: unknown[]): Pool =>
+  ({ query: async () => ({ rows }) }) as unknown as Pool;
+
+describe("extractIndexes", () => {
+  test("skips rows where pg_get_indexdef returned NULL", async () => {
+    const indexes = await extractIndexes(
+      mockPool([
+        {
+          ...baseRow,
+          name: '"good_idx"',
+          definition: "CREATE INDEX good_idx ON users (id)",
+        },
+        { ...baseRow, name: '"orphan_idx"', definition: null },
+      ]),
+    );
+
+    expect(indexes).toHaveLength(1);
+    expect(indexes[0]).toBeInstanceOf(Index);
+    expect(indexes[0]?.name).toBe('"good_idx"');
+    expect(indexes[0]?.definition).toBe("CREATE INDEX good_idx ON users (id)");
+  });
+
+  test("does not throw ZodError when the only row has a null definition", async () => {
+    await expect(
+      extractIndexes(
+        mockPool([{ ...baseRow, name: '"orphan"', definition: null }]),
+      ),
+    ).resolves.toEqual([]);
+  });
+
+  test("returns all indexes when every row has a valid definition", async () => {
+    const indexes = await extractIndexes(
+      mockPool([
+        {
+          ...baseRow,
+          name: '"a"',
+          definition: "CREATE INDEX a ON users (id)",
+        },
+        {
+          ...baseRow,
+          name: '"b"',
+          definition: "CREATE INDEX b ON users (id)",
+        },
+      ]),
+    );
+    expect(indexes.map((i) => i.name)).toEqual(['"a"', '"b"']);
+  });
+});

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

@@ -40,6 +40,16 @@ const indexPropsSchema = z.object({
   owner: z.string(),
 });
 
+// pg_get_indexdef(oid, colno, pretty) invokes pg_get_indexdef_worker with
+// missing_ok = true, so it can return NULL when any internal system-cache lookup
+// fails (race with concurrent DROP, role visibility edge cases, orphaned index
+// metadata, recovery transients). An unreadable index cannot be diffed, so we
+// accept NULL here and filter the row out with a debug log instead of crashing
+// the whole catalog extraction.
+const indexRowSchema = indexPropsSchema.extend({
+  definition: z.string().nullable(),
+});
+
 /**
  * All properties exposed by CREATE INDEX statement are included in diff output.
  * https://www.postgresql.org/docs/current/sql-createindex.html
@@ -362,9 +372,8 @@ export async function extractIndexes(pool: Pool): Promise<Index[]> {
 
       order by 1, 2
   `);
-  // Validate and parse each row using the Zod schema
-  const validatedRows = indexRows.map((row: unknown) =>
-    indexPropsSchema.parse(row),
-  );
+  const validatedRows = indexRows
+    .map((row: unknown) => indexRowSchema.parse(row))
+    .filter((row): row is IndexProps => row.definition !== null);
   return validatedRows.map((row: IndexProps) => new Index(row));
 }

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

@@ -144,12 +144,13 @@ describe.concurrent("procedure.diff", () => {
     expect(changes[0]).toBeInstanceOf(AlterProcedureSetParallel);
   });
 
-  test("create or replace when non-alterable property changes", () => {
+  test("create or replace when body-only non-alterable property changes", () => {
+    // Changing only the language (or source) is OR-REPLACE-safe: no DROP needed.
     const main = new Procedure(base);
     const branch = new Procedure({
       ...base,
-      return_type: "text",
       language: "plpgsql",
+      source_code: "BEGIN RETURN 1; END",
     });
     const changes = diffProcedures(
       testContext,
@@ -158,6 +159,82 @@ describe.concurrent("procedure.diff", () => {
     );
     expect(changes).toHaveLength(1);
     expect(changes[0]).toBeInstanceOf(CreateProcedure);
+    expect((changes[0] as CreateProcedure).orReplace).toBe(true);
+  });
+
+  test("drop + create when return type changes", () => {
+    // `CREATE OR REPLACE FUNCTION` cannot change the return type.
+    const main = new Procedure(base);
+    const branch = new Procedure({ ...base, return_type: "text" });
+    const changes = diffProcedures(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(DropProcedure);
+    expect(changes[1]).toBeInstanceOf(CreateProcedure);
+    expect((changes[1] as CreateProcedure).orReplace).toBe(false);
+  });
+
+  test("drop + create when parameter name changes but type is identical", () => {
+    // Same argument_types means same stableId (altered path), but
+    // `CREATE OR REPLACE` rejects changing an IN parameter's name.
+    const main = new Procedure({
+      ...base,
+      argument_count: 1,
+      argument_names: ["p"],
+      argument_types: ["int4"],
+      all_argument_types: ["int4"],
+      argument_modes: ["i"],
+    });
+    const branch = new Procedure({
+      ...base,
+      argument_count: 1,
+      argument_names: ["renamed"],
+      argument_types: ["int4"],
+      all_argument_types: ["int4"],
+      argument_modes: ["i"],
+    });
+    const changes = diffProcedures(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(DropProcedure);
+    expect(changes[1]).toBeInstanceOf(CreateProcedure);
+    expect((changes[1] as CreateProcedure).orReplace).toBe(false);
+  });
+
+  test("drop + create when a parameter default is removed", () => {
+    // `CREATE OR REPLACE` rejects removing parameter defaults.
+    const main = new Procedure({
+      ...base,
+      argument_count: 1,
+      argument_default_count: 1,
+      argument_names: ["p"],
+      argument_types: ["int4"],
+      all_argument_types: ["int4"],
+      argument_modes: ["i"],
+      argument_defaults: "0",
+    });
+    const branch = new Procedure({
+      ...base,
+      argument_count: 1,
+      argument_default_count: 0,
+      argument_names: ["p"],
+      argument_types: ["int4"],
+      all_argument_types: ["int4"],
+      argument_modes: ["i"],
+      argument_defaults: null,
+    });
+    const changes = diffProcedures(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(DropProcedure);
+    expect(changes[1]).toBeInstanceOf(CreateProcedure);
+    expect((changes[1] as CreateProcedure).orReplace).toBe(false);
   });
 
   test("create or replace also emits a procedure comment when the comment changes", () => {
@@ -183,4 +260,25 @@ describe.concurrent("procedure.diff", () => {
       changes.some((change) => change instanceof CreateCommentOnProcedure),
     ).toBe(true);
   });
+
+  test("signature change re-emits comment even when comment itself is unchanged", () => {
+    // DROP destroys the old comment, so the new CREATE path must re-emit it.
+    const main = new Procedure({ ...base, comment: "hello" });
+    const branch = new Procedure({
+      ...base,
+      return_type: "text",
+      comment: "hello",
+    });
+    const changes = diffProcedures(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes.some((change) => change instanceof DropProcedure)).toBe(
+      true,
+    );
+    expect(
+      changes.some((change) => change instanceof CreateCommentOnProcedure),
+    ).toBe(true);
+  });
 });