Add a pool implementation.

Author: rkistner

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

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

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

@@ -27,36 +27,31 @@ export class SqliteConnection
       SqliteQueryOptions
     >
 {
-  public driver: SqliteDriverConnection | undefined;
-  public readonly pool: SqliteDriverConnectionPool;
+  public driver: SqliteDriverConnection;
   public readonly connectionUrl: string;
-  private reserved: ReservedConnection | undefined;
 
   get connected(): boolean {
-    // TODO: implement
-    return true;
+    return this.driver != null;
   }
 
   public readonly options: SqliteConnectionOptions;
 
   constructor(
     connectionUrl: string,
-    pool: SqliteDriverConnectionPool,
+    driver: SqliteDriverConnection,
     options?: SqliteConnectionOptions
   ) {
     this.connectionUrl = connectionUrl;
-    this.pool = pool;
+    this.driver = driver;
     this.options = options ?? {};
   }
 
   async connect(): Promise<void> {
-    this.reserved = await this.pool.reserveConnection();
-    this.driver = this.reserved.connection;
+    // We're always connected
   }
 
   async close(): Promise<void> {
-    await this.reserved?.release();
-    await this.pool.close();
+    await this.driver.close();
   }
 
   async execute(

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

@@ -2,7 +2,10 @@ import type {
   ArrayRow,
   Row,
   SqlClient,
+  SqlClientPool,
   SqlConnectionOptions,
+  SqlPoolClient,
+  SqlPoolClientOptions,
   SqlPreparable,
   SqlPreparedStatement,
   SqlQueriable,
@@ -16,6 +19,7 @@ import type { DatabaseOpenOptions } from './database.js';
 import {
   SqliteCloseEvent,
   SqliteConnectEvent,
+  SqliteEvents,
   SqliteEventTarget
 } from './events.js';
 import {
@@ -26,6 +30,7 @@ import {
 import { SqliteTransactionError } from './errors.js';
 import { mergeQueryOptions, transformToAsyncGenerator } from './util.js';
 import {
+  ReservedConnection,
   SqliteDriverConnection,
   SqliteDriverConnectionPool,
   SqliteDriverStatement,
@@ -437,34 +442,43 @@ export class SqliteTransactionable
   }
 }
 
-/**
- * Sqlite client
- */
-export class SqliteClient
+class SqlitePoolClient
   extends SqliteTransactionable
   implements
-    SqlClient<
-      SqliteEventTarget,
+    SqlPoolClient<
       SqliteConnectionOptions,
+      SqliteConnection,
       SqliteParameterType,
       SqliteQueryOptions,
-      SqliteConnection,
       SqlitePreparedStatement,
       SqliteTransactionOptions,
       SqliteTransaction
     >
 {
   readonly eventTarget: SqliteEventTarget;
+  readonly reserved: ReservedConnection;
+  readonly connectionUrl: string;
 
   constructor(
     connectionUrl: string,
-    driver: SqliteDriverConnectionPool,
+    reserved: ReservedConnection,
     options: SqliteClientOptions = {}
   ) {
-    const conn = new SqliteConnection(connectionUrl, driver, options);
+    const conn = new SqliteConnection(
+      connectionUrl,
+      reserved.connection,
+      options
+    );
     super(conn, options);
+    this.reserved = reserved;
+    this.connectionUrl = connectionUrl;
     this.eventTarget = new SqliteEventTarget();
   }
+  disposed: boolean = false;
+  async release(): Promise<void> {
+    this.disposed = true;
+    await this.reserved.release();
+  }
 
   async connect(): Promise<void> {
     await this.connection.connect();
@@ -484,3 +498,66 @@ export class SqliteClient
     await this.close();
   }
 }
+
+/**
+ * Sqlite client
+ */
+export class SqliteClientPool
+  implements
+    SqlClientPool<
+      SqliteConnectionOptions,
+      SqliteParameterType,
+      SqliteQueryOptions,
+      SqliteConnection,
+      SqlitePreparedStatement,
+      SqliteTransactionOptions,
+      SqliteTransaction
+    >
+{
+  readonly eventTarget: SqliteEventTarget;
+
+  readonly connectionUrl: string;
+  readonly pool: SqliteDriverConnectionPool;
+  readonly options: SqliteClientOptions;
+  readonly connected = true;
+
+  constructor(
+    connectionUrl: string,
+    pool: SqliteDriverConnectionPool,
+    options: SqliteClientOptions = {}
+  ) {
+    this.pool = pool;
+    this.connectionUrl = connectionUrl;
+    this.options = options;
+    this.eventTarget = new SqliteEventTarget();
+  }
+
+  async acquire(): Promise<
+    SqlPoolClient<
+      SqliteConnectionOptions,
+      SqliteConnection,
+      SqliteValue,
+      SqliteQueryOptions,
+      SqlitePreparedStatement,
+      SqliteTransactionOptions,
+      SqliteTransaction,
+      SqlPoolClientOptions
+    >
+  > {
+    const reserved = await this.pool.reserveConnection();
+    return new SqlitePoolClient(this.connectionUrl, reserved, this.options);
+  }
+
+  async connect(): Promise<void> {
+    // No-op
+  }
+
+  async close(): Promise<void> {
+    // TODO: this.eventTarget.dispatchEvent(new SqliteCloseEvent({}));
+    await this.pool.close();
+  }
+
+  async [Symbol.asyncDispose](): Promise<void> {
+    await this.close();
+  }
+}

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

@@ -1,7 +1,7 @@
 import * as fs from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 import { assert, test } from 'vitest';
-import { BetterSqliteClient, SqliteClient } from '../../lib/index.js';
+import { BetterSqliteClient, SqliteClientPool } from '../../lib/index.js';
 
 const assertEquals = assert.deepEqual;
 
@@ -12,8 +12,8 @@ test('sqlite', async () => {
   // Remove any existing test.db.
   await fs.rm(path).catch(() => {});
 
-  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);