Support both a pool and direct client.

Author: rkistner

.gitignore

@@ -1,6 +1,8 @@
 node_modules/
 test-db/
 *.db
+*.db-wal
+*.db-shm
 lib/
 tsconfig.tsbuildinfo
 benchmarks/db

packages/stdext-sql-adapter/src/better-sqlite-client.ts

@@ -1,8 +1,8 @@
 import { BetterSqliteDriver } from '@sqlite-js/better-sqlite3-driver';
-import { SqliteClientPool, SqliteClientOptions } from './core.js';
+import { SqliteClientPool, SqliteClientOptions, SqliteClient } from './core.js';
 import { fileURLToPath } from 'node:url';
 
-export class BetterSqliteClient extends SqliteClientPool {
+export class BetterSqliteClient extends SqliteClient {
   constructor(connectionUrl: string | URL, options: SqliteClientOptions = {}) {
     if (typeof connectionUrl != 'string') {
       connectionUrl = fileURLToPath(connectionUrl);
@@ -11,3 +11,13 @@ export class BetterSqliteClient extends SqliteClientPool {
     super(connectionUrl, pool, options);
   }
 }
+
+export class BetterSqliteClientPool extends SqliteClientPool {
+  constructor(connectionUrl: string | URL, options: SqliteClientOptions = {}) {
+    if (typeof connectionUrl != 'string') {
+      connectionUrl = fileURLToPath(connectionUrl);
+    }
+    const pool = BetterSqliteDriver.open(connectionUrl);
+    super(connectionUrl, pool, options);
+  }
+}

packages/stdext-sql-adapter/src/connection.ts

@@ -27,7 +27,8 @@ export class SqliteConnection
       SqliteQueryOptions
     >
 {
-  public driver: SqliteDriverConnection;
+  public driver: SqliteDriverConnection | undefined;
+
   public readonly connectionUrl: string;
 
   get connected(): boolean {
@@ -38,7 +39,7 @@ export class SqliteConnection
 
   constructor(
     connectionUrl: string,
-    driver: SqliteDriverConnection,
+    driver: SqliteDriverConnection | undefined,
     options?: SqliteConnectionOptions
   ) {
     this.connectionUrl = connectionUrl;
@@ -47,11 +48,11 @@ export class SqliteConnection
   }
 
   async connect(): Promise<void> {
-    // We're always connected
+    // No-op
   }
 
   async close(): Promise<void> {
-    await this.driver.close();
+    await this.driver?.close();
   }
 
   async execute(
@@ -127,6 +128,29 @@ export class SqliteConnection
   }
 }
 
+export class SqliteReservedConnection extends SqliteConnection {
+  #connect: () => Promise<ReservedConnection>;
+  #reserved: ReservedConnection | undefined;
+
+  constructor(
+    connectionUrl: string,
+    connect: () => Promise<ReservedConnection>,
+    options?: SqliteConnectionOptions
+  ) {
+    super(connectionUrl, undefined, options);
+    this.#connect = connect;
+  }
+
+  async connect(): Promise<void> {
+    this.#reserved = await this.#connect();
+    this.driver = this.#reserved.connection;
+  }
+
+  async close(): Promise<void> {
+    await this.#reserved?.release();
+  }
+}
+
 export class SqliteConnectable
   implements SqlConnectable<SqliteConnectionOptions, SqliteConnection>
 {

packages/stdext-sql-adapter/src/core.ts

@@ -25,6 +25,7 @@ import {
 import {
   SqliteConnectable,
   SqliteConnection,
+  SqliteReservedConnection,
   type SqliteConnectionOptions
 } from './connection.js';
 import { SqliteTransactionError } from './errors.js';
@@ -442,6 +443,57 @@ export class SqliteTransactionable
   }
 }
 
+/**
+ * Single-connection client. Not safe to use concurrently.
+ */
+export class SqliteClient
+  extends SqliteTransactionable
+  implements
+    SqlClient<
+      SqliteEventTarget,
+      SqliteConnectionOptions,
+      SqliteParameterType,
+      SqliteQueryOptions,
+      SqliteConnection,
+      SqlitePreparedStatement,
+      SqliteTransactionOptions,
+      SqliteTransaction
+    >
+{
+  readonly eventTarget: SqliteEventTarget;
+
+  constructor(
+    connectionUrl: string,
+    pool: SqliteDriverConnectionPool,
+    options: SqliteClientOptions = {}
+  ) {
+    const connect = () => {
+      return pool.reserveConnection();
+    };
+    const conn = new SqliteReservedConnection(connectionUrl, connect, options);
+    super(conn, options);
+    this.eventTarget = new SqliteEventTarget();
+  }
+
+  async connect(): Promise<void> {
+    await this.connection.connect();
+    this.eventTarget.dispatchEvent(
+      new SqliteConnectEvent({ connection: this.connection } as any)
+    );
+  }
+
+  async close(): Promise<void> {
+    this.eventTarget.dispatchEvent(
+      new SqliteCloseEvent({ connection: this.connection } as any)
+    );
+    await this.connection.close();
+  }
+
+  async [Symbol.asyncDispose](): Promise<void> {
+    await this.close();
+  }
+}
+
 class SqlitePoolClient
   extends SqliteTransactionable
   implements

packages/stdext-sql-adapter/test/src/adapter.test.ts

@@ -1,19 +1,31 @@
 import * as fs from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 import { assert, test } from 'vitest';
-import { BetterSqliteClient, SqliteClientPool } from '../../lib/index.js';
+import {
+  BetterSqliteClient,
+  BetterSqliteClientPool,
+  SqliteClient,
+  SqliteClientPool
+} from '../../lib/index.js';
 
 const assertEquals = assert.deepEqual;
 
 test('sqlite', async () => {
-  const DB_URL = new URL('./test.db', import.meta.url);
+  const DB_URL = new URL('../../test.db', import.meta.url);
   const path = fileURLToPath(DB_URL);
 
   // Remove any existing test.db.
   await fs.rm(path).catch(() => {});
+  await fs.rm(path + '-shm').catch(() => {});
+  await fs.rm(path + '-wal').catch(() => {});
+
+  // To test the pool:
+  // let pool: SqliteClientPool = new BetterSqliteClientPool(path);
+  // let db = await pool.acquire();
+
+  let db: SqliteClient = new BetterSqliteClient(path);
+  await db.connect();
 
-  let pool: SqliteClientPool = new BetterSqliteClient(path);
-  let db = await pool.acquire();
   await db.execute('pragma journal_mode = WAL');
   await db.execute('pragma synchronous = normal');
   assertEquals(await db.execute('pragma temp_store = memory'), 0);