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

package/src/core/objects/index/index.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";
 
 const TableRelkindSchema = z.enum([
   "r", // table (regular relation)
@@ -163,7 +167,11 @@ export class Index extends BasePgModel {
       nulls_not_distinct: this.nulls_not_distinct,
       immediate: this.immediate,
       is_clustered: this.is_clustered,
-      is_replica_identity: this.is_replica_identity,
+      // is_replica_identity excluded: the table's `replica_identity` /
+      // `replica_identity_index` is the source of truth, set via
+      // ALTER TABLE ... REPLICA IDENTITY USING INDEX. Including this flag here
+      // would trigger spurious DROP+CREATE of the index whenever the table's
+      // replica identity changes.
       // key_columns excluded: contains attribute numbers that can differ between databases
       // even when indexes are logically identical. The definition field already captures
       // the logical structure using column names, so we compare by definition instead.
@@ -215,8 +223,16 @@ export class Index extends BasePgModel {
   }
 }
 
-export async function extractIndexes(pool: Pool): Promise<Index[]> {
-  const { rows: indexRows } = await pool.query<IndexProps>(sql`
+export async function extractIndexes(
+  pool: Pool,
+  options?: ExtractRetryOptions,
+): Promise<Index[]> {
+  const indexRows = await extractWithDefinitionRetry({
+    label: "indexes",
+    options,
+    hasNullDefinition: (row) => row.definition === null,
+    query: async () => {
+      const result = await pool.query<IndexProps>(sql`
       with extension_oids as (
         select objid
         from pg_depend d
@@ -372,8 +388,11 @@ export async function extractIndexes(pool: Pool): Promise<Index[]> {
 
       order by 1, 2
   `);
-  const validatedRows = indexRows
-    .map((row: unknown) => indexRowSchema.parse(row))
-    .filter((row): row is IndexProps => row.definition !== null);
+      return result.rows.map((row: unknown) => indexRowSchema.parse(row));
+    },
+  });
+  const validatedRows = indexRows.filter(
+    (row): row is IndexProps => row.definition !== null,
+  );
   return validatedRows.map((row: IndexProps) => new Index(row));
 }

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/publication/changes/publication.alter.ts

@@ -128,7 +128,7 @@ export class AlterPublicationAddTables extends AlterPublicationChange {
 export class AlterPublicationDropTables extends AlterPublicationChange {
   public readonly publication: Publication;
   public readonly scope = "object" as const;
-  private readonly tables: PublicationTableProps[];
+  public readonly tables: PublicationTableProps[];
 
   constructor(props: {
     publication: Publication;

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));