@zgeoff/kysely-bun-sqlite 0.1.0 → 0.2.0

package/dist/build-bun-sqlite-driver.d.ts

@@ -0,0 +1,3 @@
+import type { Database } from 'bun:sqlite';
+import type { Driver } from 'kysely';
+export declare function buildBunSQLiteDriver(sqlite: Database): Driver;

package/dist/index.d.ts

@@ -1,2 +1,2 @@
 export { buildSQLiteDialect } from './build-sqlite-dialect.ts';
-export { BunSQLiteDriver } from './bun-sqlite-driver.ts';
+export { buildBunSQLiteDriver } from './build-bun-sqlite-driver.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgeoff/kysely-bun-sqlite",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "A Kysely driver and dialect for a bun:sqlite database handle",
   "license": "MIT",
   "repository": {
@@ -29,9 +29,9 @@
     "typecheck": "tsc"
   },
   "devDependencies": {
-    "@types/bun": "1.3.14",
+    "@types/bun": "1.4.2",
     "kysely": "0.29.6",
-    "typescript": "7.0.1-rc"
+    "typescript": "7.0.2"
   },
   "peerDependencies": {
     "kysely": ">=0.29.5 <0.30.0"

package/src/{bun-sqlite-driver.ts → build-bun-sqlite-driver.ts}

@@ -7,60 +7,54 @@ import type { DatabaseConnection, Driver, QueryResult } from 'kysely';
 // Kysely's RuntimeDriver serializes the connection: SqliteAdapter reports no
 // support for multiple connections, so RuntimeDriver holds a mutex from each
 // acquire to its release.
-export class BunSQLiteDriver implements Driver {
-  private readonly connection: DatabaseConnection;
+export function buildBunSQLiteDriver(sqlite: Database): Driver {
+  const connection = buildConnection(sqlite);
 
   // The driver's own turn chain exists only for the destroy() wait, because
   // Kysely calls destroy() outside RuntimeDriver's mutex.
-  private turn: Promise<void> = Promise.resolve();
+  let turn: Promise<void> = Promise.resolve();
+  let releaseTurn: (() => void) | undefined;
 
-  private releaseTurn: () => void = () => {};
-
-  constructor(sqlite: Database) {
-    this.connection = buildConnection(sqlite);
-  }
-
-  init(): Promise<void> {
-    return Promise.resolve();
-  }
-
-  async acquireConnection(): Promise<DatabaseConnection> {
-    const previous = this.turn;
+  const acquireConnection = async (): Promise<DatabaseConnection> => {
+    const previous = turn;
     const next = Promise.withResolvers<void>();
 
-    this.turn = next.promise;
+    turn = next.promise;
 
     await previous;
 
-    this.releaseTurn = next.resolve;
+    releaseTurn = next.resolve;
 
-    return this.connection;
-  }
-
-  async beginTransaction(connection: DatabaseConnection): Promise<void> {
-    await connection.executeQuery(CompiledQuery.raw('begin'));
-  }
+    return connection;
+  };
 
-  async commitTransaction(connection: DatabaseConnection): Promise<void> {
-    await connection.executeQuery(CompiledQuery.raw('commit'));
-  }
+  const releaseConnection = (): Promise<void> => {
+    releaseTurn?.();
 
-  async rollbackTransaction(connection: DatabaseConnection): Promise<void> {
-    await connection.executeQuery(CompiledQuery.raw('rollback'));
-  }
+    return Promise.resolve();
+  };
 
-  releaseConnection(): Promise<void> {
-    this.releaseTurn();
+  return {
+    init: () => Promise.resolve(),
+    acquireConnection,
+    beginTransaction: async (heldConnection) => {
+      await heldConnection.executeQuery(CompiledQuery.raw('begin'));
+    },
+    commitTransaction: async (heldConnection) => {
+      await heldConnection.executeQuery(CompiledQuery.raw('commit'));
+    },
+    rollbackTransaction: async (heldConnection) => {
+      await heldConnection.executeQuery(CompiledQuery.raw('rollback'));
+    },
+    releaseConnection,
 
-    return Promise.resolve();
-  }
-
-  // The opener owns the handle and closes it, so destroy() leaves the handle
-  // open and only waits for the caller that holds the connection.
-  async destroy(): Promise<void> {
-    await this.acquireConnection();
-    await this.releaseConnection();
-  }
+    // The opener owns the handle and closes it, so destroy() leaves the handle
+    // open and only waits for the caller that holds the connection.
+    destroy: async () => {
+      await acquireConnection();
+      await releaseConnection();
+    },
+  };
 }
 
 function buildConnection(sqlite: Database): DatabaseConnection {
@@ -85,7 +79,7 @@ function buildConnection(sqlite: Database): DatabaseConnection {
     },
 
     streamQuery<R>(): AsyncIterableIterator<QueryResult<R>> {
-      throw new Error('BunSQLiteDriver does not support streaming queries');
+      throw new Error('The bun:sqlite driver does not support streaming queries');
     },
   };
 }

package/src/build-sqlite-dialect.ts

@@ -1,12 +1,12 @@
 import type { Database } from 'bun:sqlite';
 import { SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler } from 'kysely';
 import type { Dialect } from 'kysely';
-import { BunSQLiteDriver } from './bun-sqlite-driver.ts';
+import { buildBunSQLiteDriver } from './build-bun-sqlite-driver.ts';
 
 export function buildSQLiteDialect(sqlite: Database): Dialect {
   return {
     createAdapter: () => new SqliteAdapter(),
-    createDriver: () => new BunSQLiteDriver(sqlite),
+    createDriver: () => buildBunSQLiteDriver(sqlite),
     createIntrospector: (kysely) => new SqliteIntrospector(kysely),
     createQueryCompiler: () => new SqliteQueryCompiler(),
   };

package/src/index.ts

@@ -1,2 +1,2 @@
 export { buildSQLiteDialect } from './build-sqlite-dialect.ts';
-export { BunSQLiteDriver } from './bun-sqlite-driver.ts';
+export { buildBunSQLiteDriver } from './build-bun-sqlite-driver.ts';

package/dist/bun-sqlite-driver.d.ts

@@ -1,15 +0,0 @@
-import type { Database } from 'bun:sqlite';
-import type { DatabaseConnection, Driver } from 'kysely';
-export declare class BunSQLiteDriver implements Driver {
-    private readonly connection;
-    private turn;
-    private releaseTurn;
-    constructor(sqlite: Database);
-    init(): Promise<void>;
-    acquireConnection(): Promise<DatabaseConnection>;
-    beginTransaction(connection: DatabaseConnection): Promise<void>;
-    commitTransaction(connection: DatabaseConnection): Promise<void>;
-    rollbackTransaction(connection: DatabaseConnection): Promise<void>;
-    releaseConnection(): Promise<void>;
-    destroy(): Promise<void>;
-}