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

package/src/core/objects/table/changes/table.alter.test.ts

@@ -343,7 +343,7 @@ describe.concurrent("table", () => {
       ).toBe("ALTER TABLE public.test_table REPLICA IDENTITY FULL");
     });
 
-    test("replica identity DEFAULT and INDEX fallback", async () => {
+    test("replica identity DEFAULT and USING INDEX", async () => {
       const baseProps: Omit<
         TableProps,
         "owner" | "options" | "replica_identity"
@@ -372,31 +372,23 @@ describe.concurrent("table", () => {
         options: null,
         replica_identity: "n",
       });
-      const toDefault = new Table({
-        ...baseProps,
-        owner: "o1",
-        options: null,
-        replica_identity: "d",
-      });
-      const toIndex = new Table({
-        ...baseProps,
-        owner: "o1",
-        options: null,
-        replica_identity: "i",
-      });
       expect(
         new AlterTableSetReplicaIdentity({
           table,
-          mode: toDefault.replica_identity,
-        }).serialize(),
-      ).toBe("ALTER TABLE public.test_table REPLICA IDENTITY DEFAULT");
-      // AlterTableSetReplicaIdentity of type "i" will not be emitted in diff, it is handled by index changes, we fallback to DEFAULT here
-      expect(
-        new AlterTableSetReplicaIdentity({
-          table,
-          mode: toIndex.replica_identity,
+          mode: "d",
         }).serialize(),
       ).toBe("ALTER TABLE public.test_table REPLICA IDENTITY DEFAULT");
+      const usingIndex = new AlterTableSetReplicaIdentity({
+        table,
+        mode: "i",
+        indexName: "test_table_pkey",
+      });
+      expect(usingIndex.serialize()).toBe(
+        "ALTER TABLE public.test_table REPLICA IDENTITY USING INDEX test_table_pkey",
+      );
+      expect(usingIndex.requires).toContain(
+        "index:public.test_table.test_table_pkey",
+      );
     });
 
     test("columns add/drop/alter", async () => {

package/src/core/objects/table/changes/table.alter.ts

@@ -462,20 +462,46 @@ export class AlterTableValidateConstraint extends AlterTableChange {
 
 /**
  * ALTER TABLE ... REPLICA IDENTITY ...
+ *
+ * When `mode === "i"` (USING INDEX), `indexName` is the name of the index to
+ * use. The extractor populates `Table.replica_identity_index` from
+ * `pg_index.indisreplident` whenever `Table.replica_identity` is `'i'`, so
+ * callers that source their props from a `Table` instance can rely on the
+ * pair being consistent. The non-null assertions in `requires` / `serialize`
+ * below are justified by that data invariant — the same pattern the FK
+ * branch of `AlterTableAddConstraint` uses for `foreign_key_columns!` /
+ * `foreign_key_table!` / `foreign_key_schema!`.
  */
 export class AlterTableSetReplicaIdentity extends AlterTableChange {
   public readonly table: Table;
   public readonly mode: "d" | "n" | "f" | "i";
+  public readonly indexName: string | null;
   public readonly scope = "object" as const;
 
-  constructor(props: { table: Table; mode: "d" | "n" | "f" | "i" }) {
+  constructor(props: {
+    table: Table;
+    mode: "d" | "n" | "f" | "i";
+    indexName?: string | null;
+  }) {
     super();
     this.table = props.table;
     this.mode = props.mode;
+    this.indexName = props.indexName ?? null;
   }
 
   get requires() {
-    return [this.table.stableId];
+    const reqs: string[] = [this.table.stableId];
+    if (this.mode === "i") {
+      reqs.push(
+        stableId.index(
+          this.table.schema,
+          this.table.name,
+          // biome-ignore lint/style/noNonNullAssertion: mode 'i' implies the extractor populated replica_identity_index
+          this.indexName!,
+        ),
+      );
+    }
+    return reqs;
   }
 
   serialize(_options?: SerializeOptions): string {
@@ -486,7 +512,8 @@ export class AlterTableSetReplicaIdentity extends AlterTableChange {
           ? "NOTHING"
           : this.mode === "f"
             ? "FULL"
-            : "DEFAULT"; // 'i' (USING INDEX) is handled via index changes; fallback to DEFAULT
+            : // biome-ignore lint/style/noNonNullAssertion: mode 'i' implies the extractor populated replica_identity_index
+              `USING INDEX ${this.indexName!}`;
     return [
       "ALTER TABLE",
       `${this.table.schema}.${this.table.name}`,

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

@@ -245,15 +245,13 @@ export function diffTables(
 
     // REPLICA IDENTITY: If non-default, emit ALTER TABLE ... REPLICA IDENTITY
     if (branchTable.replica_identity !== "d") {
-      // Skip 'i' (USING INDEX) — handled by index changes
-      if (branchTable.replica_identity !== "i") {
-        changes.push(
-          new AlterTableSetReplicaIdentity({
-            table: branchTable,
-            mode: branchTable.replica_identity,
-          }),
-        );
-      }
+      changes.push(
+        new AlterTableSetReplicaIdentity({
+          table: branchTable,
+          mode: branchTable.replica_identity,
+          indexName: branchTable.replica_identity_index,
+        }),
+      );
     }
 
     changes.push(
@@ -404,16 +402,23 @@ export function diffTables(
     }
 
     // REPLICA IDENTITY
-    if (mainTable.replica_identity !== branchTable.replica_identity) {
-      // Skip when target is 'i' (USING INDEX) — handled by index changes
-      if (branchTable.replica_identity !== "i") {
-        changes.push(
-          new AlterTableSetReplicaIdentity({
-            table: mainTable,
-            mode: branchTable.replica_identity,
-          }),
-        );
-      }
+    // Re-emit when the mode changes, or when staying in 'i' mode but pointing
+    // at a different index. The index named on the branch must already exist
+    // before this ALTER runs; AlterTableSetReplicaIdentity declares that
+    // dependency in its `requires`.
+    const replicaIdentityChanged =
+      mainTable.replica_identity !== branchTable.replica_identity ||
+      (branchTable.replica_identity === "i" &&
+        mainTable.replica_identity_index !==
+          branchTable.replica_identity_index);
+    if (replicaIdentityChanged) {
+      changes.push(
+        new AlterTableSetReplicaIdentity({
+          table: mainTable,
+          mode: branchTable.replica_identity,
+          indexName: branchTable.replica_identity_index,
+        }),
+      );
     }
 
     // OWNER

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,
@@ -453,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));
 }