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

package/src/core/objects/event-trigger/event-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 SecurityLabelProps,
+  securityLabelPropsSchema,
+} from "../security-label.types.ts";
 
 const EventTriggerEnabledSchema = z.enum([
   "O", // ORIGIN - trigger fires in origin mode
@@ -19,6 +23,7 @@ const eventTriggerPropsSchema = z.object({
   tags: z.array(z.string()).nullable(),
   owner: z.string(),
   comment: z.string().nullable(),
+  security_labels: z.array(securityLabelPropsSchema).default([]).optional(),
 });
 
 export type EventTriggerProps = z.infer<typeof eventTriggerPropsSchema>;
@@ -32,6 +37,7 @@ export class EventTrigger extends BasePgModel {
   public readonly tags: EventTriggerProps["tags"];
   public readonly owner: EventTriggerProps["owner"];
   public readonly comment: EventTriggerProps["comment"];
+  public readonly security_labels: SecurityLabelProps[];
 
   constructor(props: EventTriggerProps) {
     super();
@@ -47,6 +53,7 @@ export class EventTrigger extends BasePgModel {
     this.tags = props.tags;
     this.owner = props.owner;
     this.comment = props.comment;
+    this.security_labels = props.security_labels ?? [];
   }
 
   get stableId(): `eventTrigger:${string}` {
@@ -68,6 +75,7 @@ export class EventTrigger extends BasePgModel {
       tags: this.tags,
       owner: this.owner,
       comment: this.comment,
+      security_labels: this.security_labels,
     };
   }
 }
@@ -90,7 +98,20 @@ select
   et.evtenabled as enabled,
   et.evttags as tags,
   et.evtowner::regrole::text as owner,
-  obj_description(et.oid, 'pg_event_trigger') as comment
+  obj_description(et.oid, 'pg_event_trigger') as comment,
+  coalesce(
+    (
+      select json_agg(
+        json_build_object('provider', sl.provider, 'label', sl.label)
+        order by sl.provider
+      )
+      from pg_catalog.pg_seclabel sl
+      where sl.objoid = et.oid
+        and sl.classoid = 'pg_event_trigger'::regclass
+        and sl.objsubid = 0
+    ),
+    '[]'::json
+  ) as security_labels
 from pg_catalog.pg_event_trigger et
 join pg_catalog.pg_proc p on p.oid = et.evtfoid
 left join extension_oids e on e.objid = et.oid

package/src/core/objects/extract-with-retry.test.ts

@@ -0,0 +1,143 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import {
+  extractWithDefinitionRetry,
+  resolveExtractRetries,
+} from "./extract-with-retry.ts";
+
+type Row = { id: string; definition: string | null };
+
+const hasNullDefinition = (r: Row) => r.definition === null;
+
+describe("resolveExtractRetries", () => {
+  const originalEnv = process.env.PGDELTA_EXTRACT_RETRIES;
+  afterEach(() => {
+    if (originalEnv === undefined) {
+      process.env.PGDELTA_EXTRACT_RETRIES = undefined;
+      delete process.env.PGDELTA_EXTRACT_RETRIES;
+    } else {
+      process.env.PGDELTA_EXTRACT_RETRIES = originalEnv;
+    }
+  });
+
+  test("defaults to 1 when option and env are unset", () => {
+    delete process.env.PGDELTA_EXTRACT_RETRIES;
+    expect(resolveExtractRetries()).toBe(1);
+  });
+
+  test("uses option when provided", () => {
+    process.env.PGDELTA_EXTRACT_RETRIES = "5";
+    expect(resolveExtractRetries(0)).toBe(0);
+    expect(resolveExtractRetries(1)).toBe(1);
+    expect(resolveExtractRetries(7)).toBe(7);
+  });
+
+  test("falls back to env when option is undefined", () => {
+    process.env.PGDELTA_EXTRACT_RETRIES = "4";
+    expect(resolveExtractRetries()).toBe(4);
+  });
+
+  test("clamps negative values to 0", () => {
+    delete process.env.PGDELTA_EXTRACT_RETRIES;
+    expect(resolveExtractRetries(-3)).toBe(0);
+    process.env.PGDELTA_EXTRACT_RETRIES = "-9";
+    expect(resolveExtractRetries()).toBe(0);
+  });
+
+  test("ignores non-numeric env values", () => {
+    process.env.PGDELTA_EXTRACT_RETRIES = "not-a-number";
+    expect(resolveExtractRetries()).toBe(1);
+  });
+
+  test("ignores empty env string", () => {
+    process.env.PGDELTA_EXTRACT_RETRIES = "";
+    expect(resolveExtractRetries()).toBe(1);
+  });
+});
+
+describe("extractWithDefinitionRetry", () => {
+  test("returns first attempt when no row has null definition", async () => {
+    let attempts = 0;
+    const rows = await extractWithDefinitionRetry<Row>({
+      label: "test",
+      query: async () => {
+        attempts++;
+        return [{ id: "a", definition: "OK" }];
+      },
+      hasNullDefinition,
+      options: { retries: 2, backoffMs: 0 },
+    });
+    expect(attempts).toBe(1);
+    expect(rows).toEqual([{ id: "a", definition: "OK" }]);
+  });
+
+  test("retries when definition is null and succeeds on attempt 2", async () => {
+    let attempts = 0;
+    const rows = await extractWithDefinitionRetry<Row>({
+      label: "test",
+      query: async () => {
+        attempts++;
+        if (attempts === 1) {
+          return [
+            { id: "a", definition: "OK" },
+            { id: "b", definition: null },
+          ];
+        }
+        return [{ id: "a", definition: "OK" }];
+      },
+      hasNullDefinition,
+      options: { retries: 2, backoffMs: 0 },
+    });
+    expect(attempts).toBe(2);
+    expect(rows).toEqual([{ id: "a", definition: "OK" }]);
+  });
+
+  test("returns last-attempt rows (with offenders) once retries are exhausted", async () => {
+    let attempts = 0;
+    const rows = await extractWithDefinitionRetry<Row>({
+      label: "test",
+      query: async () => {
+        attempts++;
+        return [
+          { id: "a", definition: "OK" },
+          { id: "b", definition: null },
+        ];
+      },
+      hasNullDefinition,
+      options: { retries: 2, backoffMs: 0 },
+    });
+    expect(attempts).toBe(3);
+    expect(rows).toEqual([
+      { id: "a", definition: "OK" },
+      { id: "b", definition: null },
+    ]);
+  });
+
+  test("retries: 0 disables retrying entirely", async () => {
+    let attempts = 0;
+    const rows = await extractWithDefinitionRetry<Row>({
+      label: "test",
+      query: async () => {
+        attempts++;
+        return [{ id: "b", definition: null }];
+      },
+      hasNullDefinition,
+      options: { retries: 0, backoffMs: 0 },
+    });
+    expect(attempts).toBe(1);
+    expect(rows).toEqual([{ id: "b", definition: null }]);
+  });
+
+  test("retries: 5 attempts up to 6 times before giving up", async () => {
+    let attempts = 0;
+    await extractWithDefinitionRetry<Row>({
+      label: "test",
+      query: async () => {
+        attempts++;
+        return [{ id: "b", definition: null }];
+      },
+      hasNullDefinition,
+      options: { retries: 5, backoffMs: 0 },
+    });
+    expect(attempts).toBe(6);
+  });
+});

package/src/core/objects/extract-with-retry.ts

@@ -0,0 +1,87 @@
+import debug from "debug";
+
+const log = debug("pg-delta:extract");
+
+const DEFAULT_RETRIES = 1;
+const DEFAULT_BACKOFF_MS = 50;
+
+export interface ExtractRetryOptions {
+  /**
+   * Number of retry attempts to make when a `pg_get_*def()` call returns NULL
+   * for at least one row. Total attempts is `retries + 1`. Negative values are
+   * clamped to 0. When this option is 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).
+   */
+  retries?: number;
+  /**
+   * Delay between retry attempts in milliseconds; the actual wait is
+   * `backoffMs * attemptNumber` (linear). Defaults to 50. Set to 0 in tests.
+   */
+  backoffMs?: number;
+}
+
+export function resolveExtractRetries(option?: number): number {
+  if (typeof option === "number" && Number.isFinite(option)) {
+    return Math.max(0, Math.floor(option));
+  }
+  const envVal = process.env.PGDELTA_EXTRACT_RETRIES;
+  if (envVal !== undefined && envVal !== "") {
+    const n = Number(envVal);
+    if (Number.isFinite(n)) return Math.max(0, Math.floor(n));
+  }
+  return DEFAULT_RETRIES;
+}
+
+const sleep = (ms: number) =>
+  ms > 0 ? new Promise<void>((r) => setTimeout(r, ms)) : Promise.resolve();
+
+/**
+ * Runs `query()` up to `retries + 1` times, retrying as long as at least one
+ * row in the result satisfies `hasNullDefinition`. The retry exists because
+ * `pg_get_<x>def()` can return NULL transiently when the underlying catalog
+ * row is dropped concurrently or the catalog state is in flux; in practice a
+ * second attempt either no longer sees the dropped row or succeeds in
+ * resolving the definition.
+ *
+ * Returns the rows from the first attempt with no offenders, or — once
+ * retries are exhausted — the rows from the final attempt (still containing
+ * offenders). The caller is responsible for the final filter so this helper
+ * works for both flat schemas (definition on the row) and nested schemas
+ * (definition on a child collection, e.g. table constraints).
+ */
+export async function extractWithDefinitionRetry<TRow>(params: {
+  label: string;
+  query: () => Promise<TRow[]>;
+  hasNullDefinition: (row: TRow) => boolean;
+  options?: ExtractRetryOptions;
+}): Promise<TRow[]> {
+  const retries = resolveExtractRetries(params.options?.retries);
+  const backoffMs = params.options?.backoffMs ?? DEFAULT_BACKOFF_MS;
+  const maxAttempts = retries + 1;
+
+  let rows: TRow[] = [];
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    rows = await params.query();
+    const offenders = rows.filter(params.hasNullDefinition).length;
+    if (offenders === 0) return rows;
+    if (attempt < maxAttempts) {
+      log(
+        "%s: pg_get_*def() returned NULL for %d row(s) on attempt %d/%d; retrying",
+        params.label,
+        offenders,
+        attempt,
+        maxAttempts,
+      );
+      await sleep(backoffMs * attempt);
+    } else {
+      log(
+        "%s: pg_get_*def() returned NULL for %d row(s) after %d attempt(s); skipping",
+        params.label,
+        offenders,
+        maxAttempts,
+      );
+    }
+  }
+  return rows;
+}

package/src/core/objects/foreign-data-wrapper/foreign-table/changes/foreign-table.base.ts

@@ -3,7 +3,11 @@ import type { ForeignTable } from "../foreign-table.model.ts";
 
 abstract class BaseForeignTableChange extends BaseChange {
   abstract readonly foreignTable: ForeignTable;
-  abstract readonly scope: "object" | "comment" | "privilege";
+  abstract readonly scope:
+    | "object"
+    | "comment"
+    | "privilege"
+    | "security_label";
   readonly objectType: "foreign_table" = "foreign_table";
 }
 

package/src/core/objects/foreign-data-wrapper/foreign-table/changes/foreign-table.security-label.ts

@@ -0,0 +1,95 @@
+import { quoteLiteral } from "../../../base.change.ts";
+import type { SecurityLabelProps } from "../../../security-label.types.ts";
+import { stableId } from "../../../utils.ts";
+import type { ForeignTable } from "../foreign-table.model.ts";
+import {
+  CreateForeignTableChange,
+  DropForeignTableChange,
+} from "./foreign-table.base.ts";
+
+export type SecurityLabelForeignTable =
+  | CreateSecurityLabelOnForeignTable
+  | DropSecurityLabelOnForeignTable;
+
+export class CreateSecurityLabelOnForeignTable extends CreateForeignTableChange {
+  public readonly foreignTable: ForeignTable;
+  public readonly securityLabel: SecurityLabelProps;
+  public readonly scope = "security_label" as const;
+
+  constructor(props: {
+    foreignTable: ForeignTable;
+    securityLabel: SecurityLabelProps;
+  }) {
+    super();
+    this.foreignTable = props.foreignTable;
+    this.securityLabel = props.securityLabel;
+  }
+
+  get creates() {
+    return [
+      stableId.securityLabel(
+        this.foreignTable.stableId,
+        this.securityLabel.provider,
+      ),
+    ];
+  }
+
+  get requires() {
+    return [this.foreignTable.stableId];
+  }
+
+  serialize(): string {
+    return [
+      "SECURITY LABEL FOR",
+      this.securityLabel.provider,
+      "ON FOREIGN TABLE",
+      `${this.foreignTable.schema}.${this.foreignTable.name}`,
+      "IS",
+      quoteLiteral(this.securityLabel.label),
+    ].join(" ");
+  }
+}
+
+export class DropSecurityLabelOnForeignTable extends DropForeignTableChange {
+  public readonly foreignTable: ForeignTable;
+  public readonly securityLabel: SecurityLabelProps;
+  public readonly scope = "security_label" as const;
+
+  constructor(props: {
+    foreignTable: ForeignTable;
+    securityLabel: SecurityLabelProps;
+  }) {
+    super();
+    this.foreignTable = props.foreignTable;
+    this.securityLabel = props.securityLabel;
+  }
+
+  get drops() {
+    return [
+      stableId.securityLabel(
+        this.foreignTable.stableId,
+        this.securityLabel.provider,
+      ),
+    ];
+  }
+
+  get requires() {
+    return [
+      stableId.securityLabel(
+        this.foreignTable.stableId,
+        this.securityLabel.provider,
+      ),
+      this.foreignTable.stableId,
+    ];
+  }
+
+  serialize(): string {
+    return [
+      "SECURITY LABEL FOR",
+      this.securityLabel.provider,
+      "ON FOREIGN TABLE",
+      `${this.foreignTable.schema}.${this.foreignTable.name}`,
+      "IS NULL",
+    ].join(" ");
+  }
+}

package/src/core/objects/foreign-data-wrapper/foreign-table/changes/foreign-table.types.ts

@@ -3,6 +3,7 @@ import type { CommentForeignTable } from "./foreign-table.comment.ts";
 import type { CreateForeignTable } from "./foreign-table.create.ts";
 import type { DropForeignTable } from "./foreign-table.drop.ts";
 import type { ForeignTablePrivilege } from "./foreign-table.privilege.ts";
+import type { SecurityLabelForeignTable } from "./foreign-table.security-label.ts";
 
 /** Union of all foreign-table-related change variants (`objectType: "foreign_table"`). @category Change Types */
 export type ForeignTableChange =
@@ -10,4 +11,5 @@ export type ForeignTableChange =
   | CommentForeignTable
   | CreateForeignTable
   | DropForeignTable
-  | ForeignTablePrivilege;
+  | ForeignTablePrivilege
+  | SecurityLabelForeignTable;

package/src/core/objects/foreign-data-wrapper/foreign-table/foreign-table.diff.ts

@@ -5,6 +5,7 @@ import {
   filterPublicBuiltInDefaults,
 } from "../../base.privilege-diff.ts";
 import type { ObjectDiffContext } from "../../diff-context.ts";
+import { diffSecurityLabels } from "../../security-label.types.ts";
 import {
   AlterForeignTableAddColumn,
   AlterForeignTableAlterColumnDropDefault,
@@ -27,6 +28,10 @@ import {
   RevokeForeignTablePrivileges,
   RevokeGrantOptionForeignTablePrivileges,
 } from "./changes/foreign-table.privilege.ts";
+import {
+  CreateSecurityLabelOnForeignTable,
+  DropSecurityLabelOnForeignTable,
+} from "./changes/foreign-table.security-label.ts";
 import type { ForeignTableChange } from "./changes/foreign-table.types.ts";
 import type { ForeignTable } from "./foreign-table.model.ts";
 
@@ -70,6 +75,14 @@ export function diffForeignTables(
         new CreateCommentOnForeignTable({ foreignTable: createdTable }),
       );
     }
+    for (const label of createdTable.security_labels) {
+      changes.push(
+        new CreateSecurityLabelOnForeignTable({
+          foreignTable: createdTable,
+          securityLabel: label,
+        }),
+      );
+    }
 
     // PRIVILEGES: For created objects, compare against default privileges state
     const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(
@@ -249,6 +262,26 @@ export function diffForeignTables(
       }
     }
 
+    // SECURITY LABELS
+    changes.push(
+      ...diffSecurityLabels<
+        CreateSecurityLabelOnForeignTable | DropSecurityLabelOnForeignTable
+      >(
+        mainTable.security_labels,
+        branchTable.security_labels,
+        (securityLabel) =>
+          new CreateSecurityLabelOnForeignTable({
+            foreignTable: branchTable,
+            securityLabel,
+          }),
+        (securityLabel) =>
+          new DropSecurityLabelOnForeignTable({
+            foreignTable: mainTable,
+            securityLabel,
+          }),
+      ),
+    );
+
     // PRIVILEGES
     const mainPrivilegesFiltered = filterPublicBuiltInDefaults(
       "foreign_table",

package/src/core/objects/foreign-data-wrapper/foreign-table/foreign-table.model.ts

@@ -10,6 +10,11 @@ import {
   type PrivilegeProps,
   privilegePropsSchema,
 } from "../../base.privilege-diff.ts";
+import {
+  normalizeSecurityLabels,
+  type SecurityLabelProps,
+  securityLabelPropsSchema,
+} from "../../security-label.types.ts";
 
 /**
  * All properties exposed by CREATE FOREIGN TABLE statement are included in diff output.
@@ -30,6 +35,7 @@ const foreignTablePropsSchema = z.object({
   comment: z.string().nullable(),
   columns: z.array(columnPropsSchema),
   privileges: z.array(privilegePropsSchema),
+  security_labels: z.array(securityLabelPropsSchema).default([]).optional(),
 });
 
 type ForeignTablePrivilegeProps = PrivilegeProps;
@@ -44,6 +50,7 @@ export class ForeignTable extends BasePgModel implements TableLikeObject {
   public readonly comment: ForeignTableProps["comment"];
   public readonly columns: ForeignTableProps["columns"];
   public readonly privileges: ForeignTablePrivilegeProps[];
+  public readonly security_labels: SecurityLabelProps[];
 
   constructor(props: ForeignTableProps) {
     super();
@@ -59,6 +66,7 @@ export class ForeignTable extends BasePgModel implements TableLikeObject {
     this.comment = props.comment;
     this.columns = props.columns;
     this.privileges = props.privileges;
+    this.security_labels = props.security_labels ?? [];
   }
 
   get stableId(): `foreignTable:${string}` {
@@ -80,6 +88,7 @@ export class ForeignTable extends BasePgModel implements TableLikeObject {
       comment: this.comment,
       columns: this.columns,
       privileges: this.privileges,
+      security_labels: this.security_labels,
     };
   }
 
@@ -104,6 +113,7 @@ export class ForeignTable extends BasePgModel implements TableLikeObject {
       data: {
         ...this.dataFields,
         columns: normalizeColumns(),
+        security_labels: normalizeSecurityLabels(this.security_labels),
       },
     };
   }
@@ -209,7 +219,20 @@ export async function extractForeignTables(
             join lateral aclexplode(src.acl) as x(grantor, grantee, privilege_type, is_grantable) on true
             group by x.grantee, x.privilege_type
           ) as grp
-        ), '[]') as privileges
+        ), '[]') as privileges,
+        coalesce(
+          (
+            select json_agg(
+              json_build_object('provider', sl.provider, 'label', sl.label)
+              order by sl.provider
+            )
+            from pg_catalog.pg_seclabel sl
+            where sl.objoid = ft.oid
+              and sl.classoid = 'pg_class'::regclass
+              and sl.objsubid = 0
+          ),
+          '[]'::json
+        ) as security_labels
       from
         foreign_tables ft
         left join pg_attribute a on a.attrelid = ft.oid and a.attnum > 0 and not a.attisdropped

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

@@ -104,7 +104,6 @@ export function diffIndexes(
       "nulls_not_distinct",
       "immediate",
       "is_clustered",
-      "is_replica_identity",
       "column_collations",
       "operator_classes",
       "column_options",

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

@@ -36,8 +36,19 @@ const baseRow = {
 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("extractIndexes", () => {
-  test("skips rows where pg_get_indexdef returned NULL", async () => {
+  test("skips rows where pg_get_indexdef returned NULL after exhausting retries", async () => {
     const indexes = await extractIndexes(
       mockPool([
         {
@@ -47,6 +58,7 @@ describe("extractIndexes", () => {
         },
         { ...baseRow, name: '"orphan_idx"', definition: null },
       ]),
+      NO_BACKOFF,
     );
 
     expect(indexes).toHaveLength(1);
@@ -59,6 +71,7 @@ describe("extractIndexes", () => {
     await expect(
       extractIndexes(
         mockPool([{ ...baseRow, name: '"orphan"', definition: null }]),
+        NO_BACKOFF,
       ),
     ).resolves.toEqual([]);
   });
@@ -77,7 +90,30 @@ describe("extractIndexes", () => {
           definition: "CREATE INDEX b ON users (id)",
         },
       ]),
+      NO_BACKOFF,
     );
     expect(indexes.map((i) => i.name)).toEqual(['"a"', '"b"']);
   });
+
+  test("recovers when pg_get_indexdef is NULL on first attempt but resolved on retry", async () => {
+    const indexes = await extractIndexes(
+      mockPoolSequence(
+        // attempt 1: definition is NULL (transient race)
+        [{ ...baseRow, name: '"racy_idx"', definition: null }],
+        // attempt 2: catalog scan no longer sees the dropped row, or
+        // pg_get_indexdef successfully resolves the definition
+        [
+          {
+            ...baseRow,
+            name: '"racy_idx"',
+            definition: "CREATE INDEX racy_idx ON users (id)",
+          },
+        ],
+      ),
+      { retries: 2, backoffMs: 0 },
+    );
+    expect(indexes).toHaveLength(1);
+    expect(indexes[0]?.name).toBe('"racy_idx"');
+    expect(indexes[0]?.definition).toBe("CREATE INDEX racy_idx ON users (id)");
+  });
 });

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