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

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

@@ -11,6 +11,10 @@ import {
   type PrivilegeProps,
   privilegePropsSchema,
 } from "../base.privilege-diff.ts";
+import {
+  type ExtractRetryOptions,
+  extractWithDefinitionRetry,
+} from "../extract-with-retry.ts";
 import { ReplicaIdentitySchema } from "../table/table.model.ts";
 
 const viewPropsSchema = z.object({
@@ -34,6 +38,15 @@ const viewPropsSchema = z.object({
   privileges: z.array(privilegePropsSchema),
 });
 
+// pg_get_viewdef(oid) can return NULL when the underlying view (or its
+// pg_rewrite row) is dropped between catalog scan and resolution, or under
+// transient catalog state during recovery. An unreadable view cannot be
+// diffed, so we accept NULL here and filter the row out at extraction time
+// rather than crashing the whole catalog parse with a ZodError.
+const viewRowSchema = viewPropsSchema.extend({
+  definition: z.string().nullable(),
+});
+
 type ViewPrivilegeProps = PrivilegeProps;
 export type ViewProps = z.infer<typeof viewPropsSchema>;
 
@@ -126,8 +139,16 @@ export class View extends BasePgModel implements TableLikeObject {
   }
 }
 
-export async function extractViews(pool: Pool): Promise<View[]> {
-  const { rows: viewRows } = await pool.query<ViewProps>(sql`
+export async function extractViews(
+  pool: Pool,
+  options?: ExtractRetryOptions,
+): Promise<View[]> {
+  const viewRows = await extractWithDefinitionRetry({
+    label: "views",
+    options,
+    hasNullDefinition: (row) => row.definition === null,
+    query: async () => {
+      const result = await pool.query<ViewProps>(sql`
 with extension_oids as (
   select
     objid
@@ -254,9 +275,11 @@ group by
 order by
   v.schema, v.name
   `);
-  // Validate and parse each row using the Zod schema
-  const validatedRows = viewRows.map((row: unknown) =>
-    viewPropsSchema.parse(row),
+      return result.rows.map((row: unknown) => viewRowSchema.parse(row));
+    },
+  });
+  const validatedRows = viewRows.filter(
+    (row): row is ViewProps => row.definition !== null,
   );
   return validatedRows.map((row: ViewProps) => new View(row));
 }

package/src/core/plan/create.ts

@@ -100,7 +100,9 @@ export async function createPlan(
     }
     const resolved = await resolvePool(input, label);
     pools.push(resolved);
-    return extractCatalog(resolved.pool);
+    return extractCatalog(resolved.pool, {
+      extractRetries: options.extractRetries,
+    });
   };
 
   const pools: Array<{ pool: Pool; shouldClose: boolean }> = [];

package/src/core/plan/types.ts

@@ -165,4 +165,12 @@ export interface CreatePlanOptions {
    * the output must be self-contained and not rely on statement execution order.
    */
   skipDefaultPrivilegeSubtraction?: boolean;
+  /**
+   * Number of retry attempts for catalog extractors when `pg_get_*def()`
+   * returns NULL for at least one row (a transient race with concurrent DDL).
+   * Total attempts is `extractRetries + 1`. When undefined, the value is read
+   * from the `PGDELTA_EXTRACT_RETRIES` environment variable, falling back to
+   * a default of 1 (i.e. the first attempt plus one retry, 2 attempts total).
+   */
+  extractRetries?: number;
 }

package/src/core/{post-diff-cycle-breaking.test.ts → post-diff-normalization.test.ts}

@@ -1,6 +1,8 @@
 import { describe, expect, test } from "bun:test";
-import { Catalog, createEmptyCatalog } from "./catalog.model.ts";
 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 {
   AlterTableAddConstraint,
   AlterTableChangeOwner,
@@ -15,8 +17,7 @@ import { CreateTable } from "./objects/table/changes/table.create.ts";
 import { DropTable } from "./objects/table/changes/table.drop.ts";
 import { GrantTablePrivileges } from "./objects/table/changes/table.privilege.ts";
 import { Table } from "./objects/table/table.model.ts";
-import { stableId } from "./objects/utils.ts";
-import { normalizePostDiffCycles } from "./post-diff-cycle-breaking.ts";
+import { normalizePostDiffChanges } from "./post-diff-normalization.ts";
 
 const baseTableProps = {
   schema: "public",
@@ -61,150 +62,8 @@ function integerColumn(name: string, position: number) {
   };
 }
 
-describe("normalizePostDiffCycles", () => {
-  test("injects explicit FK drops for mutually dependent dropped tables", async () => {
-    const baseline = await createEmptyCatalog(170000, "postgres");
-    const tableA = new Table({
-      ...baseTableProps,
-      name: "a",
-      columns: [
-        { ...integerColumn("id", 1), not_null: true },
-        integerColumn("b_id", 2),
-      ],
-      constraints: [
-        {
-          name: "a_b_fkey",
-          constraint_type: "f",
-          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: ["b_id"],
-          foreign_key_columns: ["id"],
-          foreign_key_table: "b",
-          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: "b",
-          on_update: "a",
-          on_delete: "a",
-          match_type: "s",
-          check_expression: null,
-          owner: "postgres",
-          definition: "FOREIGN KEY (b_id) REFERENCES public.b(id)",
-          comment: null,
-        },
-      ],
-    });
-    const tableB = new Table({
-      ...baseTableProps,
-      name: "b",
-      columns: [
-        { ...integerColumn("id", 1), not_null: true },
-        integerColumn("a_id", 2),
-      ],
-      constraints: [
-        {
-          name: "b_a_fkey",
-          constraint_type: "f",
-          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: ["a_id"],
-          foreign_key_columns: ["id"],
-          foreign_key_table: "a",
-          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: "a",
-          on_update: "a",
-          on_delete: "a",
-          match_type: "s",
-          check_expression: null,
-          owner: "postgres",
-          definition: "FOREIGN KEY (a_id) REFERENCES public.a(id)",
-          comment: null,
-        },
-      ],
-    });
-    const mainCatalog = new Catalog({
-      ...baseline,
-      tables: {
-        [tableA.stableId]: tableA,
-        [tableB.stableId]: tableB,
-      },
-    });
-    const changes: Change[] = [
-      new DropTable({ table: tableA }),
-      new DropTable({ table: tableB }),
-    ];
-
-    const normalized = normalizePostDiffCycles({
-      changes,
-      mainCatalog,
-    });
-
-    const explicitConstraintDrops = normalized.filter(
-      (change) => change instanceof AlterTableDropConstraint,
-    );
-    expect(explicitConstraintDrops).toHaveLength(2);
-
-    const normalizedDropTableA = normalized.find(
-      (change) =>
-        change instanceof DropTable &&
-        change.table.stableId === tableA.stableId,
-    );
-    const normalizedDropTableB = normalized.find(
-      (change) =>
-        change instanceof DropTable &&
-        change.table.stableId === tableB.stableId,
-    );
-    if (!(normalizedDropTableA instanceof DropTable)) {
-      throw new Error("expected normalized DropTable(public.a)");
-    }
-    if (!(normalizedDropTableB instanceof DropTable)) {
-      throw new Error("expected normalized DropTable(public.b)");
-    }
-
-    expect(
-      normalizedDropTableA.externallyDroppedConstraints.has("a_b_fkey"),
-    ).toBe(true);
-    expect(
-      normalizedDropTableB.externallyDroppedConstraints.has("b_a_fkey"),
-    ).toBe(true);
-    expect(
-      normalizedDropTableA.requires.includes(
-        stableId.constraint("public", "a", "a_b_fkey"),
-      ),
-    ).toBe(false);
-    expect(
-      normalizedDropTableB.requires.includes(
-        stableId.constraint("public", "b", "b_a_fkey"),
-      ),
-    ).toBe(false);
-  });
-
+describe("normalizePostDiffChanges", () => {
   test("prunes same-table drop-column and drop-constraint ALTERs for replaced tables only", async () => {
-    const baseline = await createEmptyCatalog(170000, "postgres");
     const mainChildren = new Table({
       ...baseTableProps,
       name: "children",
@@ -292,14 +151,9 @@ describe("normalizePostDiffCycles", () => {
       preExistingReplicaIdentity,
       preExistingGrant,
     ];
-    const mainCatalog = new Catalog({
-      ...baseline,
-      tables: { [mainChildren.stableId]: mainChildren },
-    });
 
-    const normalized = normalizePostDiffCycles({
+    const normalized = normalizePostDiffChanges({
       changes,
-      mainCatalog,
       replacedTableIds: new Set([mainChildren.stableId]),
     });
 
@@ -322,7 +176,6 @@ describe("normalizePostDiffCycles", () => {
   });
 
   test("dedupes duplicate constraint Add/Validate/Comment on replaced tables keeping last occurrence", async () => {
-    const baseline = await createEmptyCatalog(170000, "postgres");
     const branchChildren = new Table({
       ...baseTableProps,
       name: "children",
@@ -423,14 +276,8 @@ describe("normalizePostDiffCycles", () => {
       expansionComment,
     ];
 
-    const mainCatalog = new Catalog({
-      ...baseline,
-      tables: { [branchChildren.stableId]: branchChildren },
-    });
-
-    const normalized = normalizePostDiffCycles({
+    const normalized = normalizePostDiffChanges({
       changes,
-      mainCatalog,
       replacedTableIds: new Set([branchChildren.stableId]),
     });
 
@@ -456,4 +303,165 @@ describe("normalizePostDiffCycles", () => {
       ),
     ).toHaveLength(1);
   });
+
+  describe("restoreReplicaIdentityAfterIndexReplace", () => {
+    const baseIndexProps: IndexProps = {
+      schema: "public",
+      table_name: "replicated",
+      name: "tenant_idx",
+      storage_params: [],
+      statistics_target: [],
+      index_type: "btree",
+      tablespace: null,
+      is_unique: true,
+      is_primary: false,
+      is_exclusion: false,
+      nulls_not_distinct: false,
+      immediate: true,
+      is_clustered: false,
+      is_replica_identity: true,
+      key_columns: [],
+      column_collations: [],
+      operator_classes: [],
+      column_options: [],
+      index_expressions: null,
+      partial_predicate: null,
+      table_relkind: "r",
+      is_owned_by_constraint: false,
+      is_partitioned_index: false,
+      is_index_partition: false,
+      parent_index_name: null,
+      definition: "CREATE UNIQUE INDEX tenant_idx ON public.replicated (a)",
+      comment: null,
+      owner: "postgres",
+    };
+
+    function makeBranchTable(replicaIdentityIndex: string | null) {
+      return new Table({
+        ...baseTableProps,
+        name: "replicated",
+        replica_identity: replicaIdentityIndex ? "i" : "d",
+        replica_identity_index: replicaIdentityIndex,
+        columns: [
+          { ...integerColumn("id", 1), not_null: true },
+          integerColumn("a", 2),
+        ],
+      });
+    }
+
+    test("re-emits ALTER TABLE … REPLICA IDENTITY USING INDEX after a DropIndex+CreateIndex pair", () => {
+      const branchTable = makeBranchTable("tenant_idx");
+      const oldIndex = new Index(baseIndexProps);
+      const newIndex = new Index({
+        ...baseIndexProps,
+        definition:
+          "CREATE UNIQUE INDEX tenant_idx ON public.replicated (a, id)",
+      });
+
+      const changes: Change[] = [
+        new DropIndex({ index: oldIndex }),
+        new CreateIndex({ index: newIndex, indexableObject: branchTable }),
+      ];
+
+      const normalized = normalizePostDiffChanges({
+        changes,
+        branchTables: { [branchTable.stableId]: branchTable },
+      });
+
+      expect(normalized.map((c) => c.constructor.name)).toEqual([
+        "DropIndex",
+        "CreateIndex",
+        "AlterTableSetReplicaIdentity",
+      ]);
+
+      const inserted = normalized[2] as AlterTableSetReplicaIdentity;
+      expect(inserted.mode).toBe("i");
+      expect(inserted.indexName).toBe("tenant_idx");
+      expect(inserted.requires).toEqual([
+        "table:public.replicated",
+        "index:public.replicated.tenant_idx",
+      ]);
+    });
+
+    test("does not double-emit when diffTables already produced an AlterTableSetReplicaIdentity for the same table", () => {
+      const branchTable = makeBranchTable("tenant_idx");
+      const oldIndex = new Index(baseIndexProps);
+      const newIndex = new Index({
+        ...baseIndexProps,
+        definition:
+          "CREATE UNIQUE INDEX tenant_idx ON public.replicated (a, id)",
+      });
+
+      const changes: Change[] = [
+        new DropIndex({ index: oldIndex }),
+        new CreateIndex({ index: newIndex, indexableObject: branchTable }),
+        new AlterTableSetReplicaIdentity({
+          table: branchTable,
+          mode: "i",
+          indexName: "tenant_idx",
+        }),
+      ];
+
+      const normalized = normalizePostDiffChanges({
+        changes,
+        branchTables: { [branchTable.stableId]: branchTable },
+      });
+
+      expect(
+        normalized.filter((c) => c instanceof AlterTableSetReplicaIdentity),
+      ).toHaveLength(1);
+    });
+
+    test("ignores DropIndex without a matching CreateIndex (pure drop)", () => {
+      // Pure drop: the user removed the index entirely. The table.diff path is
+      // responsible for emitting the corresponding REPLICA IDENTITY DEFAULT.
+      // The post-diff pass must not synthesize a USING INDEX setter for an
+      // index that no longer exists.
+      const branchTable = makeBranchTable(null);
+      const oldIndex = new Index(baseIndexProps);
+
+      const changes: Change[] = [new DropIndex({ index: oldIndex })];
+
+      const normalized = normalizePostDiffChanges({
+        changes,
+        branchTables: { [branchTable.stableId]: branchTable },
+      });
+
+      expect(
+        normalized.filter((c) => c instanceof AlterTableSetReplicaIdentity),
+      ).toHaveLength(0);
+    });
+
+    test("ignores indexes that are not the table's replica identity", () => {
+      // The table has replica_identity = 'd', so even if some other index is
+      // being replaced, no setter should be injected.
+      const branchTable = makeBranchTable(null);
+      const otherIndex = new Index({
+        ...baseIndexProps,
+        name: "some_other_idx",
+        is_replica_identity: false,
+        definition: "CREATE INDEX some_other_idx ON public.replicated (a)",
+      });
+      const newOtherIndex = new Index({
+        ...baseIndexProps,
+        name: "some_other_idx",
+        is_replica_identity: false,
+        definition: "CREATE INDEX some_other_idx ON public.replicated (a, id)",
+      });
+
+      const changes: Change[] = [
+        new DropIndex({ index: otherIndex }),
+        new CreateIndex({ index: newOtherIndex, indexableObject: branchTable }),
+      ];
+
+      const normalized = normalizePostDiffChanges({
+        changes,
+        branchTables: { [branchTable.stableId]: branchTable },
+      });
+
+      expect(
+        normalized.filter((c) => c instanceof AlterTableSetReplicaIdentity),
+      ).toHaveLength(0);
+    });
+  });
 });