bunsql-native-migrate 0.3.1 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunsql-native-migrate",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Zero-ORM SQL file migrations for Bun: PostgreSQL, MySQL/MariaDB and SQLite through the built-in Bun.SQL client",
   "keywords": [
     "bun",

package/src/api/down.ts

@@ -8,15 +8,20 @@ import { runMigrationStep } from "./run-step.js";
 import { isSqlMigration, loadMigration } from "./load-migration.js";
 import { ensureTrackingTable, listExecutedForPlan } from "./tracking-table.js";
 
-function resolveStepCount(steps: number | "all" | undefined, appliedCount: number): number {
+export function parseSteps(steps: number | "all" | undefined): number | "all" {
   if (steps === undefined) return 1;
-  if (steps === "all") return appliedCount;
+  if (steps === "all") return "all";
   if (!Number.isInteger(steps) || steps < 1) {
     throw new Error(`Invalid steps: ${String(steps)} — expected a positive integer or "all"`);
   }
   return steps;
 }
 
+function resolveStepCount(steps: number | "all" | undefined, appliedCount: number): number {
+  const parsed = parseSteps(steps);
+  return parsed === "all" ? appliedCount : parsed;
+}
+
 async function revertOne(driver: MigrationDriver, listDir: string, file: string): Promise<void> {
   const { down } = await loadMigration(listDir, file);
 
@@ -49,10 +54,8 @@ export async function migrateDown(options: MigrateDownOptions = {}): Promise<Mig
     }
 
     const count = resolveStepCount(options.steps, executed.length);
-    const plan = executed
-      .slice(-count)
-      .reverse()
-      .map((entry) => entry.name);
+    const revertList = executed.slice(-count).reverse();
+    const plan = revertList.map((entry) => entry.name);
 
     if (dryRun) {
       log({ text: "Dry run — no changes will be made.", type: "info" });
@@ -64,7 +67,7 @@ export async function migrateDown(options: MigrateDownOptions = {}): Promise<Mig
 
     const reverted: string[] = [];
 
-    for (const entry of executed.slice(-count).reverse()) {
+    for (const entry of revertList) {
       try {
         await revertOne(driver, listDir, entry.name);
       } catch (error) {

package/src/api/mark.ts

@@ -1,7 +1,8 @@
 import path from "node:path";
 import { checksumFile, listFiles, MIGRATION_EXTENSIONS, resolveListDir } from "../core/fs.js";
 import { log } from "../core/console.js";
-import { type MarkOptions, type MarkResult, MigrationNotFoundError } from "./options.js";
+import { type MarkOptions, type MarkResult } from "./options.js";
+import { resolvePendingToTarget } from "./pending.js";
 import { runWithDriver } from "./run-with-driver.js";
 import { ensureTrackingTable } from "./tracking-table.js";
 
@@ -13,24 +14,27 @@ export async function markMigrationsApplied(options: MarkOptions = {}): Promise<
     await ensureTrackingTable(driver);
 
     const allFiles = await listFiles(listDir, MIGRATION_EXTENSIONS);
-    if (target !== undefined && !allFiles.includes(target)) {
-      throw new MigrationNotFoundError(target);
-    }
-
     const executed = await driver.listExecuted();
-    const executedNames = new Set(executed.map((entry) => entry.name));
-    let pending = allFiles.filter((file) => !executedNames.has(file));
-    if (target !== undefined) {
-      if (executedNames.has(target)) {
-        log({ text: `${target} is already applied.`, type: "info" });
-        return { marked: [] };
-      }
-      pending = pending.slice(0, pending.indexOf(target) + 1);
+
+    const { pending, targetApplied } = resolvePendingToTarget({
+      allFiles,
+      executedNames: executed.map((entry) => entry.name),
+      target,
+    });
+    if (targetApplied) {
+      return { marked: [] };
     }
 
+    const checksums = new Map(
+      await Promise.all(
+        pending.map(async (file) => [file, await checksumFile(path.join(listDir, file))] as const),
+      ),
+    );
+
     const marked: string[] = [];
     for (const file of pending) {
-      const checksum = await checksumFile(path.join(listDir, file));
+      const checksum = checksums.get(file);
+      if (!checksum) continue;
       await driver.record(file, checksum);
       marked.push(file);
       log({ text: `${file} marked as applied`, type: "success" });

package/src/api/pending.ts

@@ -0,0 +1,37 @@
+import { log } from "../core/console.js";
+import { MigrationNotFoundError } from "./options.js";
+
+export interface PendingToTargetResult {
+  pending: string[];
+  targetApplied: boolean;
+}
+
+interface ResolvePendingOptions {
+  allFiles: string[];
+  executedNames: string[];
+  target: string | undefined;
+}
+
+export function resolvePendingToTarget({
+  allFiles,
+  executedNames,
+  target,
+}: ResolvePendingOptions): PendingToTargetResult {
+  const executed = new Set(executedNames);
+
+  if (target !== undefined && !allFiles.includes(target)) {
+    throw new MigrationNotFoundError(target);
+  }
+
+  let pending = allFiles.filter((file) => !executed.has(file));
+  let targetApplied = false;
+  if (target !== undefined) {
+    if (executed.has(target)) {
+      log({ text: `${target} is already applied.`, type: "info" });
+      targetApplied = true;
+    } else {
+      pending = pending.slice(0, pending.indexOf(target) + 1);
+    }
+  }
+  return { pending, targetApplied };
+}

package/src/api/up.ts

@@ -2,15 +2,11 @@ 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,
-  ChecksumDriftError,
-  MigrationNotFoundError,
-} from "./options.js";
+import { type MigrateUpOptions, type MigrateUpResult, ChecksumDriftError } from "./options.js";
 import { runWithDriver } from "./run-with-driver.js";
 import { runMigrationStep } from "./run-step.js";
 import { loadMigration } from "./load-migration.js";
+import { resolvePendingToTarget } from "./pending.js";
 import { resolveLockTimeout, withMigrationLock } from "./lock.js";
 import { ensureTrackingTable, listExecutedForPlan } from "./tracking-table.js";
 
@@ -27,9 +23,6 @@ export async function migrateUp(options: MigrateUpOptions = {}): Promise<Migrate
 
     const run = async (): Promise<MigrateUpResult> => {
       const allFiles = await listFiles(listDir, MIGRATION_EXTENSIONS);
-      if (target !== undefined && !allFiles.includes(target)) {
-        throw new MigrationNotFoundError(target);
-      }
 
       const checksums = new Map(
         await Promise.all(
@@ -59,13 +52,13 @@ export async function migrateUp(options: MigrateUpOptions = {}): Promise<Migrate
         }
       }
 
-      let pending = allFiles.filter((file) => !executedByName.has(file));
-      if (target !== undefined) {
-        if (executedByName.has(target)) {
-          log({ text: `${target} is already applied.`, type: "info" });
-          return dryRun ? { applied: [], planned: [] } : { applied: [] };
-        }
-        pending = pending.slice(0, pending.indexOf(target) + 1);
+      const { pending, targetApplied } = resolvePendingToTarget({
+        allFiles,
+        executedNames: executed.map((entry) => entry.name),
+        target,
+      });
+      if (targetApplied) {
+        return dryRun ? { applied: [], planned: [] } : { applied: [] };
       }
 
       if (dryRun) {

package/src/cli/main.ts

@@ -1,11 +1,12 @@
 #!/usr/bin/env bun
 import { migrateUp } from "../api/up.js";
-import { migrateDown } from "../api/down.js";
+import { migrateDown, parseSteps } 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 { resolveLockTimeout } from "../api/lock.js";
 import { ChecksumDriftError, MigrationLockError, MigrationNotFoundError } from "../api/options.js";
 import { InvalidIdentifierError } from "../core/identifiers.js";
 import { log } from "../core/console.js";
@@ -63,15 +64,15 @@ function parseArgs(argv: string[]): CliArgs {
       }
     } else if (arg === "--lock-timeout") {
       const value = argv[++i];
-      const parsed = Number(value);
-      if (value === undefined || !Number.isInteger(parsed) || parsed < 0) {
+      try {
+        lockTimeout = resolveLockTimeout(Number(value));
+      } catch {
         log({
           text: `Invalid --lock-timeout: ${value ?? "(missing)"} (expected a non-negative integer of seconds)`,
           type: "error",
         });
         usage(1);
       }
-      lockTimeout = parsed;
     } else if (arg === "--table") {
       table = argv[++i];
       if (table === undefined) {
@@ -160,15 +161,15 @@ try {
       if (args.all) {
         steps = "all";
       } else if (stepsArg !== undefined) {
-        const parsed = Number(stepsArg);
-        if (!Number.isInteger(parsed) || parsed < 1) {
+        try {
+          steps = parseSteps(Number(stepsArg));
+        } catch {
           log({
             text: `Invalid step count: ${stepsArg} (expected a positive integer)`,
             type: "error",
           });
           usage(1);
         }
-        steps = parsed;
       }
       const { reverted, planned } = await migrateDown({
         ...listDirOptions,

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/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>;

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,
     {