bunsql-native-migrate 0.1.1 → 0.2.0

package/src/drivers/shared.ts

@@ -0,0 +1,91 @@
+import { SQL, type ReservedSQL } from "bun";
+import type { ExecutedMigration, MigrationDriver } from "../core/driver.js";
+
+export interface SqlLock {
+  tryLock(timeoutSeconds: number): Promise<boolean>;
+  releaseLock(): Promise<void>;
+  dispose(): void;
+}
+
+export interface SqlDialect {
+  install(db: SQL): Promise<void>;
+  record(db: SQL, migration: string, checksum: string): Promise<void>;
+  createLock?(db: SQL): SqlLock;
+}
+
+export function createReservedLock(
+  db: SQL,
+  acquire: (lock: SQL) => Promise<boolean>,
+  release: (lock: SQL) => Promise<void>,
+): SqlLock {
+  let lockConnection: ReservedSQL | null = null;
+
+  return {
+    async tryLock() {
+      const connection = await db.reserve();
+      lockConnection = connection;
+      try {
+        const acquired = await acquire(connection);
+        if (!acquired) {
+          connection.release();
+          lockConnection = null;
+        }
+        return acquired;
+      } catch (error) {
+        connection.release();
+        lockConnection = null;
+        throw error;
+      }
+    },
+    async releaseLock() {
+      const connection = lockConnection;
+      if (!connection) return;
+      lockConnection = null;
+      try {
+        await release(connection);
+      } finally {
+        connection.release();
+      }
+    },
+    dispose() {
+      lockConnection?.release();
+      lockConnection = null;
+    },
+  };
+}
+
+export function createSqlDriver(databaseUrl: string, dialect: SqlDialect): MigrationDriver {
+  const db = new SQL(databaseUrl);
+  const lock = dialect.createLock?.(db);
+
+  return {
+    install: () => dialect.install(db),
+    async listExecuted() {
+      const rows = await db`SELECT migration, checksum FROM migrations ORDER BY id ASC`;
+      return rows.map(
+        (r: { migration: string; checksum: string | null }): ExecutedMigration => ({
+          name: r.migration,
+          checksum: r.checksum ?? null,
+        }),
+      );
+    },
+    record: (migration, checksum) => dialect.record(db, migration, checksum),
+    async setChecksum(migration, checksum) {
+      await db`UPDATE migrations SET checksum = ${checksum} WHERE migration = ${migration}`;
+    },
+    async remove(migration) {
+      await db`DELETE FROM migrations WHERE migration = ${migration}`;
+    },
+    transaction: (run) => db.begin(run),
+    ...(lock
+      ? {
+          tryLock: (timeoutSeconds: number) => lock.tryLock(timeoutSeconds),
+          releaseLock: () => lock.releaseLock(),
+        }
+      : {}),
+    async close() {
+      lock?.dispose();
+      db.close({ timeout: 0 });
+    },
+  };
+}

package/src/drivers/sqlite.ts

@@ -1,11 +1,9 @@
-import { SQL } from "bun";
-import type { ExecutedMigration, MigrationDriver } from "../core/driver.js";
+import type { MigrationDriver } from "../core/driver.js";
+import { createSqlDriver } from "./shared.js";
 
 export function create(databaseUrl: string): MigrationDriver {
-  const db = new SQL(databaseUrl);
-
-  return {
-    async install() {
+  return createSqlDriver(databaseUrl, {
+    async install(db) {
       await db`CREATE TABLE IF NOT EXISTS migrations (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         migration TEXT NOT NULL,
@@ -20,32 +18,19 @@ export function create(databaseUrl: string): MigrationDriver {
       }
       await db`CREATE UNIQUE INDEX IF NOT EXISTS migrations_migration_unique ON migrations (migration)`;
     },
-
-    async listExecuted() {
-      const rows = await db`SELECT migration, checksum FROM migrations ORDER BY id ASC`;
-      return rows.map(
-        (r: { migration: string; checksum: string | null }): ExecutedMigration => ({
-          name: r.migration,
-          checksum: r.checksum ?? null,
-        }),
-      );
-    },
-
-    async record(migration: string, checksum: string) {
+    async record(db, migration, checksum) {
       await db`INSERT OR IGNORE INTO migrations (migration, checksum)
         VALUES (${migration}, ${checksum})`;
     },
-
-    async setChecksum(migration: string, checksum: string) {
-      await db`UPDATE migrations SET checksum = ${checksum} WHERE migration = ${migration}`;
-    },
-
-    async remove(migration: string) {
-      await db`DELETE FROM migrations WHERE migration = ${migration}`;
-    },
-
-    async close() {
-      db.close({ timeout: 0 });
-    },
-  };
+    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() {},
+    }),
+  });
 }

package/src/index.ts

@@ -1,29 +1,41 @@
 import { createDriver, type ExecutedMigration, type MigrationDriver } from "./core/driver.js";
 import { migrateUp } from "./api/up.js";
 import { migrateDown } from "./api/down.js";
+import { migrateStatus } from "./api/status.js";
 import { installMigrations } from "./api/install.js";
 import { createMigration } from "./api/create.js";
 import {
+  type MigrateDownOptions,
   type MigrateDownResult,
   type MigrateOptions,
+  type MigrateStatusResult,
+  type MigrateUpOptions,
   type MigrateUpResult,
   ChecksumDriftError,
   GitStageError,
+  MigrationLockError,
+  MigrationNotFoundError,
 } from "./api/options.js";
 
 export {
   createDriver,
   migrateUp,
   migrateDown,
+  migrateStatus,
   installMigrations,
   createMigration,
   ChecksumDriftError,
   GitStageError,
+  MigrationLockError,
+  MigrationNotFoundError,
 };
 export type {
   ExecutedMigration,
   MigrationDriver,
   MigrateOptions,
+  MigrateUpOptions,
   MigrateUpResult,
+  MigrateDownOptions,
   MigrateDownResult,
+  MigrateStatusResult,
 };