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

package/src/core/objects/materialized-view/materialized-view.model.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, test } from "bun:test";
+import type { Pool } from "pg";
+import {
+  extractMaterializedViews,
+  MaterializedView,
+} from "./materialized-view.model.ts";
+
+const baseRow = {
+  schema: "public",
+  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 mockPool = (rows: unknown[]): Pool =>
+  ({ query: async () => ({ rows }) }) as unknown as Pool;
+
+const mockPoolSequence = (...attempts: unknown[][]): Pool => {
+  let i = 0;
+  return {
+    query: async () => ({
+      rows: attempts[Math.min(i++, attempts.length - 1)],
+    }),
+  } as unknown as Pool;
+};
+
+const NO_BACKOFF = { backoffMs: 0 } as const;
+
+describe("extractMaterializedViews", () => {
+  test("skips rows where pg_get_viewdef returned NULL after exhausting retries", async () => {
+    const mvs = await extractMaterializedViews(
+      mockPool([
+        {
+          ...baseRow,
+          name: '"good_mv"',
+          definition: "SELECT 1",
+        },
+        { ...baseRow, name: '"orphan_mv"', definition: null },
+      ]),
+      NO_BACKOFF,
+    );
+
+    expect(mvs).toHaveLength(1);
+    expect(mvs[0]).toBeInstanceOf(MaterializedView);
+    expect(mvs[0]?.name).toBe('"good_mv"');
+    expect(mvs[0]?.definition).toBe("SELECT 1");
+  });
+
+  test("does not throw ZodError when the only row has a null definition", async () => {
+    await expect(
+      extractMaterializedViews(
+        mockPool([{ ...baseRow, name: '"orphan"', definition: null }]),
+        NO_BACKOFF,
+      ),
+    ).resolves.toEqual([]);
+  });
+
+  test("returns all materialized views when every row has a valid definition", async () => {
+    const mvs = await extractMaterializedViews(
+      mockPool([
+        { ...baseRow, name: '"a"', definition: "SELECT 1" },
+        { ...baseRow, name: '"b"', definition: "SELECT 2" },
+      ]),
+      NO_BACKOFF,
+    );
+    expect(mvs.map((m) => m.name)).toEqual(['"a"', '"b"']);
+  });
+
+  test("recovers when pg_get_viewdef is NULL on first attempt but resolved on retry", async () => {
+    const mvs = await extractMaterializedViews(
+      mockPoolSequence(
+        [{ ...baseRow, name: '"racy_mv"', definition: null }],
+        [{ ...baseRow, name: '"racy_mv"', definition: "SELECT 42" }],
+      ),
+      { retries: 2, backoffMs: 0 },
+    );
+    expect(mvs).toHaveLength(1);
+    expect(mvs[0]?.name).toBe('"racy_mv"');
+    expect(mvs[0]?.definition).toBe("SELECT 42");
+  });
+});

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

@@ -10,6 +10,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 materializedViewPropsSchema = z.object({
@@ -33,6 +37,15 @@ const materializedViewPropsSchema = z.object({
   privileges: z.array(privilegePropsSchema),
 });
 
+// pg_get_viewdef(oid) can return NULL when the underlying matview (or its
+// pg_rewrite row) is dropped between catalog scan and resolution, or under
+// transient catalog state during recovery. An unreadable matview 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 materializedViewRowSchema = materializedViewPropsSchema.extend({
+  definition: z.string().nullable(),
+});
+
 type MaterializedViewPrivilegeProps = PrivilegeProps;
 export type MaterializedViewProps = z.infer<typeof materializedViewPropsSchema>;
 
@@ -142,8 +155,14 @@ export class MaterializedView extends BasePgModel implements TableLikeObject {
 
 export async function extractMaterializedViews(
   pool: Pool,
+  options?: ExtractRetryOptions,
 ): Promise<MaterializedView[]> {
-  const { rows: mvRows } = await pool.query<MaterializedViewProps>(sql`
+  const mvRows = await extractWithDefinitionRetry({
+    label: "materialized views",
+    options,
+    hasNullDefinition: (row) => row.definition === null,
+    query: async () => {
+      const result = await pool.query<MaterializedViewProps>(sql`
 with extension_oids as (
   select
     objid
@@ -248,9 +267,13 @@ group by
 order by
   c.relnamespace::regnamespace, c.relname
   `);
-  // Validate and parse each row using the Zod schema
-  const validatedRows = mvRows.map((row: unknown) =>
-    materializedViewPropsSchema.parse(row),
+      return result.rows.map((row: unknown) =>
+        materializedViewRowSchema.parse(row),
+      );
+    },
+  });
+  const validatedRows = mvRows.filter(
+    (row): row is MaterializedViewProps => row.definition !== null,
   );
   return validatedRows.map(
     (row: MaterializedViewProps) => new MaterializedView(row),

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

@@ -0,0 +1,117 @@
+import { describe, expect, test } from "bun:test";
+import type { Pool } from "pg";
+import { extractProcedures, Procedure } from "./procedure.model.ts";
+
+const baseRow = {
+  schema: "public",
+  kind: "f" as const,
+  return_type: "integer",
+  return_type_schema: "pg_catalog",
+  language: "sql",
+  security_definer: false,
+  volatility: "v" as const,
+  parallel_safety: "u" as const,
+  execution_cost: 100,
+  result_rows: 0,
+  is_strict: false,
+  leakproof: false,
+  returns_set: false,
+  argument_count: 0,
+  argument_default_count: 0,
+  argument_names: null,
+  argument_types: null,
+  all_argument_types: null,
+  argument_modes: null,
+  argument_defaults: null,
+  source_code: "select 1",
+  binary_path: null,
+  sql_body: null,
+  config: null,
+  owner: "postgres",
+  comment: null,
+  privileges: [],
+};
+
+const mockPool = (rows: unknown[]): Pool =>
+  ({ query: async () => ({ rows }) }) as unknown as Pool;
+
+const mockPoolSequence = (...attempts: unknown[][]): Pool => {
+  let i = 0;
+  return {
+    query: async () => ({
+      rows: attempts[Math.min(i++, attempts.length - 1)],
+    }),
+  } as unknown as Pool;
+};
+
+const NO_BACKOFF = { backoffMs: 0 } as const;
+
+describe("extractProcedures", () => {
+  test("skips rows where pg_get_functiondef returned NULL after exhausting retries", async () => {
+    const procs = await extractProcedures(
+      mockPool([
+        {
+          ...baseRow,
+          name: '"good_fn"',
+          definition:
+            "CREATE OR REPLACE FUNCTION good_fn() RETURNS integer AS $$ select 1 $$ LANGUAGE sql;",
+        },
+        { ...baseRow, name: '"orphan_fn"', definition: null },
+      ]),
+      NO_BACKOFF,
+    );
+
+    expect(procs).toHaveLength(1);
+    expect(procs[0]).toBeInstanceOf(Procedure);
+    expect(procs[0]?.name).toBe('"good_fn"');
+  });
+
+  test("does not throw ZodError when the only row has a null definition", async () => {
+    await expect(
+      extractProcedures(
+        mockPool([{ ...baseRow, name: '"orphan"', definition: null }]),
+        NO_BACKOFF,
+      ),
+    ).resolves.toEqual([]);
+  });
+
+  test("returns all procedures when every row has a valid definition", async () => {
+    const procs = await extractProcedures(
+      mockPool([
+        {
+          ...baseRow,
+          name: '"a"',
+          definition:
+            "CREATE OR REPLACE FUNCTION a() RETURNS integer AS $$ select 1 $$ LANGUAGE sql;",
+        },
+        {
+          ...baseRow,
+          name: '"b"',
+          definition:
+            "CREATE OR REPLACE FUNCTION b() RETURNS integer AS $$ select 2 $$ LANGUAGE sql;",
+        },
+      ]),
+      NO_BACKOFF,
+    );
+    expect(procs.map((p) => p.name)).toEqual(['"a"', '"b"']);
+  });
+
+  test("recovers when pg_get_functiondef is NULL on first attempt but resolved on retry", async () => {
+    const procs = await extractProcedures(
+      mockPoolSequence(
+        [{ ...baseRow, name: '"racy_fn"', definition: null }],
+        [
+          {
+            ...baseRow,
+            name: '"racy_fn"',
+            definition:
+              "CREATE OR REPLACE FUNCTION racy_fn() RETURNS integer AS $$ select 1 $$ LANGUAGE sql;",
+          },
+        ],
+      ),
+      { retries: 2, backoffMs: 0 },
+    );
+    expect(procs).toHaveLength(1);
+    expect(procs[0]?.name).toBe('"racy_fn"');
+  });
+});

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

@@ -6,6 +6,10 @@ import {
   type PrivilegeProps,
   privilegePropsSchema,
 } from "../base.privilege-diff.ts";
+import {
+  type ExtractRetryOptions,
+  extractWithDefinitionRetry,
+} from "../extract-with-retry.ts";
 
 const FunctionKindSchema = z.enum([
   "f", // function
@@ -66,6 +70,15 @@ const procedurePropsSchema = z.object({
   privileges: z.array(privilegePropsSchema),
 });
 
+// pg_get_functiondef(oid) can return NULL when the function (its pg_proc
+// row) is dropped between catalog scan and resolution, or under transient
+// catalog state. An unreadable function 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 procedureRowSchema = procedurePropsSchema.extend({
+  definition: z.string().nullable(),
+});
+
 type ProcedurePrivilegeProps = PrivilegeProps;
 export type ProcedureProps = z.infer<typeof procedurePropsSchema>;
 
@@ -183,8 +196,16 @@ export class Procedure extends BasePgModel {
   }
 }
 
-export async function extractProcedures(pool: Pool): Promise<Procedure[]> {
-  const { rows: procedureRows } = await pool.query<ProcedureProps>(sql`
+export async function extractProcedures(
+  pool: Pool,
+  options?: ExtractRetryOptions,
+): Promise<Procedure[]> {
+  const procedureRows = await extractWithDefinitionRetry({
+    label: "procedures",
+    options,
+    hasNullDefinition: (row) => row.definition === null,
+    query: async () => {
+      const result = await pool.query<ProcedureProps>(sql`
 with extension_oids as (
   select
     objid
@@ -256,9 +277,11 @@ from
 order by
   1, 2
   `);
-  // Validate and parse each row using the Zod schema
-  const validatedRows = procedureRows.map((row: unknown) =>
-    procedurePropsSchema.parse(row),
+      return result.rows.map((row: unknown) => procedureRowSchema.parse(row));
+    },
+  });
+  const validatedRows = procedureRows.filter(
+    (row): row is ProcedureProps => row.definition !== null,
   );
   return validatedRows.map((row: ProcedureProps) => new Procedure(row));
 }

package/src/core/objects/rls-policy/rls-policy.diff.ts

@@ -59,7 +59,25 @@ export function diffRlsPolicies(
       {},
     );
 
-    if (nonAlterablePropsChanged) {
+    // The set of relations and procedures that the policy's USING / WITH
+    // CHECK expressions reference is recorded by PostgreSQL in pg_depend
+    // (recordDependencyOnExpr at policy creation). When that set changes
+    // it is unsafe to ALTER POLICY in place: the old reference target may
+    // be dropped in the same plan, and the new reference target may only
+    // exist after the create phase. Drop+create lets the sort phase order
+    // the policy's drop before the referenced object's drop and the
+    // policy's recreate after the referenced object's create.
+    const referencedDependenciesChanged = hasNonAlterableChanges(
+      mainRlsPolicy,
+      branchRlsPolicy,
+      ["referenced_procedures", "referenced_relations"] as const,
+      {
+        referenced_procedures: deepEqual,
+        referenced_relations: deepEqual,
+      },
+    );
+
+    if (nonAlterablePropsChanged || referencedDependenciesChanged) {
       // Replace the entire RLS policy (drop + create)
       changes.push(
         new DropRlsPolicy({ policy: mainRlsPolicy }),

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

@@ -0,0 +1,99 @@
+import { describe, expect, test } from "bun:test";
+import type { Pool } from "pg";
+import { extractRules, Rule } from "./rule.model.ts";
+
+const baseRow = {
+  schema: "public",
+  table_name: '"events"',
+  relation_kind: "r" as const,
+  event: "INSERT" as const,
+  enabled: "O" as const,
+  is_instead: false,
+  owner: "postgres",
+  comment: null,
+  columns: [] as string[],
+};
+
+const mockPool = (rows: unknown[]): Pool =>
+  ({ query: async () => ({ rows }) }) as unknown as Pool;
+
+const mockPoolSequence = (...attempts: unknown[][]): Pool => {
+  let i = 0;
+  return {
+    query: async () => ({
+      rows: attempts[Math.min(i++, attempts.length - 1)],
+    }),
+  } as unknown as Pool;
+};
+
+const NO_BACKOFF = { backoffMs: 0 } as const;
+
+describe("extractRules", () => {
+  test("skips rows where pg_get_ruledef returned NULL after exhausting retries", async () => {
+    const rules = await extractRules(
+      mockPool([
+        {
+          ...baseRow,
+          name: '"good_rule"',
+          definition:
+            "CREATE RULE good_rule AS ON INSERT TO events DO INSTEAD NOTHING;",
+        },
+        { ...baseRow, name: '"orphan_rule"', definition: null },
+      ]),
+      NO_BACKOFF,
+    );
+
+    expect(rules).toHaveLength(1);
+    expect(rules[0]).toBeInstanceOf(Rule);
+    expect(rules[0]?.name).toBe('"good_rule"');
+  });
+
+  test("does not throw ZodError when the only row has a null definition", async () => {
+    await expect(
+      extractRules(
+        mockPool([{ ...baseRow, name: '"orphan"', definition: null }]),
+        NO_BACKOFF,
+      ),
+    ).resolves.toEqual([]);
+  });
+
+  test("returns all rules when every row has a valid definition", async () => {
+    const rules = await extractRules(
+      mockPool([
+        {
+          ...baseRow,
+          name: '"a"',
+          definition:
+            "CREATE RULE a AS ON INSERT TO events DO INSTEAD NOTHING;",
+        },
+        {
+          ...baseRow,
+          name: '"b"',
+          definition:
+            "CREATE RULE b AS ON UPDATE TO events DO INSTEAD NOTHING;",
+        },
+      ]),
+      NO_BACKOFF,
+    );
+    expect(rules.map((r) => r.name)).toEqual(['"a"', '"b"']);
+  });
+
+  test("recovers when pg_get_ruledef is NULL on first attempt but resolved on retry", async () => {
+    const rules = await extractRules(
+      mockPoolSequence(
+        [{ ...baseRow, name: '"racy_rule"', definition: null }],
+        [
+          {
+            ...baseRow,
+            name: '"racy_rule"',
+            definition:
+              "CREATE RULE racy_rule AS ON INSERT TO events DO INSTEAD NOTHING;",
+          },
+        ],
+      ),
+      { retries: 2, backoffMs: 0 },
+    );
+    expect(rules).toHaveLength(1);
+    expect(rules[0]?.name).toBe('"racy_rule"');
+  });
+});

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

@@ -2,6 +2,10 @@ import { sql } from "@ts-safeql/sql-tag";
 import type { Pool } from "pg";
 import z from "zod";
 import { BasePgModel } from "../base.model.ts";
+import {
+  type ExtractRetryOptions,
+  extractWithDefinitionRetry,
+} from "../extract-with-retry.ts";
 import { stableId } from "../utils.ts";
 
 const RuleEventSchema = z.enum(["SELECT", "INSERT", "UPDATE", "DELETE"]);
@@ -29,6 +33,15 @@ const rulePropsSchema = z.object({
   columns: z.array(z.string()),
 });
 
+// pg_get_ruledef(oid, pretty) can return NULL when the rule (its pg_rewrite
+// row) is dropped between catalog scan and resolution, or under transient
+// catalog state. An unreadable rule 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 ruleRowSchema = rulePropsSchema.extend({
+  definition: z.string().nullable(),
+});
+
 export type RuleEnabledState = z.infer<typeof RuleEnabledStateSchema>;
 export type RuleProps = z.infer<typeof rulePropsSchema>;
 
@@ -97,8 +110,16 @@ export class Rule extends BasePgModel {
   }
 }
 
-export async function extractRules(pool: Pool): Promise<Rule[]> {
-  const { rows: ruleRows } = await pool.query<RuleProps>(sql`
+export async function extractRules(
+  pool: Pool,
+  options?: ExtractRetryOptions,
+): Promise<Rule[]> {
+  const ruleRows = await extractWithDefinitionRetry({
+    label: "rules",
+    options,
+    hasNullDefinition: (row) => row.definition === null,
+    query: async () => {
+      const result = await pool.query<RuleProps>(sql`
       WITH extension_rule_oids AS (
         SELECT
           objid
@@ -164,9 +185,12 @@ export async function extractRules(pool: Pool): Promise<Rule[]> {
       ORDER BY
         1, 3, 2
   `);
+      return result.rows.map((row: unknown) => ruleRowSchema.parse(row));
+    },
+  });
 
-  const validatedRows = ruleRows.map((row: unknown) =>
-    rulePropsSchema.parse(row),
+  const validatedRows = ruleRows.filter(
+    (row): row is RuleProps => row.definition !== null,
   );
 
   return validatedRows.map((row) => new Rule(row));

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

@@ -327,6 +327,93 @@ describe.concurrent("sequence.diff", () => {
     expect(changes).toHaveLength(0);
   });
 
+  test("recreate same-name sequence when owning table is renamed away", () => {
+    // Reproduces issue #228 case 1: a SERIAL column's table is renamed
+    // (`old_table` → `new_table`). The sequence keeps the same name
+    // (`old_table_id_seq`) but its OWNED BY now points at `new_table.id`.
+    // PostgreSQL cascade-drops the sequence with the old table, so a later
+    // CREATE TABLE that references `old_table_id_seq` fails. The diff must
+    // emit CreateSequence (and skip the explicit DropSequence to avoid an
+    // unbreakable cycle with the DropTable).
+    const tableColumn = {
+      name: "id",
+      position: 1,
+      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: true,
+      is_identity: false,
+      is_identity_always: false,
+      is_generated: false,
+      collation: null,
+      default: "nextval('public.old_table_id_seq'::regclass)",
+      comment: null,
+    };
+    const tableBaseProps = {
+      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: "test",
+      comment: null,
+      parent_schema: null,
+      parent_name: null,
+      privileges: [],
+    };
+    const oldTable = new Table({
+      ...tableBaseProps,
+      name: "old_table",
+      columns: [tableColumn],
+    });
+    const newTable = new Table({
+      ...tableBaseProps,
+      name: "new_table",
+      columns: [tableColumn],
+    });
+    const mainSequence = new Sequence({
+      ...base,
+      name: "old_table_id_seq",
+      owned_by_schema: "public",
+      owned_by_table: "old_table",
+      owned_by_column: "id",
+    });
+    const branchSequence = new Sequence({
+      ...base,
+      name: "old_table_id_seq",
+      owned_by_schema: "public",
+      owned_by_table: "new_table",
+      owned_by_column: "id",
+    });
+
+    const changes = diffSequences(
+      testContext,
+      { [mainSequence.stableId]: mainSequence },
+      { [branchSequence.stableId]: branchSequence },
+      { [newTable.stableId]: newTable },
+      { [oldTable.stableId]: oldTable },
+    );
+
+    expect(changes.some((c) => c instanceof DropSequence)).toBe(false);
+    expect(changes.some((c) => c instanceof CreateSequence)).toBe(true);
+    expect(changes.some((c) => c instanceof AlterSequenceSetOwnedBy)).toBe(
+      true,
+    );
+  });
+
   test("create with comment emits CreateCommentOnSequence", () => {
     const s = new Sequence({ ...base, comment: "my seq" });
     const changes = diffSequences(testContext, {}, { [s.stableId]: s });

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

@@ -36,6 +36,7 @@ type SequenceOrColumnSetDefaultChange =
  * @param main - The sequences in the main catalog.
  * @param branch - The sequences in the branch catalog.
  * @param branchTables - The tables in the branch catalog (used to check if owning tables are being dropped).
+ * @param mainTables - The tables in the main catalog (used to detect when a same-name sequence will be cascade-dropped because its main-side owning table is going away).
  * @returns A list of changes to apply to main to make it match branch.
  */
 export function diffSequences(
@@ -46,6 +47,7 @@ export function diffSequences(
   main: Record<string, Sequence>,
   branch: Record<string, Sequence>,
   branchTables: Record<string, Table> = {},
+  mainTables: Record<string, Table> = {},
 ): SequenceOrColumnSetDefaultChange[] {
   const { created, dropped, altered } = diffObjects(main, branch);
 
@@ -157,12 +159,35 @@ export function diffSequences(
       NON_ALTERABLE_FIELDS,
     );
 
-    if (nonAlterablePropsChanged) {
-      // Replace the entire sequence (drop + create)
-      changes.push(
-        new DropSequence({ sequence: mainSequence }),
-        new CreateSequence({ sequence: branchSequence }),
-      );
+    // A sequence kept the same name (so it's "altered" in catalog terms),
+    // but its main-side owning table is going away from the plan (renamed
+    // away or simply dropped). PostgreSQL will cascade-drop the sequence
+    // alongside the table, leaving any later CREATE TABLE / column-default
+    // that depends on the sequence name pointing at nothing. Treat this
+    // like a non-alterable change so we recreate the sequence after the
+    // owning table is dropped.
+    const mainOwnedByTableId =
+      mainSequence.owned_by_schema && mainSequence.owned_by_table
+        ? `table:${mainSequence.owned_by_schema}.${mainSequence.owned_by_table}`
+        : null;
+    const cascadeOrphanedByOwningTable =
+      mainOwnedByTableId !== null &&
+      mainTables[mainOwnedByTableId] !== undefined &&
+      branchTables[mainOwnedByTableId] === undefined;
+
+    if (nonAlterablePropsChanged || cascadeOrphanedByOwningTable) {
+      // When the owning table is going away in this plan, PostgreSQL will
+      // cascade-drop the sequence as part of the DROP TABLE. Emitting an
+      // explicit DROP SEQUENCE here would (a) introduce an unbreakable
+      // DropSequence ↔ DropTable cycle on the catalog edges between the
+      // sequence and the dropped column, and (b) be redundant with the
+      // cascade. The CreateSequence below restores the sequence under its
+      // original name so any same-name reference in a later CREATE TABLE
+      // resolves correctly.
+      if (!cascadeOrphanedByOwningTable) {
+        changes.push(new DropSequence({ sequence: mainSequence }));
+      }
+      changes.push(new CreateSequence({ sequence: branchSequence }));
       // Re-apply OWNED BY if present on branch
       if (
         branchSequence.owned_by_schema !== null &&