bunsql-native-migrate 0.2.0 → 0.3.1

package/src/api/up.ts

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { checksumFile, listFiles, MIGRATION_EXTENSIONS, resolveListDir } from "../core/fs.js";
 import { log } from "../core/console.js";
+import { formatDuration } from "../core/duration.js";
 import {
   type MigrateUpOptions,
   type MigrateUpResult,
@@ -9,17 +10,22 @@ import {
 } from "./options.js";
 import { runWithDriver } from "./run-with-driver.js";
 import { runMigrationStep } from "./run-step.js";
+import { loadMigration } from "./load-migration.js";
 import { resolveLockTimeout, withMigrationLock } from "./lock.js";
+import { ensureTrackingTable, listExecutedForPlan } from "./tracking-table.js";
 
 export async function migrateUp(options: MigrateUpOptions = {}): Promise<MigrateUpResult> {
   const listDir = resolveListDir(options.listDir);
   const target = options.to;
+  const dryRun = options.dryRun ?? false;
   const lockTimeout = resolveLockTimeout(options.lockTimeout);
 
   return runWithDriver(options, async (driver) => {
-    await driver.install();
+    if (!dryRun) {
+      await ensureTrackingTable(driver);
+    }
 
-    return withMigrationLock(driver, lockTimeout, async () => {
+    const run = async (): Promise<MigrateUpResult> => {
       const allFiles = await listFiles(listDir, MIGRATION_EXTENSIONS);
       if (target !== undefined && !allFiles.includes(target)) {
         throw new MigrationNotFoundError(target);
@@ -33,7 +39,7 @@ export async function migrateUp(options: MigrateUpOptions = {}): Promise<Migrate
         ),
       );
 
-      const executed = await driver.listExecuted();
+      const executed = dryRun ? await listExecutedForPlan(driver) : await driver.listExecuted();
       const executedByName = new Map(executed.map((entry) => [entry.name, entry]));
 
       for (const [file, checksum] of checksums) {
@@ -41,8 +47,10 @@ export async function migrateUp(options: MigrateUpOptions = {}): Promise<Migrate
         if (!record) continue;
 
         if (record.checksum === null) {
-          await driver.setChecksum(file, checksum);
-          log({ text: `${file} checksum saved (legacy record)`, type: "info" });
+          if (!dryRun) {
+            await driver.setChecksum(file, checksum);
+            log({ text: `${file} checksum saved (legacy record)`, type: "info" });
+          }
           continue;
         }
 
@@ -55,11 +63,22 @@ export async function migrateUp(options: MigrateUpOptions = {}): Promise<Migrate
       if (target !== undefined) {
         if (executedByName.has(target)) {
           log({ text: `${target} is already applied.`, type: "info" });
-          return { applied: [] };
+          return dryRun ? { applied: [], planned: [] } : { applied: [] };
         }
         pending = pending.slice(0, pending.indexOf(target) + 1);
       }
 
+      if (dryRun) {
+        log({ text: "Dry run — no changes will be made.", type: "info" });
+        if (pending.length === 0) {
+          log({ text: "No pending migrations.", type: "warn" });
+        }
+        for (const file of pending) {
+          log({ text: `${file} would be applied`, type: "info" });
+        }
+        return { applied: [], planned: pending };
+      }
+
       const applied: string[] = [];
 
       if (pending.length === 0) {
@@ -71,15 +90,15 @@ export async function migrateUp(options: MigrateUpOptions = {}): Promise<Migrate
         const checksum = checksums.get(file);
         if (!checksum) continue;
         try {
-          const mod = await import(path.join(listDir, file));
-          if (typeof mod.up !== "function") {
+          const { up } = await loadMigration(listDir, file);
+          if (up === null) {
             log({ text: `${file} has no up() export, skipping`, type: "warn" });
             continue;
           }
-          await runMigrationStep(driver, mod.up);
+          const durationMs = await runMigrationStep(driver, up);
           await driver.record(file, checksum);
           applied.push(file);
-          log({ text: `${file} migrated up`, type: "success" });
+          log({ text: `${file} migrated up (${formatDuration(durationMs)})`, type: "success" });
         } catch (error) {
           log({ text: `${file} migration failed`, type: "error", error });
           throw error;
@@ -87,6 +106,11 @@ export async function migrateUp(options: MigrateUpOptions = {}): Promise<Migrate
       }
 
       return { applied };
-    });
+    };
+
+    if (dryRun) {
+      return run();
+    }
+    return withMigrationLock(driver, lockTimeout, run);
   });
 }

package/src/cli/main.ts

@@ -4,7 +4,10 @@ import { migrateDown } from "../api/down.js";
 import { migrateStatus } from "../api/status.js";
 import { installMigrations } from "../api/install.js";
 import { createMigrationCommand, type MigrationLang } from "../api/create.js";
+import { initMigrations } from "../api/init.js";
+import { markMigrationsApplied } from "../api/mark.js";
 import { ChecksumDriftError, MigrationLockError, MigrationNotFoundError } from "../api/options.js";
+import { InvalidIdentifierError } from "../core/identifiers.js";
 import { log } from "../core/console.js";
 
 interface CliArgs {
@@ -15,6 +18,9 @@ interface CliArgs {
   lang?: MigrationLang | undefined;
   to?: string | undefined;
   lockTimeout?: number | undefined;
+  table?: string | undefined;
+  schema?: string | undefined;
+  dryRun: boolean;
   all: boolean;
   strict: boolean;
   help: boolean;
@@ -27,6 +33,9 @@ function parseArgs(argv: string[]): CliArgs {
   let lang: MigrationLang | undefined;
   let to: string | undefined;
   let lockTimeout: number | undefined;
+  let table: string | undefined;
+  let schema: string | undefined;
+  let dryRun = false;
   let all = false;
   let strict = false;
   let help = false;
@@ -63,8 +72,22 @@ function parseArgs(argv: string[]): CliArgs {
         usage(1);
       }
       lockTimeout = parsed;
+    } else if (arg === "--table") {
+      table = argv[++i];
+      if (table === undefined) {
+        log({ text: "--table requires a tracking table name", type: "error" });
+        usage(1);
+      }
+    } else if (arg === "--schema") {
+      schema = argv[++i];
+      if (schema === undefined) {
+        log({ text: "--schema requires a postgres schema name", type: "error" });
+        usage(1);
+      }
     } else if (arg === "--all") {
       all = true;
+    } else if (arg === "--dry-run") {
+      dryRun = true;
     } else if (arg === "--strict") {
       strict = true;
     } else if (arg === "--help" || arg === "-h") {
@@ -81,6 +104,9 @@ function parseArgs(argv: string[]): CliArgs {
     lang,
     to,
     lockTimeout,
+    table,
+    schema,
+    dryRun,
     all,
     strict,
     help,
@@ -89,7 +115,7 @@ function parseArgs(argv: string[]): CliArgs {
 
 function usage(exitCode: number): never {
   log({
-    text: "Usage: bunsql-native-migrate <up|down [n]|install|create [name]|status> [--dir <migrations-dir>] [--to <name>] [--lock-timeout <seconds>] [--all] [--lang <js|ts>] [--git] [--strict] [--help]",
+    text: "Usage: bunsql-native-migrate <init|up|down [n]|install|create [name]|mark [name]|status> [--dir <migrations-dir>] [--to <name>] [--lock-timeout <seconds>] [--table <name>] [--schema <name>] [--dry-run] [--all] [--lang <js|ts>] [--git] [--strict] [--help]",
     type: "info",
   });
   process.exit(exitCode);
@@ -97,6 +123,10 @@ function usage(exitCode: number): never {
 
 const args = parseArgs(process.argv.slice(2));
 const listDirOptions = args.dir ? { listDir: args.dir } : {};
+const tableOptions = {
+  ...(args.table !== undefined ? { tableName: args.table } : {}),
+  ...(args.schema !== undefined ? { schema: args.schema } : {}),
+};
 
 if (args.help) {
   usage(0);
@@ -105,11 +135,16 @@ if (args.help) {
 try {
   switch (args.command) {
     case "up": {
-      const { applied } = await migrateUp({
+      const { applied, planned } = await migrateUp({
         ...listDirOptions,
+        ...tableOptions,
         ...(args.to ? { to: args.to } : {}),
         ...(args.lockTimeout !== undefined ? { lockTimeout: args.lockTimeout } : {}),
+        ...(args.dryRun ? { dryRun: true } : {}),
       });
+      if (planned !== undefined && planned.length > 0) {
+        log({ text: `Would apply ${planned.length} migration(s).`, type: "info" });
+      }
       if (applied.length > 0) {
         log({ text: `Applied ${applied.length} migration(s).`, type: "success" });
       }
@@ -135,14 +170,29 @@ try {
         }
         steps = parsed;
       }
-      const { reverted } = await migrateDown({ ...listDirOptions, steps });
+      const { reverted, planned } = await migrateDown({
+        ...listDirOptions,
+        ...tableOptions,
+        steps,
+        ...(args.dryRun ? { dryRun: true } : {}),
+      });
+      if (planned !== undefined && planned.length > 0) {
+        log({ text: `Would revert ${planned.length} migration(s).`, type: "info" });
+      }
       if (reverted.length > 0) {
         log({ text: `Reverted ${reverted.length} migration(s).`, type: "success" });
       }
       break;
     }
+    case "init": {
+      await initMigrations({
+        ...listDirOptions,
+        ...(args.lang !== undefined ? { lang: args.lang } : {}),
+      });
+      break;
+    }
     case "install": {
-      await installMigrations(listDirOptions);
+      await installMigrations({ ...listDirOptions, ...tableOptions });
       break;
     }
     case "create": {
@@ -155,8 +205,28 @@ try {
       });
       break;
     }
+    case "mark": {
+      const [name] = args.positional;
+      if (args.all && name !== undefined) {
+        log({ text: "Use either --all or a migration file name, not both.", type: "error" });
+        usage(1);
+      }
+      if (!args.all && name === undefined) {
+        log({ text: "mark requires a migration file name or --all.", type: "error" });
+        usage(1);
+      }
+      const { marked } = await markMigrationsApplied({
+        ...listDirOptions,
+        ...tableOptions,
+        ...(name !== undefined ? { to: name } : {}),
+      });
+      if (marked.length > 0) {
+        log({ text: `Marked ${marked.length} migration(s) as applied.`, type: "success" });
+      }
+      break;
+    }
     case "status": {
-      const { applied, pending } = await migrateStatus(listDirOptions);
+      const { applied, pending } = await migrateStatus({ ...listDirOptions, ...tableOptions });
       for (const entry of applied) {
         log({ text: `${entry.name} applied`, type: "info" });
       }
@@ -177,7 +247,8 @@ try {
   if (
     error instanceof ChecksumDriftError ||
     error instanceof MigrationNotFoundError ||
-    error instanceof MigrationLockError
+    error instanceof MigrationLockError ||
+    error instanceof InvalidIdentifierError
   ) {
     log({ text: error.message, type: "error" });
   } else {

package/src/core/driver.ts

@@ -12,12 +12,22 @@ export interface MigrationDriver {
   setChecksum(migration: string, checksum: string): Promise<void>;
   remove(migration: string): Promise<void>;
   transaction<T>(run: (tx: SQL) => Promise<T>): Promise<T>;
+  trackingTableExists?(): Promise<boolean>;
+  trackingTableCurrent?(): Promise<boolean>;
   tryLock?(timeoutSeconds: number): Promise<boolean>;
   releaseLock?(): Promise<void>;
   close(): Promise<void>;
 }
 
-export async function createDriver(databaseUrl: string): Promise<MigrationDriver> {
+export interface DriverTableOptions {
+  tableName?: string;
+  schema?: string;
+}
+
+export async function createDriver(
+  databaseUrl: string,
+  options: DriverTableOptions = {},
+): Promise<MigrationDriver> {
   let protocol: string;
   try {
     protocol = new URL(databaseUrl).protocol.replace(":", "");
@@ -28,20 +38,25 @@ export async function createDriver(databaseUrl: string): Promise<MigrationDriver
       throw new Error(`Cannot parse database URL: ${databaseUrl}`);
     }
   }
+  if (options.schema !== undefined && protocol !== "postgres" && protocol !== "postgresql") {
+    throw new Error(
+      "The schema option is only supported for postgres URLs — MySQL/MariaDB selects the database in the URL, SQLite has no schemas",
+    );
+  }
   switch (protocol) {
     case "postgres":
     case "postgresql": {
       const mod = await import("./../drivers/postgres.js");
-      return mod.create(databaseUrl);
+      return mod.create(databaseUrl, options);
     }
     case "sqlite": {
       const mod = await import("./../drivers/sqlite.js");
-      return mod.create(databaseUrl);
+      return mod.create(databaseUrl, options);
     }
     case "mariadb":
     case "mysql": {
       const mod = await import("./../drivers/mariadb.js");
-      return mod.create(databaseUrl);
+      return mod.create(databaseUrl, options);
     }
     default:
       throw new Error(

package/src/core/duration.ts

@@ -0,0 +1,7 @@
+export function formatDuration(durationMs: number): string {
+  const roundedMs = Math.round(durationMs);
+  if (roundedMs < 1000) {
+    return `${roundedMs}ms`;
+  }
+  return `${(durationMs / 1000).toFixed(1)}s`;
+}

package/src/core/fs.ts

@@ -3,7 +3,7 @@ import path from "node:path";
 
 export const DEFAULT_MIGRATIONS_DIR = "migrations";
 
-export const MIGRATION_EXTENSIONS = ["js", "ts"] as const;
+export const MIGRATION_EXTENSIONS = ["js", "ts", "up.sql"] as const;
 
 export async function listFiles(dir: string, extensions: readonly string[]): Promise<string[]> {
   const matchedFiles: string[] = [];

package/src/core/identifiers.ts

@@ -0,0 +1,32 @@
+export type IdentifierKind = "table" | "schema";
+
+const IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_$]*$/;
+
+export class InvalidIdentifierError extends Error {
+  readonly kind: IdentifierKind;
+  readonly value: string;
+
+  constructor(kind: IdentifierKind, value: string, maxLength: number) {
+    super(
+      `Invalid ${kind} name: "${value}" — expected an identifier of letters, digits, underscores and dollar signs ` +
+        `starting with a letter or underscore, at most ${maxLength} characters`,
+    );
+    this.name = "InvalidIdentifierError";
+    this.kind = kind;
+    this.value = value;
+  }
+}
+
+export function validateIdentifier(kind: IdentifierKind, value: string, maxLength: number): void {
+  if (!IDENTIFIER_PATTERN.test(value) || value.length > maxLength) {
+    throw new InvalidIdentifierError(kind, value, maxLength);
+  }
+}
+
+export function doubleQuoted(name: string): string {
+  return `"${name}"`;
+}
+
+export function backtickQuoted(name: string): string {
+  return `\`${name}\``;
+}

package/src/drivers/mariadb.ts

@@ -1,59 +1,103 @@
 import { type SQL } from "bun";
-import type { MigrationDriver } from "../core/driver.js";
+import type { DriverTableOptions, MigrationDriver } from "../core/driver.js";
+import { backtickQuoted, validateIdentifier } from "../core/identifiers.js";
 import { createReservedLock, createSqlDriver } from "./shared.js";
 
 const LOCK_NAME_PREFIX = "bunsql-native-migrate:";
 
-async function checksumColumnExists(db: SQL): Promise<boolean> {
+const TABLE_NAME_MAX_LENGTH = 47;
+const UNIQUE_INDEX_SUFFIX = "_migration_unique";
+
+function resolveTableRef(options: DriverTableOptions): {
+  table: string;
+  index: string;
+  name: string;
+} {
+  const tableName = options.tableName ?? "migrations";
+  validateIdentifier("table", tableName, TABLE_NAME_MAX_LENGTH);
+  return {
+    table: backtickQuoted(tableName),
+    index: backtickQuoted(`${tableName}${UNIQUE_INDEX_SUFFIX}`),
+    name: tableName,
+  };
+}
+
+async function checksumColumnExists(db: SQL, tableName: string): Promise<boolean> {
   const rows = await db`SELECT column_name FROM information_schema.columns
     WHERE table_schema = DATABASE()
-      AND table_name = 'migrations'
+      AND table_name = ${tableName}
       AND column_name = 'checksum'`;
   return rows.length > 0;
 }
 
-async function uniqueIndexExists(db: SQL): Promise<boolean> {
+async function uniqueIndexExists(db: SQL, tableName: string): Promise<boolean> {
   const rows = await db`SELECT index_name FROM information_schema.statistics
     WHERE table_schema = DATABASE()
-      AND table_name = 'migrations'
-      AND index_name = 'migrations_migration_unique'`;
+      AND table_name = ${tableName}
+      AND index_name = ${`${tableName}${UNIQUE_INDEX_SUFFIX}`}`;
   return rows.length > 0;
 }
 
-export function create(databaseUrl: string): MigrationDriver {
-  return createSqlDriver(databaseUrl, {
-    async install(db) {
-      await db`CREATE TABLE IF NOT EXISTS migrations (
-        id INTEGER PRIMARY KEY AUTO_INCREMENT,
-        migration VARCHAR(255) NOT NULL,
-        checksum VARCHAR(64),
-        CONSTRAINT migrations_migration_unique UNIQUE (migration)
-      )`;
-      if (!(await checksumColumnExists(db))) {
-        await db`ALTER TABLE migrations ADD COLUMN checksum VARCHAR(64)`;
-      }
-      if (!(await uniqueIndexExists(db))) {
-        await db`CREATE UNIQUE INDEX migrations_migration_unique ON migrations (migration)`;
-      }
-    },
-    async record(db, migration, checksum) {
-      await db`INSERT IGNORE INTO migrations (migration, checksum)
-        VALUES (${migration}, ${checksum})`;
+export function create(databaseUrl: string, options: DriverTableOptions = {}): MigrationDriver {
+  const { table, index, name } = resolveTableRef(options);
+  return createSqlDriver(
+    databaseUrl,
+    {
+      async install(db) {
+        await db`CREATE TABLE IF NOT EXISTS ${db.unsafe(table)} (
+          id INTEGER PRIMARY KEY AUTO_INCREMENT,
+          migration VARCHAR(255) NOT NULL,
+          checksum VARCHAR(64),
+          CONSTRAINT ${db.unsafe(index)} UNIQUE (migration)
+        )`;
+        if (!(await checksumColumnExists(db, name))) {
+          await db`ALTER TABLE ${db.unsafe(table)} ADD COLUMN checksum VARCHAR(64)`;
+        }
+        if (!(await uniqueIndexExists(db, name))) {
+          await db`CREATE UNIQUE INDEX ${db.unsafe(index)} ON ${db.unsafe(table)} (migration)`;
+        }
+      },
+      async trackingTableExists(db) {
+        const rows = await db`SELECT 1 FROM information_schema.tables
+          WHERE table_schema = DATABASE()
+            AND table_name = ${name}`;
+        return rows.length > 0;
+      },
+      async trackingTableCurrent(db) {
+        const rows = (await db`SELECT EXISTS (
+            SELECT 1 FROM information_schema.tables
+            WHERE table_schema = DATABASE() AND table_name = ${name}
+          ) AND EXISTS (
+            SELECT 1 FROM information_schema.columns
+            WHERE table_schema = DATABASE() AND table_name = ${name} AND column_name = 'checksum'
+          ) AND EXISTS (
+            SELECT 1 FROM information_schema.statistics
+            WHERE table_schema = DATABASE() AND table_name = ${name}
+              AND index_name = ${`${name}${UNIQUE_INDEX_SUFFIX}`}
+          ) AS current`) as Array<{ current: number | boolean }>;
+        const current = rows[0]?.current;
+        return current === 1 || current === true;
+      },
+      async record(db, migration, checksum) {
+        await db`INSERT IGNORE INTO ${db.unsafe(table)} (migration, checksum)
+          VALUES (${migration}, ${checksum})`;
+      },
+      createLock: (db) =>
+        createReservedLock(
+          db,
+          async (lock) => {
+            const rows =
+              (await lock`SELECT GET_LOCK(CONCAT(${LOCK_NAME_PREFIX}, MD5(DATABASE())), 0) AS locked`) as Array<{
+                locked: number | string | null;
+              }>;
+            const locked = rows[0]?.locked;
+            return locked === 1 || locked === "1";
+          },
+          async (lock) => {
+            await lock`SELECT RELEASE_LOCK(CONCAT(${LOCK_NAME_PREFIX}, MD5(DATABASE())))`;
+          },
+        ),
     },
-    createLock: (db) =>
-      createReservedLock(
-        db,
-        async (lock) => {
-          const rows =
-            (await lock`SELECT GET_LOCK(CONCAT(${LOCK_NAME_PREFIX}, MD5(DATABASE())), 0) AS locked`) as Array<{
-              locked: number | string | null;
-            }>;
-          const locked = rows[0]?.locked;
-          return locked === 1 || locked === "1";
-        },
-        async (lock) => {
-          await lock`SELECT RELEASE_LOCK(CONCAT(${LOCK_NAME_PREFIX}, MD5(DATABASE())))`;
-        },
-      ),
-  });
+    table,
+  );
 }

package/src/drivers/postgres.ts

@@ -1,46 +1,98 @@
 import { type SQL } from "bun";
-import type { MigrationDriver } from "../core/driver.js";
+import type { DriverTableOptions, MigrationDriver } from "../core/driver.js";
+import { doubleQuoted, validateIdentifier } from "../core/identifiers.js";
 import { createReservedLock, createSqlDriver } from "./shared.js";
 
 const LOCK_SCOPE = "bunsql-native-migrate:up";
 
+const IDENTIFIER_MAX_LENGTH = 63;
+const UNIQUE_INDEX_SUFFIX = "_migration_unique";
+
+interface TableRef {
+  table: string;
+  index: string;
+  name: string;
+  schemaName?: string;
+}
+
+function resolveTableRef(options: DriverTableOptions): TableRef {
+  const tableName = options.tableName ?? "migrations";
+  validateIdentifier("table", tableName, IDENTIFIER_MAX_LENGTH);
+  const index = doubleQuoted(`${tableName}${UNIQUE_INDEX_SUFFIX}`);
+  if (options.schema === undefined) {
+    return { table: doubleQuoted(tableName), index, name: tableName };
+  }
+  validateIdentifier("schema", options.schema, IDENTIFIER_MAX_LENGTH);
+  return {
+    table: `${doubleQuoted(options.schema)}.${doubleQuoted(tableName)}`,
+    index,
+    name: tableName,
+    schemaName: options.schema,
+  };
+}
+
 async function advisoryKeyComponents(lock: SQL): Promise<[number, number]> {
   const rows = (await lock`SELECT current_database() AS name`) as Array<{ name: string }>;
   const hash = Bun.hash.wyhash(`${LOCK_SCOPE}:${rows[0]?.name ?? ""}`);
   return [Number((hash >> 32n) & 0x7fffffffn), Number(hash & 0x7fffffffn)];
 }
 
-export function create(databaseUrl: string): MigrationDriver {
-  return createSqlDriver(databaseUrl, {
-    async install(db) {
-      await db`CREATE TABLE IF NOT EXISTS migrations (
-        id SERIAL PRIMARY KEY,
-        migration VARCHAR(255) NOT NULL,
-        checksum VARCHAR(64)
-      )`;
-      await db`ALTER TABLE migrations ADD COLUMN IF NOT EXISTS checksum VARCHAR(64)`;
-      await db`CREATE UNIQUE INDEX IF NOT EXISTS migrations_migration_unique ON migrations (migration)`;
-    },
-    async record(db, migration, checksum) {
-      await db`INSERT INTO migrations (migration, checksum)
-        VALUES (${migration}, ${checksum})
-        ON CONFLICT (migration) DO NOTHING`;
+export function create(databaseUrl: string, options: DriverTableOptions = {}): MigrationDriver {
+  const { table, index, name, schemaName } = resolveTableRef(options);
+  return createSqlDriver(
+    databaseUrl,
+    {
+      async install(db) {
+        await db`CREATE TABLE IF NOT EXISTS ${db.unsafe(table)} (
+          id SERIAL PRIMARY KEY,
+          migration VARCHAR(255) NOT NULL,
+          checksum VARCHAR(64)
+        )`;
+        await db`ALTER TABLE ${db.unsafe(table)} ADD COLUMN IF NOT EXISTS checksum VARCHAR(64)`;
+        await db`CREATE UNIQUE INDEX IF NOT EXISTS ${db.unsafe(index)} ON ${db.unsafe(table)} (migration)`;
+      },
+      async trackingTableExists(db) {
+        const rows = schemaName
+          ? await db`SELECT 1 FROM information_schema.tables
+              WHERE table_schema = ${schemaName} AND table_name = ${name}`
+          : await db`SELECT 1 FROM information_schema.tables
+              WHERE table_schema = current_schema() AND table_name = ${name}`;
+        return rows.length > 0;
+      },
+      async trackingTableCurrent(db) {
+        const rows = (await db`SELECT EXISTS (
+            SELECT 1 FROM information_schema.columns
+            WHERE table_schema = COALESCE(${schemaName ?? null}, current_schema())
+              AND table_name = ${name} AND column_name = 'checksum'
+          ) AND EXISTS (
+            SELECT 1 FROM pg_indexes
+            WHERE schemaname = COALESCE(${schemaName ?? null}, current_schema())
+              AND indexname = ${`${name}${UNIQUE_INDEX_SUFFIX}`}
+          ) AS "current"`) as Array<{ current: boolean }>;
+        return rows[0]?.current === true;
+      },
+      async record(db, migration, checksum) {
+        await db`INSERT INTO ${db.unsafe(table)} (migration, checksum)
+          VALUES (${migration}, ${checksum})
+          ON CONFLICT (migration) DO NOTHING`;
+      },
+      createLock: (db) =>
+        createReservedLock(
+          db,
+          async (lock) => {
+            const [first, second] = await advisoryKeyComponents(lock);
+            const rows =
+              (await lock`SELECT pg_try_advisory_lock(${first}, ${second}) AS locked`) as Array<{
+                locked: boolean;
+              }>;
+            return rows[0]?.locked === true;
+          },
+          async (lock) => {
+            const [first, second] = await advisoryKeyComponents(lock);
+            await lock`SELECT pg_advisory_unlock(${first}, ${second})`;
+          },
+        ),
     },
-    createLock: (db) =>
-      createReservedLock(
-        db,
-        async (lock) => {
-          const [first, second] = await advisoryKeyComponents(lock);
-          const rows =
-            (await lock`SELECT pg_try_advisory_lock(${first}, ${second}) AS locked`) as Array<{
-              locked: boolean;
-            }>;
-          return rows[0]?.locked === true;
-        },
-        async (lock) => {
-          const [first, second] = await advisoryKeyComponents(lock);
-          await lock`SELECT pg_advisory_unlock(${first}, ${second})`;
-        },
-      ),
-  });
+    table,
+  );
 }