bunsql-native-migrate 0.3.1 → 0.4.0

package/src/core/console.ts

@@ -13,32 +13,32 @@ interface LogOptions {
   error?: unknown;
 }
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
-function formatError(error: any): void {
+function formatError(error: unknown): void {
   if (error instanceof Error) {
     console.log(error.message);
     if (error.stack) console.log(error.stack);
     return;
   }
-  if (typeof error === "object" && error !== null) {
-    if ("code" in error && "detail" in error) {
-      console.table(error);
-      return;
-    }
-    if ("code" in error && "errno" in error) {
-      console.log(error.code);
-      console.log(error.errno);
-      if ("byteOffset" in error) console.log(error.byteOffset);
-      return;
-    }
-    if ("message" in error) {
-      console.log(error.message);
-      return;
-    }
+  if (typeof error !== "object" || error === null) {
+    console.log(String(error));
+    return;
+  }
+  if ("code" in error && "detail" in error) {
+    console.table(error);
+    return;
+  }
+  if ("code" in error && "errno" in error) {
+    console.log(error.code);
+    console.log(error.errno);
+    if ("byteOffset" in error) console.log(error.byteOffset);
+    return;
+  }
+  if ("message" in error) {
+    console.log(error.message);
+    return;
   }
   console.log(String(error));
 }
-/* eslint-enable @typescript-eslint/no-explicit-any */
 
 export function log({ text, type, error = null }: LogOptions): void {
   console.log(colors[type], text);

package/src/core/driver.ts

@@ -17,6 +17,7 @@ export interface MigrationDriver {
   tryLock?(timeoutSeconds: number): Promise<boolean>;
   releaseLock?(): Promise<void>;
   close(): Promise<void>;
+  client?(): SQL;
 }
 
 export interface DriverTableOptions {

package/src/core/duration.ts

@@ -1,3 +1,19 @@
+export function resolveSecondsOption(
+  option: string,
+  value: number | undefined,
+  fallback: number,
+): number {
+  if (value === undefined) {
+    return fallback;
+  }
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(
+      `Invalid ${option}: ${String(value)} — expected a non-negative integer of seconds`,
+    );
+  }
+  return value;
+}
+
 export function formatDuration(durationMs: number): string {
   const roundedMs = Math.round(durationMs);
   if (roundedMs < 1000) {

package/src/drivers/mariadb.ts

@@ -1,26 +1,16 @@
 import { type SQL } from "bun";
 import type { DriverTableOptions, MigrationDriver } from "../core/driver.js";
-import { backtickQuoted, validateIdentifier } from "../core/identifiers.js";
-import { createReservedLock, createSqlDriver } from "./shared.js";
+import { backtickQuoted } from "../core/identifiers.js";
+import {
+  createReservedLock,
+  createSqlDriver,
+  resolveTableRef,
+  UNIQUE_INDEX_SUFFIX,
+} from "./shared.js";
 
 const LOCK_NAME_PREFIX = "bunsql-native-migrate:";
 
 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
@@ -39,7 +29,10 @@ async function uniqueIndexExists(db: SQL, tableName: string): Promise<boolean> {
 }
 
 export function create(databaseUrl: string, options: DriverTableOptions = {}): MigrationDriver {
-  const { table, index, name } = resolveTableRef(options);
+  const { table, index, name } = resolveTableRef(options, {
+    quote: backtickQuoted,
+    maxLength: TABLE_NAME_MAX_LENGTH,
+  });
   return createSqlDriver(
     databaseUrl,
     {

package/src/drivers/postgres.ts

@@ -1,32 +1,34 @@
 import { type SQL } from "bun";
 import type { DriverTableOptions, MigrationDriver } from "../core/driver.js";
 import { doubleQuoted, validateIdentifier } from "../core/identifiers.js";
-import { createReservedLock, createSqlDriver } from "./shared.js";
+import {
+  createReservedLock,
+  createSqlDriver,
+  resolveTableRef,
+  UNIQUE_INDEX_SUFFIX,
+  type TableRef,
+} 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;
+interface PostgresTableRef extends TableRef {
   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}`);
+function resolvePostgresTableRef(options: DriverTableOptions): PostgresTableRef {
+  const base = resolveTableRef(options, {
+    quote: doubleQuoted,
+    maxLength: IDENTIFIER_MAX_LENGTH,
+  });
   if (options.schema === undefined) {
-    return { table: doubleQuoted(tableName), index, name: tableName };
+    return base;
   }
   validateIdentifier("schema", options.schema, IDENTIFIER_MAX_LENGTH);
   return {
-    table: `${doubleQuoted(options.schema)}.${doubleQuoted(tableName)}`,
-    index,
-    name: tableName,
+    ...base,
+    table: `${doubleQuoted(options.schema)}.${base.table}`,
     schemaName: options.schema,
   };
 }
@@ -38,7 +40,7 @@ async function advisoryKeyComponents(lock: SQL): Promise<[number, number]> {
 }
 
 export function create(databaseUrl: string, options: DriverTableOptions = {}): MigrationDriver {
-  const { table, index, name, schemaName } = resolveTableRef(options);
+  const { table, index, name, schemaName } = resolvePostgresTableRef(options);
   return createSqlDriver(
     databaseUrl,
     {
@@ -76,11 +78,18 @@ export function create(databaseUrl: string, options: DriverTableOptions = {}): M
           VALUES (${migration}, ${checksum})
           ON CONFLICT (migration) DO NOTHING`;
       },
-      createLock: (db) =>
-        createReservedLock(
+      createLock: (db) => {
+        let cachedKey: [number, number] | null = null;
+        const resolveAdvisoryKey = async (lock: SQL): Promise<[number, number]> => {
+          if (cachedKey === null) {
+            cachedKey = await advisoryKeyComponents(lock);
+          }
+          return cachedKey;
+        };
+        return createReservedLock(
           db,
           async (lock) => {
-            const [first, second] = await advisoryKeyComponents(lock);
+            const [first, second] = await resolveAdvisoryKey(lock);
             const rows =
               (await lock`SELECT pg_try_advisory_lock(${first}, ${second}) AS locked`) as Array<{
                 locked: boolean;
@@ -88,10 +97,11 @@ export function create(databaseUrl: string, options: DriverTableOptions = {}): M
             return rows[0]?.locked === true;
           },
           async (lock) => {
-            const [first, second] = await advisoryKeyComponents(lock);
+            const [first, second] = await resolveAdvisoryKey(lock);
             await lock`SELECT pg_advisory_unlock(${first}, ${second})`;
           },
-        ),
+        );
+      },
     },
     table,
   );

package/src/drivers/shared.ts

@@ -1,5 +1,29 @@
 import { SQL, type ReservedSQL } from "bun";
-import type { ExecutedMigration, MigrationDriver } from "../core/driver.js";
+import type { DriverTableOptions, ExecutedMigration, MigrationDriver } from "../core/driver.js";
+import { validateIdentifier } from "../core/identifiers.js";
+
+export const UNIQUE_INDEX_SUFFIX = "_migration_unique";
+
+export interface TableRef {
+  table: string;
+  index: string;
+  name: string;
+}
+
+interface TableRefSpec {
+  quote: (identifier: string) => string;
+  maxLength: number;
+}
+
+export function resolveTableRef(options: DriverTableOptions, spec: TableRefSpec): TableRef {
+  const tableName = options.tableName ?? "migrations";
+  validateIdentifier("table", tableName, spec.maxLength);
+  return {
+    table: spec.quote(tableName),
+    index: spec.quote(`${tableName}${UNIQUE_INDEX_SUFFIX}`),
+    name: tableName,
+  };
+}
 
 export interface SqlLock {
   tryLock(timeoutSeconds: number): Promise<boolean>;
@@ -23,7 +47,10 @@ export function createReservedLock(
   let lockConnection: ReservedSQL | null = null;
 
   return {
-    async tryLock() {
+    async tryLock(_timeoutSeconds: number): Promise<boolean> {
+      if (lockConnection !== null) {
+        return true;
+      }
       const connection = await db.reserve();
       lockConnection = connection;
       try {
@@ -66,6 +93,7 @@ export function createSqlDriver(
 
   return {
     install: () => dialect.install(db),
+    client: () => db,
     async listExecuted() {
       const rows = await db`SELECT migration, checksum FROM ${db.unsafe(table)} ORDER BY id ASC`;
       return rows.map(

package/src/drivers/sqlite.ts

@@ -1,26 +1,14 @@
 import type { DriverTableOptions, MigrationDriver } from "../core/driver.js";
-import { doubleQuoted, validateIdentifier } from "../core/identifiers.js";
-import { createSqlDriver } from "./shared.js";
+import { doubleQuoted } from "../core/identifiers.js";
+import { createSqlDriver, resolveTableRef, UNIQUE_INDEX_SUFFIX } from "./shared.js";
 
 const TABLE_NAME_MAX_LENGTH = 128;
-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: doubleQuoted(tableName),
-    index: doubleQuoted(`${tableName}${UNIQUE_INDEX_SUFFIX}`),
-    name: tableName,
-  };
-}
 
 export function create(databaseUrl: string, options: DriverTableOptions = {}): MigrationDriver {
-  const { table, index, name } = resolveTableRef(options);
+  const { table, index, name } = resolveTableRef(options, {
+    quote: doubleQuoted,
+    maxLength: TABLE_NAME_MAX_LENGTH,
+  });
   return createSqlDriver(
     databaseUrl,
     {

package/src/index.ts

@@ -7,6 +7,7 @@ import {
 import { InvalidIdentifierError } from "./core/identifiers.js";
 import { migrateUp } from "./api/up.js";
 import { migrateDown } from "./api/down.js";
+import { migrateRedo } from "./api/redo.js";
 import { migrateStatus } from "./api/status.js";
 import { installMigrations } from "./api/install.js";
 import { createMigration } from "./api/create.js";
@@ -20,7 +21,10 @@ import {
   type MigrateStatusResult,
   type MigrateUpOptions,
   type MigrateUpResult,
+  type RedoOptions,
+  type RedoResult,
   ChecksumDriftError,
+  DatabaseWaitTimeoutError,
   GitStageError,
   MigrationLockError,
   MigrationNotFoundError,
@@ -30,11 +34,13 @@ export {
   createDriver,
   migrateUp,
   migrateDown,
+  migrateRedo,
   migrateStatus,
   installMigrations,
   createMigration,
   markMigrationsApplied,
   ChecksumDriftError,
+  DatabaseWaitTimeoutError,
   GitStageError,
   InvalidIdentifierError,
   MigrationLockError,
@@ -49,6 +55,8 @@ export type {
   MigrateUpResult,
   MigrateDownOptions,
   MigrateDownResult,
+  RedoOptions,
+  RedoResult,
   MarkOptions,
   MarkResult,
   MigrateStatusResult,