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

package/dist/core/sort/utils.d.ts

@@ -19,5 +19,15 @@ export declare function isMetadataStableId(stableId: string): boolean;
  * - ALTER operations with scope="privilege" → create_alter_object phase (metadata changes)
  * - ALTER operations that drop actual objects → drop phase (destructive ALTER)
  * - ALTER operations that don't drop objects → create_alter_object phase (non-destructive ALTER)
+ *
+ * Dependency-breaking ALTERs that remove a `pg_depend` edge to another
+ * object that may be dropped in the same plan (for example
+ * `ALTER COLUMN ... DROP DEFAULT` releasing a sequence reference, or
+ * `ALTER COLUMN ... TYPE <built-in>` releasing a user-defined type
+ * reference) are routed to the drop phase. The drop phase sorts in reverse
+ * dependency order using the main catalog, so the catalog edges already
+ * in `pg_depend` order the ALTER before any dependent `DROP TYPE` /
+ * `DROP SEQUENCE` / `DROP FUNCTION` and PostgreSQL no longer rejects the
+ * drop with error 2BP01.
  */
 export declare function getExecutionPhase(change: Change): Phase;

package/dist/core/sort/utils.js

@@ -1,3 +1,4 @@
+import { AlterTableAlterColumnDropDefault, AlterTableAlterColumnDropIdentity, AlterTableAlterColumnType, } from "../objects/table/changes/table.alter.js";
 /**
  * Check if a stable ID represents metadata (ACL, default privileges, comments, etc.)
  * rather than an actual database object.
@@ -20,6 +21,16 @@ export function isMetadataStableId(stableId) {
  * - ALTER operations with scope="privilege" → create_alter_object phase (metadata changes)
  * - ALTER operations that drop actual objects → drop phase (destructive ALTER)
  * - ALTER operations that don't drop objects → create_alter_object phase (non-destructive ALTER)
+ *
+ * Dependency-breaking ALTERs that remove a `pg_depend` edge to another
+ * object that may be dropped in the same plan (for example
+ * `ALTER COLUMN ... DROP DEFAULT` releasing a sequence reference, or
+ * `ALTER COLUMN ... TYPE <built-in>` releasing a user-defined type
+ * reference) are routed to the drop phase. The drop phase sorts in reverse
+ * dependency order using the main catalog, so the catalog edges already
+ * in `pg_depend` order the ALTER before any dependent `DROP TYPE` /
+ * `DROP SEQUENCE` / `DROP FUNCTION` and PostgreSQL no longer rejects the
+ * drop with error 2BP01.
  */
 export function getExecutionPhase(change) {
     // DROP operations always go to drop phase
@@ -43,6 +54,23 @@ export function getExecutionPhase(change) {
             // Destructive ALTER (DROP COLUMN, DROP CONSTRAINT, etc.) → drop phase
             return "drop";
         }
+        // Dependency-breaking column ALTERs that release a pg_depend edge.
+        // Routing these to the drop phase lets the existing catalog dependency
+        // edges (column → sequence, column → identity sequence) order them
+        // before the matching DROP statement.
+        if (change instanceof AlterTableAlterColumnDropDefault ||
+            change instanceof AlterTableAlterColumnDropIdentity) {
+            return "drop";
+        }
+        // ALTER COLUMN ... TYPE only safely runs in the drop phase when the
+        // target type is built-in. For user-defined target types we cannot tell
+        // here whether the type is created in the same plan, and the create
+        // happens in create_alter phase, so we keep the alter in that phase to
+        // preserve the create-then-alter ordering.
+        if (change instanceof AlterTableAlterColumnType &&
+            !change.column.is_custom_type) {
+            return "drop";
+        }
         // Non-destructive ALTER (ADD COLUMN, GRANT, etc.) → create_alter phase
         return "create_alter_object";
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supabase/pg-delta",
-  "version": "1.0.0-alpha.20",
+  "version": "1.0.0-alpha.22",
   "description": "PostgreSQL migrations made easy",
   "type": "module",
   "sideEffects": false,

package/src/core/catalog.diff.ts

@@ -1,7 +1,7 @@
 import debug from "debug";
 import type { Catalog } from "./catalog.model.ts";
 import { expandReplaceDependencies } from "./expand-replace-dependencies.ts";
-import { normalizePostDiffCycles } from "./post-diff-cycle-breaking.ts";
+import { normalizePostDiffChanges } from "./post-diff-normalization.ts";
 
 const debugCatalog = debug("pg-delta:catalog");
 
@@ -190,6 +190,7 @@ export function diffCatalogs(
       main.sequences,
       branch.sequences,
       branch.tables,
+      main.tables,
     ),
   );
   changes.push(...diffTables(diffContext, main.tables, branch.tables));
@@ -238,10 +239,10 @@ export function diffCatalogs(
     mainCatalog: main,
     branchCatalog: branch,
   });
-  filteredChanges = normalizePostDiffCycles({
+  filteredChanges = normalizePostDiffChanges({
     changes: expandedDependencies.changes,
-    mainCatalog: main,
     replacedTableIds: expandedDependencies.replacedTableIds,
+    branchTables: branch.tables,
   });
 
   debugCatalog(

package/src/core/catalog.model.ts

@@ -302,7 +302,19 @@ export async function createEmptyCatalog(
   });
 }
 
-export async function extractCatalog(pool: Pool) {
+interface ExtractCatalogOptions {
+  /**
+   * Number of retry attempts for catalog extractors when `pg_get_*def()`
+   * returns NULL for at least one row. See `ExtractRetryOptions.retries`.
+   */
+  extractRetries?: number;
+}
+
+export async function extractCatalog(
+  pool: Pool,
+  options: ExtractCatalogOptions = {},
+) {
+  const retryOptions = { retries: options.extractRetries };
   const [
     aggregates,
     collations,
@@ -339,21 +351,21 @@ export async function extractCatalog(pool: Pool) {
     extractDomains(pool).then(listToRecord),
     extractEnums(pool).then(listToRecord),
     extractExtensions(pool).then(listToRecord),
-    extractIndexes(pool).then(listToRecord),
-    extractMaterializedViews(pool).then(listToRecord),
+    extractIndexes(pool, retryOptions).then(listToRecord),
+    extractMaterializedViews(pool, retryOptions).then(listToRecord),
     extractSubscriptions(pool).then(listToRecord),
     extractPublications(pool).then(listToRecord),
-    extractProcedures(pool).then(listToRecord),
+    extractProcedures(pool, retryOptions).then(listToRecord),
     extractRlsPolicies(pool).then(listToRecord),
     extractRoles(pool).then(listToRecord),
     extractSchemas(pool).then(listToRecord),
     extractSequences(pool).then(listToRecord),
-    extractTables(pool).then(listToRecord),
-    extractTriggers(pool).then(listToRecord),
+    extractTables(pool, retryOptions).then(listToRecord),
+    extractTriggers(pool, retryOptions).then(listToRecord),
     extractEventTriggers(pool).then(listToRecord),
-    extractRules(pool).then(listToRecord),
+    extractRules(pool, retryOptions).then(listToRecord),
     extractRanges(pool).then(listToRecord),
-    extractViews(pool).then(listToRecord),
+    extractViews(pool, retryOptions).then(listToRecord),
     extractForeignDataWrappers(pool).then(listToRecord),
     extractServers(pool).then(listToRecord),
     extractUserMappings(pool).then(listToRecord),

package/src/core/expand-replace-dependencies.test.ts

@@ -97,19 +97,154 @@ describe("expandReplaceDependencies", () => {
     expect(result.replacedTableIds.size).toBe(0);
   });
 
+  test("promotes surviving dependent view when its referenced table is dropped without a same-name create", async () => {
+    // Reproduces issue #228 case 3: ALTER TABLE users RENAME TO members.
+    // pg-delta sees `users` as drop-only and `members` as create-only — the
+    // stableIds differ, so neither is in the createdIds∩droppedIds replace
+    // root set. The dependent view `user_count` exists in both catalogs
+    // (its definition was rewritten to FROM members in branch). Without
+    // expansion, DROP TABLE users would fail because user_count still
+    // references it. The expander must seed the drop-only table as a root
+    // so the surviving dependent gets promoted to DROP+CREATE.
+    const baseline = await createEmptyCatalog(170000, "postgres");
+    const usersTable = new Table({
+      schema: "public",
+      name: "users",
+      persistence: "p",
+      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",
+      is_partition: false,
+      options: null,
+      partition_bound: null,
+      partition_by: null,
+      owner: "postgres",
+      comment: null,
+      parent_schema: null,
+      parent_name: null,
+      columns: [
+        {
+          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: null,
+          comment: null,
+        },
+      ],
+      privileges: [],
+    });
+    const mainView = new View({
+      schema: "public",
+      name: "user_count",
+      owner: "postgres",
+      definition: " SELECT count(*) AS n FROM public.users;",
+      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",
+      is_partition: false,
+      partition_bound: null,
+      comment: null,
+      columns: [
+        {
+          name: "n",
+          position: 1,
+          data_type: "bigint",
+          data_type_str: "bigint",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: null,
+          comment: null,
+        },
+      ],
+      options: null,
+      privileges: [],
+    });
+    const branchView = new View({
+      ...mainView,
+      definition: " SELECT count(*) AS n FROM public.members;",
+    });
+
+    const mainCatalog = new Catalog({
+      ...baseline,
+      tables: { [usersTable.stableId]: usersTable },
+      views: { [mainView.stableId]: mainView },
+      depends: [
+        {
+          dependent_stable_id: mainView.stableId,
+          referenced_stable_id: usersTable.stableId,
+          deptype: "n",
+        },
+      ],
+    });
+    const branchCatalog = new Catalog({
+      ...baseline,
+      views: { [branchView.stableId]: branchView },
+    });
+
+    // Simulated planner output: DropTable(users) + CreateView orReplace(user_count).
+    // The surviving view appears only as a "create" (CREATE OR REPLACE VIEW),
+    // never as a drop, so DROP TABLE users would fail without expansion.
+    const changes: Change[] = [
+      new DropTable({ table: usersTable }),
+      new CreateView({ view: branchView, orReplace: true }),
+    ];
+    const result = expandReplaceDependencies({
+      changes,
+      mainCatalog,
+      branchCatalog,
+    });
+
+    // The view's surviving CREATE OR REPLACE remains, AND a DropView is
+    // injected so the drop phase removes the view before the table.
+    expect(result.changes.some((c) => c instanceof DropView)).toBe(true);
+  });
+
   test("does not replace the owning table for an owned sequence recreation", async () => {
     const baseline = await createEmptyCatalog(170000, "postgres");
+    // Use `persistence` (UNLOGGED → LOGGED) to trigger the
+    // non-alterable replace path: it's the only field still in
+    // NON_ALTERABLE_FIELDS. `data_type` was previously in that list
+    // but is now alterable in place via ALTER SEQUENCE ... AS <type>.
     const mainSequence = new Sequence({
       schema: "public",
       name: "user_id_seq",
-      data_type: "integer",
+      data_type: "bigint",
       start_value: 1,
       minimum_value: 1n,
-      maximum_value: 2147483647n,
+      maximum_value: 9223372036854775807n,
       increment: 1,
       cycle_option: false,
       cache_size: 1,
-      persistence: "p",
+      persistence: "u",
       owned_by_schema: "public",
       owned_by_table: "users",
       owned_by_column: "id",
@@ -119,8 +254,7 @@ describe("expandReplaceDependencies", () => {
     });
     const branchSequence = new Sequence({
       ...mainSequence,
-      data_type: "bigint",
-      maximum_value: 9223372036854775807n,
+      persistence: "p",
     });
     const usersTable = new Table({
       schema: "public",

package/src/core/expand-replace-dependencies.ts

@@ -129,6 +129,30 @@ export function expandReplaceDependencies({
     }
   }
 
+  // Drop-only objects (no matching create — typically a renamed-away table or
+  // type) are also expansion roots: anything in main that depends on them via
+  // pg_depend must drop before the parent does. Without this seed, a renamed
+  // table whose dependent view stays in the branch catalog (with an updated
+  // definition that no longer references the old name) would still try to
+  // run DROP TABLE old_name while old_name is referenced by the view, which
+  // PostgreSQL refuses without CASCADE. The walk below promotes the surviving
+  // dependent to DROP+CREATE so its drop is sequenced before the parent drop.
+  for (const id of droppedIds) {
+    if (createdIds.has(id)) continue;
+    if (replaceRoots.has(id)) continue;
+    // Only seed for object kinds that can have catalog dependents we know
+    // how to recreate via buildReplaceChanges.
+    if (
+      id.startsWith("table:") ||
+      id.startsWith("view:") ||
+      id.startsWith("materializedView:") ||
+      id.startsWith("type:") ||
+      id.startsWith("domain:")
+    ) {
+      replaceRoots.add(id);
+    }
+  }
+
   if (replaceRoots.size === 0) {
     return {
       changes,

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/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)");
+  });
 });