bunsql-native-migrate 0.4.0 → 0.4.1

package/src/core/fs.ts

@@ -1,31 +1,55 @@
 import { readdir } from "node:fs/promises";
 import path from "node:path";
+import { getMigrationListDir } from "./env.js";
 
 export const DEFAULT_MIGRATIONS_DIR = "migrations";
 
 export const MIGRATION_EXTENSIONS = ["js", "ts", "up.sql"] as const;
 
+const MIGRATION_SUFFIXES = MIGRATION_EXTENSIONS.map((extension) => `.${extension}`);
+
+const DECLARATION_SUFFIX = ".d.ts";
+
+export function isMigrationFileName(name: string): boolean {
+  if (name.endsWith(DECLARATION_SUFFIX)) return false;
+  return MIGRATION_SUFFIXES.some((suffix) => name.endsWith(suffix));
+}
+
 export async function listFiles(dir: string, extensions: readonly string[]): Promise<string[]> {
+  const suffixes = extensions.map((extension) => `.${extension}`);
   const matchedFiles: string[] = [];
   const entries = await readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    if (entry.isFile() && extensions.some((ext) => entry.name.endsWith(`.${ext}`))) {
+    if (entry.isFile() && suffixes.some((suffix) => entry.name.endsWith(suffix))) {
+      if (!isMigrationFileName(entry.name)) continue;
       matchedFiles.push(entry.name);
     }
   }
   return matchedFiles.sort().reverse();
 }
 
+export async function listMigrationFiles(listDir: string): Promise<string[]> {
+  return listFiles(listDir, MIGRATION_EXTENSIONS);
+}
+
 export async function checksumFile(filePath: string): Promise<string> {
   const hasher = new Bun.CryptoHasher("sha256");
   hasher.update(await Bun.file(filePath).arrayBuffer());
   return hasher.digest("hex");
 }
 
+export async function checksumFiles(
+  listDir: string,
+  files: readonly string[],
+): Promise<Map<string, string>> {
+  const entries = await Promise.all(
+    files.map(async (file) => [file, await checksumFile(path.join(listDir, file))] as const),
+  );
+  return new Map(entries);
+}
+
 export function resolveListDir(override?: string): string {
   return path.resolve(
-    override ??
-      process.env["MIGRATION_LIST_DIR"] ??
-      path.join(process.cwd(), DEFAULT_MIGRATIONS_DIR),
+    override ?? getMigrationListDir() ?? path.join(process.cwd(), DEFAULT_MIGRATIONS_DIR),
   );
 }

package/src/drivers/mariadb.ts

@@ -28,7 +28,10 @@ async function uniqueIndexExists(db: SQL, tableName: string): Promise<boolean> {
   return rows.length > 0;
 }
 
-export function create(databaseUrl: string, options: DriverTableOptions = {}): MigrationDriver {
+export async function create(
+  databaseUrl: string,
+  options: DriverTableOptions = {},
+): Promise<MigrationDriver> {
   const { table, index, name } = resolveTableRef(options, {
     quote: backtickQuoted,
     maxLength: TABLE_NAME_MAX_LENGTH,

package/src/drivers/postgres.ts

@@ -39,7 +39,10 @@ async function advisoryKeyComponents(lock: SQL): Promise<[number, number]> {
   return [Number((hash >> 32n) & 0x7fffffffn), Number(hash & 0x7fffffffn)];
 }
 
-export function create(databaseUrl: string, options: DriverTableOptions = {}): MigrationDriver {
+export async function create(
+  databaseUrl: string,
+  options: DriverTableOptions = {},
+): Promise<MigrationDriver> {
   const { table, index, name, schemaName } = resolvePostgresTableRef(options);
   return createSqlDriver(
     databaseUrl,

package/src/drivers/shared.ts

@@ -28,7 +28,7 @@ export function resolveTableRef(options: DriverTableOptions, spec: TableRefSpec)
 export interface SqlLock {
   tryLock(timeoutSeconds: number): Promise<boolean>;
   releaseLock(): Promise<void>;
-  dispose(): void;
+  dispose(): void | Promise<void>;
 }
 
 export interface SqlDialect {
@@ -36,7 +36,8 @@ export interface SqlDialect {
   record(db: SQL, migration: string, checksum: string): Promise<void>;
   trackingTableExists?(db: SQL): Promise<boolean>;
   trackingTableCurrent?(db: SQL): Promise<boolean>;
-  createLock?(db: SQL): SqlLock;
+  createLock?(db: SQL, databaseUrl: string): SqlLock;
+  setupConnection?(db: SQL): Promise<void>;
 }
 
 export function createReservedLock(
@@ -83,13 +84,16 @@ export function createReservedLock(
   };
 }
 
-export function createSqlDriver(
+export async function createSqlDriver(
   databaseUrl: string,
   dialect: SqlDialect,
   table: string,
-): MigrationDriver {
+): Promise<MigrationDriver> {
   const db = new SQL(databaseUrl);
-  const lock = dialect.createLock?.(db);
+  const lock = dialect.createLock?.(db, databaseUrl);
+  if (dialect.setupConnection) {
+    await dialect.setupConnection(db);
+  }
 
   return {
     install: () => dialect.install(db),
@@ -124,7 +128,7 @@ export function createSqlDriver(
         }
       : {}),
     async close() {
-      lock?.dispose();
+      await lock?.dispose();
       db.close({ timeout: 0 });
     },
   };

package/src/drivers/sqlite-lock.ts

@@ -0,0 +1,87 @@
+import { link, open, readFile, unlink } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import type { SqlLock } from "./shared.js";
+
+const LOCK_FILE_SUFFIX = ".bunsql-migrate.lock";
+
+const IN_MEMORY_PATH = ":memory:";
+
+export function sqliteLockPath(databaseUrl: string): string | null {
+  const withoutScheme = databaseUrl.replace(/^sqlite:/, "");
+  const withoutAuthority = withoutScheme.startsWith("//") ? withoutScheme.slice(2) : withoutScheme;
+  const filePath = withoutAuthority.split(/[?#]/)[0]!;
+  if (filePath === IN_MEMORY_PATH) return null;
+  return `${path.resolve(filePath)}${LOCK_FILE_SUFFIX}`;
+}
+
+async function lockIsStale(lockPath: string): Promise<boolean> {
+  let content: string;
+  try {
+    content = (await readFile(lockPath, "utf8")).trim();
+  } catch {
+    return false;
+  }
+  const pid = Number(content);
+  if (!Number.isInteger(pid)) return false;
+  if (pid <= 0) return true;
+  try {
+    process.kill(pid, 0);
+    return false;
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code === "ESRCH";
+  }
+}
+
+async function tryCreateLockFile(lockPath: string): Promise<boolean> {
+  const stagingPath = `${lockPath}.${randomUUID()}.tmp`;
+  const handle = await open(stagingPath, "wx");
+  try {
+    await handle.writeFile(String(process.pid));
+  } finally {
+    await handle.close();
+  }
+  try {
+    await link(stagingPath, lockPath);
+    return true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+    if (!(await lockIsStale(lockPath))) return false;
+    await unlink(lockPath).catch(() => undefined);
+    return tryCreateLockFile(lockPath);
+  } finally {
+    await unlink(stagingPath).catch(() => undefined);
+  }
+}
+
+export function createSqliteFileLock(lockPath: string): SqlLock {
+  let held = false;
+  return {
+    async tryLock() {
+      if (held) return true;
+      if (await tryCreateLockFile(lockPath)) {
+        held = true;
+        return true;
+      }
+      return false;
+    },
+    async releaseLock() {
+      if (!held) return;
+      held = false;
+      await unlink(lockPath).catch(() => undefined);
+    },
+    async dispose() {
+      if (!held) return;
+      held = false;
+      await unlink(lockPath).catch(() => undefined);
+    },
+  };
+}
+
+export function createInMemoryLock(): SqlLock {
+  return {
+    tryLock: async () => true,
+    releaseLock: async () => {},
+    dispose() {},
+  };
+}

package/src/drivers/sqlite.ts

@@ -1,10 +1,16 @@
 import type { DriverTableOptions, MigrationDriver } from "../core/driver.js";
 import { doubleQuoted } from "../core/identifiers.js";
 import { createSqlDriver, resolveTableRef, UNIQUE_INDEX_SUFFIX } from "./shared.js";
+import { createInMemoryLock, createSqliteFileLock, sqliteLockPath } from "./sqlite-lock.js";
 
 const TABLE_NAME_MAX_LENGTH = 128;
 
-export function create(databaseUrl: string, options: DriverTableOptions = {}): MigrationDriver {
+export const DEFAULT_BUSY_TIMEOUT_MS = 30_000;
+
+export async function create(
+  databaseUrl: string,
+  options: DriverTableOptions = {},
+): Promise<MigrationDriver> {
   const { table, index, name } = resolveTableRef(options, {
     quote: doubleQuoted,
     maxLength: TABLE_NAME_MAX_LENGTH,
@@ -45,16 +51,27 @@ export function create(databaseUrl: string, options: DriverTableOptions = {}): M
         await db`INSERT OR IGNORE INTO ${db.unsafe(table)} (migration, checksum)
           VALUES (${migration}, ${checksum})`;
       },
-      createLock: (db) => ({
-        async tryLock(timeoutSeconds: number) {
-          await db.unsafe(`PRAGMA busy_timeout = ${timeoutSeconds * 1000}`);
-          return true;
-        },
-        async releaseLock() {
-          await db.unsafe("PRAGMA busy_timeout = 0");
-        },
-        dispose() {},
-      }),
+      async setupConnection(db) {
+        await db.unsafe(`PRAGMA busy_timeout = ${DEFAULT_BUSY_TIMEOUT_MS}`);
+      },
+      createLock: (_db) => {
+        const lockPath = sqliteLockPath(databaseUrl);
+        if (lockPath === null) {
+          return createInMemoryLock();
+        }
+        const fileLock = createSqliteFileLock(lockPath);
+        return {
+          async tryLock(timeoutSeconds: number) {
+            return fileLock.tryLock(timeoutSeconds);
+          },
+          async releaseLock() {
+            await fileLock.releaseLock();
+          },
+          async dispose() {
+            await fileLock.dispose();
+          },
+        };
+      },
     },
     table,
   );

package/src/index.ts

@@ -5,6 +5,7 @@ import {
   type MigrationDriver,
 } from "./core/driver.js";
 import { InvalidIdentifierError } from "./core/identifiers.js";
+import { InvalidConfigError, loadProjectConfig, type ProjectConfig } from "./core/config.js";
 import { migrateUp } from "./api/up.js";
 import { migrateDown } from "./api/down.js";
 import { migrateRedo } from "./api/redo.js";
@@ -26,12 +27,15 @@ import {
   ChecksumDriftError,
   DatabaseWaitTimeoutError,
   GitStageError,
+  InvalidMigrationNameError,
+  MigrationFileMissingError,
   MigrationLockError,
   MigrationNotFoundError,
 } from "./api/options.js";
 
 export {
   createDriver,
+  loadProjectConfig,
   migrateUp,
   migrateDown,
   migrateRedo,
@@ -42,7 +46,10 @@ export {
   ChecksumDriftError,
   DatabaseWaitTimeoutError,
   GitStageError,
+  InvalidConfigError,
   InvalidIdentifierError,
+  InvalidMigrationNameError,
+  MigrationFileMissingError,
   MigrationLockError,
   MigrationNotFoundError,
 };
@@ -60,4 +67,5 @@ export type {
   MarkOptions,
   MarkResult,
   MigrateStatusResult,
+  ProjectConfig,
 };