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

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

@@ -0,0 +1,209 @@
+import { describe, expect, test } from "bun:test";
+import type { Pool } from "pg";
+import { extractTables, Table } from "./table.model.ts";
+
+// Minimal fields required by tablePropsSchema; individual tests override the
+// constraints array (and any other relevant fields).
+const baseTableRow = {
+  schema: "public",
+  name: '"users"',
+  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: "postgres",
+  comment: null,
+  parent_schema: null,
+  parent_name: null,
+  columns: [],
+  privileges: [],
+};
+
+const baseConstraint = {
+  name: '"users_pkey"',
+  constraint_type: "p" as const,
+  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: ['"id"'],
+  foreign_key_columns: null,
+  foreign_key_table: null,
+  foreign_key_schema: null,
+  foreign_key_table_is_partition: null,
+  foreign_key_parent_schema: null,
+  foreign_key_parent_table: null,
+  foreign_key_effective_schema: null,
+  foreign_key_effective_table: null,
+  on_update: null,
+  on_delete: null,
+  match_type: null,
+  check_expression: null,
+  owner: "postgres",
+  comment: null,
+};
+
+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("extractTables", () => {
+  test("skips constraints where pg_get_constraintdef returned NULL after exhausting retries", async () => {
+    const tables = await extractTables(
+      mockPool([
+        {
+          ...baseTableRow,
+          constraints: [
+            {
+              ...baseConstraint,
+              name: '"users_pkey"',
+              definition: "PRIMARY KEY (id)",
+            },
+            {
+              ...baseConstraint,
+              name: '"users_orphan_chk"',
+              constraint_type: "c",
+              key_columns: [],
+              definition: null,
+            },
+          ],
+        },
+      ]),
+      NO_BACKOFF,
+    );
+
+    expect(tables).toHaveLength(1);
+    expect(tables[0]).toBeInstanceOf(Table);
+    expect(tables[0]?.constraints).toHaveLength(1);
+    expect(tables[0]?.constraints[0]?.name).toBe('"users_pkey"');
+    expect(tables[0]?.constraints[0]?.definition).toBe("PRIMARY KEY (id)");
+  });
+
+  test("does not throw ZodError when every constraint has a null definition", async () => {
+    const tables = await extractTables(
+      mockPool([
+        {
+          ...baseTableRow,
+          constraints: [
+            {
+              ...baseConstraint,
+              name: '"orphan_a"',
+              constraint_type: "c",
+              key_columns: [],
+              definition: null,
+            },
+            {
+              ...baseConstraint,
+              name: '"orphan_b"',
+              constraint_type: "c",
+              key_columns: [],
+              definition: null,
+            },
+          ],
+        },
+      ]),
+      NO_BACKOFF,
+    );
+
+    expect(tables).toHaveLength(1);
+    expect(tables[0]?.constraints).toEqual([]);
+  });
+
+  test("returns all constraints when every definition is valid", async () => {
+    const tables = await extractTables(
+      mockPool([
+        {
+          ...baseTableRow,
+          constraints: [
+            {
+              ...baseConstraint,
+              name: '"users_pkey"',
+              definition: "PRIMARY KEY (id)",
+            },
+            {
+              ...baseConstraint,
+              name: '"users_email_key"',
+              constraint_type: "u",
+              key_columns: ['"email"'],
+              definition: "UNIQUE (email)",
+            },
+          ],
+        },
+      ]),
+      NO_BACKOFF,
+    );
+
+    expect(tables[0]?.constraints.map((c) => c.name)).toEqual([
+      '"users_pkey"',
+      '"users_email_key"',
+    ]);
+  });
+
+  test("recovers when pg_get_constraintdef is NULL on first attempt but resolved on retry", async () => {
+    const tables = await extractTables(
+      mockPoolSequence(
+        // attempt 1: one constraint has NULL definition
+        [
+          {
+            ...baseTableRow,
+            constraints: [
+              {
+                ...baseConstraint,
+                name: '"users_racy_chk"',
+                constraint_type: "c",
+                key_columns: [],
+                definition: null,
+              },
+            ],
+          },
+        ],
+        // attempt 2: constraint resolves on retry
+        [
+          {
+            ...baseTableRow,
+            constraints: [
+              {
+                ...baseConstraint,
+                name: '"users_racy_chk"',
+                constraint_type: "c",
+                key_columns: [],
+                definition: "CHECK (id > 0)",
+              },
+            ],
+          },
+        ],
+      ),
+      { retries: 2, backoffMs: 0 },
+    );
+    expect(tables).toHaveLength(1);
+    expect(tables[0]?.constraints).toHaveLength(1);
+    expect(tables[0]?.constraints[0]?.name).toBe('"users_racy_chk"');
+    expect(tables[0]?.constraints[0]?.definition).toBe("CHECK (id > 0)");
+  });
+});

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

@@ -12,6 +12,10 @@ import {
   type PrivilegeProps,
   privilegePropsSchema,
 } from "../base.privilege-diff.ts";
+import {
+  type ExtractRetryOptions,
+  extractWithDefinitionRetry,
+} from "../extract-with-retry.ts";
 
 const RelationPersistenceSchema = z.enum([
   "p", // permanent
@@ -82,6 +86,15 @@ const tableConstraintPropsSchema = z.object({
 
 export type TableConstraintProps = z.infer<typeof tableConstraintPropsSchema>;
 
+// pg_get_constraintdef(oid, pretty) can return NULL under the same conditions
+// as pg_get_indexdef: races with concurrent DDL, transient catalog
+// inconsistencies, recovery edges. An unreadable constraint cannot be diffed,
+// so we accept NULL here and filter the constraint out at extraction time
+// rather than crashing the whole catalog parse with a ZodError.
+const tableConstraintRowSchema = tableConstraintPropsSchema.extend({
+  definition: z.string().nullable(),
+});
+
 const tablePropsSchema = z.object({
   schema: z.string(),
   name: z.string(),
@@ -94,6 +107,7 @@ const tablePropsSchema = z.object({
   has_subclasses: z.boolean(),
   is_populated: z.boolean(),
   replica_identity: ReplicaIdentitySchema,
+  replica_identity_index: z.string().nullable().optional(),
   is_partition: z.boolean(),
   options: z.array(z.string()).nullable(),
   partition_bound: z.string().nullable(),
@@ -107,8 +121,13 @@ const tablePropsSchema = z.object({
   privileges: z.array(privilegePropsSchema),
 });
 
+const tableRowSchema = tablePropsSchema.extend({
+  constraints: z.array(tableConstraintRowSchema).optional(),
+});
+
 type TablePrivilegeProps = PrivilegeProps;
 export type TableProps = z.infer<typeof tablePropsSchema>;
+type TableRow = z.infer<typeof tableRowSchema>;
 
 export class Table extends BasePgModel implements TableLikeObject {
   public readonly schema: TableProps["schema"];
@@ -122,6 +141,7 @@ export class Table extends BasePgModel implements TableLikeObject {
   public readonly has_subclasses: TableProps["has_subclasses"];
   public readonly is_populated: TableProps["is_populated"];
   public readonly replica_identity: TableProps["replica_identity"];
+  public readonly replica_identity_index: TableProps["replica_identity_index"];
   public readonly is_partition: TableProps["is_partition"];
   public readonly options: TableProps["options"];
   public readonly partition_bound: TableProps["partition_bound"];
@@ -151,6 +171,7 @@ export class Table extends BasePgModel implements TableLikeObject {
     this.has_subclasses = props.has_subclasses;
     this.is_populated = props.is_populated;
     this.replica_identity = props.replica_identity;
+    this.replica_identity_index = props.replica_identity_index ?? null;
     this.is_partition = props.is_partition;
     this.options = props.options;
     this.partition_bound = props.partition_bound;
@@ -182,6 +203,7 @@ export class Table extends BasePgModel implements TableLikeObject {
       row_security: this.row_security,
       force_row_security: this.force_row_security,
       replica_identity: this.replica_identity,
+      replica_identity_index: this.replica_identity_index,
       options: this.options,
       // Partition membership can be altered via ATTACH/DETACH
       parent_schema: this.parent_schema,
@@ -216,8 +238,17 @@ export class Table extends BasePgModel implements TableLikeObject {
   }
 }
 
-export async function extractTables(pool: Pool): Promise<Table[]> {
-  const { rows: tableRows } = await pool.query<TableProps>(sql`
+export async function extractTables(
+  pool: Pool,
+  options?: ExtractRetryOptions,
+): Promise<Table[]> {
+  const tableRows = await extractWithDefinitionRetry({
+    label: "table constraints",
+    options,
+    hasNullDefinition: (row: TableRow) =>
+      row.constraints?.some((c) => c.definition === null) ?? false,
+    query: async () => {
+      const result = await pool.query<TableProps>(sql`
 with extension_oids as (
   select objid
   from pg_depend d
@@ -236,6 +267,14 @@ with extension_oids as (
     c.relhassubclass as has_subclasses,
     c.relispopulated as is_populated,
     c.relreplident as replica_identity,
+    (
+      select quote_ident(ri_class.relname)
+      from pg_index ri
+      join pg_class ri_class on ri_class.oid = ri.indexrelid
+      where ri.indrelid = c.oid
+        and ri.indisreplident is true
+      limit 1
+    ) as replica_identity_index,
     c.relispartition as is_partition,
     c.reloptions as options,
     pg_get_expr(c.relpartbound, c.oid) as partition_bound,
@@ -266,6 +305,7 @@ select
   t.has_subclasses,
   t.is_populated,
   t.replica_identity,
+  t.replica_identity_index,
   t.is_partition,
   t.options,
   t.partition_bound,
@@ -296,13 +336,16 @@ select
 
           'key_columns',
             case
-              when c.conkey is not null then (
-                select json_agg(quote_ident(att.attname) order by pk.ordinality)
-                from unnest(c.conkey) with ordinality as pk(attnum, ordinality)
-                join pg_attribute att
-                  on att.attrelid = c.conrelid
-                and att.attnum = pk.attnum
-                and att.attisdropped = false
+              when c.conkey is not null then coalesce(
+                (
+                  select json_agg(quote_ident(att.attname) order by pk.ordinality)
+                  from unnest(c.conkey) with ordinality as pk(attnum, ordinality)
+                  join pg_attribute att
+                    on att.attrelid = c.conrelid
+                  and att.attnum = pk.attnum
+                  and att.attisdropped = false
+                ),
+                '[]'::json
               )
               else '[]'::json
             end,
@@ -450,13 +493,18 @@ from
   left join pg_attrdef ad on a.attrelid = ad.adrelid and a.attnum = ad.adnum
   left join pg_type ty on ty.oid = a.atttypid
 group by
-  t.oid, t.schema, t.name, t.persistence, t.row_security, t.force_row_security, t.has_indexes, t.has_rules, t.has_triggers, t.has_subclasses, t.is_populated, t.replica_identity, t.is_partition, t.options, t.partition_bound, t.partition_by, t.owner, t.parent_schema, t.parent_name
+  t.oid, t.schema, t.name, t.persistence, t.row_security, t.force_row_security, t.has_indexes, t.has_rules, t.has_triggers, t.has_subclasses, t.is_populated, t.replica_identity, t.replica_identity_index, t.is_partition, t.options, t.partition_bound, t.partition_by, t.owner, t.parent_schema, t.parent_name
 order by
   t.schema, t.name
   `);
-  // Validate and parse each row using the Zod schema
-  const validatedRows = tableRows.map((row: unknown) =>
-    tablePropsSchema.parse(row),
-  );
+      return result.rows.map((row: unknown) => tableRowSchema.parse(row));
+    },
+  });
+  const validatedRows = tableRows.map((row): TableProps => {
+    const filteredConstraints = row.constraints?.filter(
+      (c): c is TableConstraintProps => c.definition !== null,
+    );
+    return { ...row, constraints: filteredConstraints };
+  });
   return validatedRows.map((row: TableProps) => new Table(row));
 }

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

@@ -0,0 +1,113 @@
+import { describe, expect, test } from "bun:test";
+import type { Pool } from "pg";
+import { extractTriggers, Trigger } from "./trigger.model.ts";
+
+const baseRow = {
+  schema: "public",
+  table_name: '"users"',
+  table_relkind: "r" as const,
+  function_schema: "public",
+  function_name: '"my_fn"',
+  trigger_type: 7,
+  enabled: "O" as const,
+  is_internal: false,
+  deferrable: false,
+  initially_deferred: false,
+  argument_count: 0,
+  column_numbers: null,
+  arguments: [] as string[],
+  when_condition: null,
+  old_table: null,
+  new_table: null,
+  is_partition_clone: false,
+  parent_trigger_name: null,
+  parent_table_schema: null,
+  parent_table_name: null,
+  is_on_partitioned_table: false,
+  owner: "postgres",
+  comment: null,
+};
+
+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("extractTriggers", () => {
+  test("skips rows where pg_get_triggerdef returned NULL after exhausting retries", async () => {
+    const triggers = await extractTriggers(
+      mockPool([
+        {
+          ...baseRow,
+          name: '"good_trg"',
+          definition:
+            "CREATE TRIGGER good_trg BEFORE INSERT ON users FOR EACH ROW EXECUTE FUNCTION my_fn()",
+        },
+        { ...baseRow, name: '"orphan_trg"', definition: null },
+      ]),
+      NO_BACKOFF,
+    );
+
+    expect(triggers).toHaveLength(1);
+    expect(triggers[0]).toBeInstanceOf(Trigger);
+    expect(triggers[0]?.name).toBe('"good_trg"');
+  });
+
+  test("does not throw ZodError when the only row has a null definition", async () => {
+    await expect(
+      extractTriggers(
+        mockPool([{ ...baseRow, name: '"orphan"', definition: null }]),
+        NO_BACKOFF,
+      ),
+    ).resolves.toEqual([]);
+  });
+
+  test("returns all triggers when every row has a valid definition", async () => {
+    const triggers = await extractTriggers(
+      mockPool([
+        {
+          ...baseRow,
+          name: '"a"',
+          definition:
+            "CREATE TRIGGER a BEFORE INSERT ON users FOR EACH ROW EXECUTE FUNCTION my_fn()",
+        },
+        {
+          ...baseRow,
+          name: '"b"',
+          definition:
+            "CREATE TRIGGER b AFTER UPDATE ON users FOR EACH ROW EXECUTE FUNCTION my_fn()",
+        },
+      ]),
+      NO_BACKOFF,
+    );
+    expect(triggers.map((t) => t.name)).toEqual(['"a"', '"b"']);
+  });
+
+  test("recovers when pg_get_triggerdef is NULL on first attempt but resolved on retry", async () => {
+    const triggers = await extractTriggers(
+      mockPoolSequence(
+        [{ ...baseRow, name: '"racy_trg"', definition: null }],
+        [
+          {
+            ...baseRow,
+            name: '"racy_trg"',
+            definition:
+              "CREATE TRIGGER racy_trg BEFORE INSERT ON users FOR EACH ROW EXECUTE FUNCTION my_fn()",
+          },
+        ],
+      ),
+      { retries: 2, backoffMs: 0 },
+    );
+    expect(triggers).toHaveLength(1);
+    expect(triggers[0]?.name).toBe('"racy_trg"');
+  });
+});

package/src/core/objects/trigger/trigger.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 TriggerEnabledSchema = z.enum([
   "O", // ORIGIN - trigger fires in "origin" and "local" replica modes
@@ -46,6 +50,15 @@ const triggerPropsSchema = z.object({
   comment: z.string().nullable(),
 });
 
+// pg_get_triggerdef(oid, pretty) can return NULL when the trigger (its
+// pg_trigger row) is dropped between catalog scan and resolution, or under
+// transient catalog state. An unreadable trigger 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 triggerRowSchema = triggerPropsSchema.extend({
+  definition: z.string().nullable(),
+});
+
 export type TriggerProps = z.infer<typeof triggerPropsSchema>;
 
 export class Trigger extends BasePgModel {
@@ -154,8 +167,16 @@ export class Trigger extends BasePgModel {
   }
 }
 
-export async function extractTriggers(pool: Pool): Promise<Trigger[]> {
-  const { rows: triggerRows } = await pool.query<TriggerProps>(sql`
+export async function extractTriggers(
+  pool: Pool,
+  options?: ExtractRetryOptions,
+): Promise<Trigger[]> {
+  const triggerRows = await extractWithDefinitionRetry({
+    label: "triggers",
+    options,
+    hasNullDefinition: (row) => row.definition === null,
+    query: async () => {
+      const result = await pool.query<TriggerProps>(sql`
       with extension_trigger_oids as (
         select objid
         from pg_depend d
@@ -260,9 +281,11 @@ export async function extractTriggers(pool: Pool): Promise<Trigger[]> {
 
       order by 1, 2
   `);
-  // Validate and parse each row using the Zod schema
-  const validatedRows = triggerRows.map((row: unknown) =>
-    triggerPropsSchema.parse(row),
+      return result.rows.map((row: unknown) => triggerRowSchema.parse(row));
+    },
+  });
+  const validatedRows = triggerRows.filter(
+    (row): row is TriggerProps => row.definition !== null,
   );
   return validatedRows.map((row: TriggerProps) => new Trigger(row));
 }

package/src/core/objects/utils.ts

@@ -71,6 +71,9 @@ export const stableId = {
   constraint(schema: string, table: string, constraint: string) {
     return `constraint:${schema}.${table}.${constraint}` as const;
   },
+  index(schema: string, table: string, indexName: string) {
+    return `index:${schema}.${table}.${indexName}` as const;
+  },
   comment(objectStableId: string) {
     return `comment:${objectStableId}` as const;
   },

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

@@ -0,0 +1,90 @@
+import { describe, expect, test } from "bun:test";
+import type { Pool } from "pg";
+import { extractViews, View } from "./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("extractViews", () => {
+  test("skips rows where pg_get_viewdef returned NULL after exhausting retries", async () => {
+    const views = await extractViews(
+      mockPool([
+        {
+          ...baseRow,
+          name: '"good_view"',
+          definition: "SELECT 1",
+        },
+        { ...baseRow, name: '"orphan_view"', definition: null },
+      ]),
+      NO_BACKOFF,
+    );
+
+    expect(views).toHaveLength(1);
+    expect(views[0]).toBeInstanceOf(View);
+    expect(views[0]?.name).toBe('"good_view"');
+    expect(views[0]?.definition).toBe("SELECT 1");
+  });
+
+  test("does not throw ZodError when the only row has a null definition", async () => {
+    await expect(
+      extractViews(
+        mockPool([{ ...baseRow, name: '"orphan"', definition: null }]),
+        NO_BACKOFF,
+      ),
+    ).resolves.toEqual([]);
+  });
+
+  test("returns all views when every row has a valid definition", async () => {
+    const views = await extractViews(
+      mockPool([
+        { ...baseRow, name: '"a"', definition: "SELECT 1" },
+        { ...baseRow, name: '"b"', definition: "SELECT 2" },
+      ]),
+      NO_BACKOFF,
+    );
+    expect(views.map((v) => v.name)).toEqual(['"a"', '"b"']);
+  });
+
+  test("recovers when pg_get_viewdef is NULL on first attempt but resolved on retry", async () => {
+    const views = await extractViews(
+      mockPoolSequence(
+        [{ ...baseRow, name: '"racy_view"', definition: null }],
+        [{ ...baseRow, name: '"racy_view"', definition: "SELECT 42" }],
+      ),
+      { retries: 2, backoffMs: 0 },
+    );
+    expect(views).toHaveLength(1);
+    expect(views[0]?.name).toBe('"racy_view"');
+    expect(views[0]?.definition).toBe("SELECT 42");
+  });
+});