Fix driver options.

Author: rkistner

packages/better-sqlite3-driver/src/driver.ts

@@ -50,7 +50,8 @@ export class BetterSqliteDriver implements SqliteDriverConnectionPool {
 
     const connection = new ReadWriteConnectionPool({
       async openConnection(connectionOptions) {
-        return new WorkerDriverConnection(workerPath, path, {
+        return new WorkerDriverConnection(workerPath, {
+          path,
           ...options,
           readonly: connectionOptions?.readonly || false
         });

packages/better-sqlite3-driver/src/sync-driver.ts

@@ -281,6 +281,7 @@ export class BetterSqliteConnection implements SqliteDriverConnection {
     const con = new DatabaseConstructor(path, options);
     con.exec('PRAGMA journal_mode = WAL');
     con.exec('PRAGMA synchronous = normal');
+
     if (options?.loadExtensions) {
       for (let extension of options.loadExtensions) {
         con.loadExtension(extension);

packages/better-sqlite3-driver/src/worker.ts

@@ -3,11 +3,13 @@ import { BetterSqliteConnection } from './sync-driver.js';
 import {
   retriedOpen,
   setupDriverWorker,
-  ConnectionOptions
+  WorkerDriverConnectionOptions
 } from '@sqlite-js/driver/worker_threads/setup';
 
 setupDriverWorker({
-  async openConnection(options: ConnectionOptions & BetterSqliteDriverOptions) {
+  async openConnection(
+    options: WorkerDriverConnectionOptions & BetterSqliteDriverOptions
+  ) {
     return retriedOpen(() => {
       return BetterSqliteConnection.open(options.path, options);
     }, 2_000);

packages/driver/src/node/driver.ts

@@ -48,7 +48,8 @@ export class NodeSqliteDriver implements SqliteDriverConnectionPool {
     const connection = new ReadWriteConnectionPool(
       {
         openConnection: async (connectionOptions) => {
-          return new WorkerDriverConnection(workerPath, path, {
+          return new WorkerDriverConnection(workerPath, {
+            path,
             readonly: connectionOptions?.readonly ?? false,
             connectionName: connectionOptions?.connectionName,
             workerOptions: {

packages/driver/src/util/MultiConnectionPool.ts

@@ -21,6 +21,8 @@ export class MultiConnectionPool implements SqliteDriverConnectionPool {
   private _queue: QueuedPoolItem[] = [];
   private _maxConnections: number;
 
+  private options: ConnectionPoolOptions;
+
   [Symbol.asyncDispose]: () => Promise<void> = undefined as any;
 
   constructor(
@@ -31,6 +33,7 @@ export class MultiConnectionPool implements SqliteDriverConnectionPool {
       this[Symbol.asyncDispose] = () => this.close();
     }
     this._maxConnections = options?.maxConnections ?? 2;
+    this.options = options ?? {};
   }
 
   reserveConnection(
@@ -52,6 +55,7 @@ export class MultiConnectionPool implements SqliteDriverConnectionPool {
     options?: ReserveConnectionOptions
   ): Promise<SqliteDriverConnection> {
     const connection = await this.factory.openConnection({
+      ...this.options,
       ...options,
       connectionName: `connection-${this._allConnections.size + 1}`
     });

packages/driver/src/util/ReadWriteConnectionPool.ts

@@ -21,9 +21,8 @@ export class ReadWriteConnectionPool implements SqliteDriverConnectionPool {
 
   constructor(factory: DriverFactory, options?: ConnectionPoolOptions) {
     this.readPool = new MultiConnectionPool(factory, options);
-
     this.initPromise = factory
-      .openConnection({ readonly: false, connectionName: 'writer' })
+      .openConnection({ ...options, readonly: false, connectionName: 'writer' })
       .then((con) => {
         this.writePool = new SingleConnectionPool(con);
       });

packages/driver/src/worker_threads/setup.ts

@@ -3,15 +3,14 @@ import { isErrorResponse, WorkerDriver } from './async-commands.js';
 import { setTimeout } from 'timers/promises';
 
 import * as worker_threads from 'worker_threads';
+import type { WorkerDriverConnectionOptions } from './worker-driver.js';
 
-export interface ConnectionOptions {
-  path: string;
-  readonly?: boolean;
-  connectionName?: string;
-}
+export type { WorkerDriverConnectionOptions };
 
 export interface WorkerDriverConfig {
-  openConnection: (options: ConnectionOptions) => Promise<WorkerDriver>;
+  openConnection: (
+    options: WorkerDriverConnectionOptions
+  ) => Promise<WorkerDriver>;
 }
 
 export function setupDriverWorker(config: WorkerDriverConfig) {
@@ -32,7 +31,7 @@ export function setupDriverPort(
 
     if (message == 'open') {
       try {
-        db = await config.openConnection(args);
+        db = await config.openConnection(args as WorkerDriverConnectionOptions);
         port.postMessage({ id });
         opened.resolve();
       } catch (e: any) {

packages/driver/src/worker_threads/worker-driver.ts

@@ -23,6 +23,7 @@ import {
 } from './async-commands.js';
 
 export interface WorkerDriverConnectionOptions {
+  path: string;
   connectionName?: string;
   readonly?: boolean;
   workerOptions?: worker_threads.WorkerOptions;
@@ -43,14 +44,13 @@ export class WorkerDriverConnection implements SqliteDriverConnection {
 
   constructor(
     workerPath: string | URL,
-    path: string,
-    options?: WorkerDriverConnectionOptions
+    options: WorkerDriverConnectionOptions
   ) {
     const worker = new worker_threads.Worker(
       workerPath,
       options?.workerOptions
     );
-    this.post('open', { path, options });
+    this.post('open', options);
     worker.addListener('error', (err) => {
       console.error('worker error', err);
     });