@powersync/web 1.39.0 → 2.1.0

package/src/db/adapters/wa-sqlite/DatabaseClient.ts

@@ -2,23 +2,22 @@ import {
   QueryResult,
   LockContext,
   DBLockOptions,
-  DBAdapterListener,
-  ConnectionPool,
   SqlExecutor,
-  DBGetUtilsDefaultMixin,
   BatchedUpdateNotification,
-  BaseObserver,
-  ConnectionClosedError,
-  SQLOpenOptions
+  SQLOpenOptions,
+  DBAdapter,
+  RawQueryResult,
+  queryResultWithoutRows,
+  BaseQueryResult
 } from '@powersync/common';
 import { SharedConnectionWorker, WebDBAdapterConfiguration } from '../WebDBAdapter.js';
 import { ClientConnectionView } from './DatabaseServer.js';
-import { RawQueryResult } from './RawSqliteConnection.js';
 import * as Comlink from 'comlink';
-import { WorkerDBOpenerOptions } from './WASQLiteOpenFactory.js';
+import type { ConnectToMultiDatabaseServerOptions } from '../../../worker/db/MultiDatabaseServer.js';
+import { ConnectionClosedError } from '@powersync/shared-internals';
 
 export interface OpenWorkerConnection {
-  connect(config: WorkerDBOpenerOptions): Promise<ClientConnectionView>;
+  connect(config: ConnectToMultiDatabaseServerOptions): Promise<ClientConnectionView>;
   connectToExisting(options: { identifier: string; lockName: string }): Promise<ClientConnectionView>;
 }
 
@@ -44,10 +43,7 @@ export interface ClientOptions {
 /**
  * A single-connection {@link ConnectionPool} implementation based on a worker connection.
  */
-export class DatabaseClient<Config extends SQLOpenOptions = WebDBAdapterConfiguration>
-  extends BaseObserver<DBAdapterListener>
-  implements ConnectionPool
-{
+export class DatabaseClient<Config extends SQLOpenOptions = WebDBAdapterConfiguration> extends DBAdapter {
   #connection: ConnectionState;
   #shareConnectionAbortController = new AbortController();
   #receiveTableUpdates: MessagePort;
@@ -70,9 +66,7 @@ export class DatabaseClient<Config extends SQLOpenOptions = WebDBAdapterConfigur
     port2.onmessage = (event) => {
       const tables = event.data as string[];
       const notification: BatchedUpdateNotification = {
-        tables,
-        groupedUpdates: {},
-        rawUpdates: []
+        tables
       };
       this.iterateListeners((l) => {
         l.tablesUpdated && l.tablesUpdated(notification);
@@ -185,16 +179,17 @@ export class DatabaseClient<Config extends SQLOpenOptions = WebDBAdapterConfigur
 }
 
 /**
- * A {@link SqlExecutor} implemented by sending commands to a worker.
+ * A {@link LockContext} implemented by sending commands to a worker.
  *
  * While an instance is active, it has exclusive access to the underlying database connection (as represented by its
  * token).
  */
-class ClientSqlExecutor implements SqlExecutor {
+class ClientLockContext extends LockContext {
   readonly #connection: ConnectionState;
   readonly #token: string;
 
   constructor(connection: ConnectionState, token: string) {
+    super();
     this.#connection = connection;
     this.#token = token;
   }
@@ -223,37 +218,8 @@ class ClientSqlExecutor implements SqlExecutor {
     }
   }
 
-  async execute(query: string, params?: any[] | undefined): Promise<QueryResult> {
-    const rs = await this.#executeOnWorker(query, params);
-    let rows: QueryResult['rows'] | undefined;
-    if (rs.resultSet) {
-      const resultSet = rs.resultSet;
-
-      function rowToJavaScriptObject(row: any[]): Record<string, any> {
-        const obj: Record<string, any> = {};
-        resultSet.columns.forEach((key, idx) => (obj[key] = row[idx]));
-        return obj;
-      }
-
-      const mapped = resultSet.rows.map(rowToJavaScriptObject);
-
-      rows = {
-        _array: mapped,
-        length: mapped.length,
-        item: (idx: number) => mapped[idx]
-      };
-    }
-
-    return {
-      rowsAffected: rs.changes,
-      insertId: rs.lastInsertRowId,
-      rows
-    };
-  }
-
-  async executeRaw(query: string, params?: any[] | undefined): Promise<any[][]> {
-    const rs = await this.#executeOnWorker(query, params);
-    return rs.resultSet?.rows ?? [];
+  async executeRaw(query: string, params?: any[] | undefined): Promise<RawQueryResult> {
+    return await this.#executeOnWorker(query, params);
   }
 
   async #executeOnWorker(query: string, params: any[] | undefined): Promise<RawQueryResult> {
@@ -263,23 +229,21 @@ class ClientSqlExecutor implements SqlExecutor {
     );
   }
 
-  async executeBatch(query: string, params: any[][] = []): Promise<QueryResult> {
+  async executeBatch(query: string, params: any[][] = []): Promise<QueryResult<never>> {
     const results = await this.maybeTrace(
       (c) => c.executeBatch(this.#token, query, params),
       () => `${query} (batch of ${params.length})`
     );
-    const result: QueryResult = { insertId: undefined, rowsAffected: 0 };
+    const result: BaseQueryResult = { insertId: undefined, rowsAffected: 0 };
     for (const source of results) {
-      result.insertId = source.lastInsertRowId;
-      result.rowsAffected += source.changes;
+      result.insertId = source.insertId;
+      result.rowsAffected = (result.rowsAffected ?? 0) + source.rowsAffected;
     }
 
-    return result;
+    return queryResultWithoutRows(result);
   }
 }
 
-class ClientLockContext extends DBGetUtilsDefaultMixin(ClientSqlExecutor) implements LockContext {}
-
 interface ConnectionState {
   connection: ClientConnectionView;
   notifyRemoteClosed: AbortController | undefined;

package/src/db/adapters/wa-sqlite/DatabaseServer.ts

@@ -1,11 +1,11 @@
-import { ILogger } from '@powersync/common';
+import { LogLevels, PowerSyncLogger } from '@powersync/common';
 import { ConcurrentSqliteConnection, ConnectionLeaseToken } from './ConcurrentConnection.js';
-import { RawQueryResult } from './RawSqliteConnection.js';
+import { RawWebResult } from './RawSqliteConnection.js';
 
 export interface DatabaseServerOptions {
   inner: ConcurrentSqliteConnection;
   onClose: () => void;
-  logger: ILogger;
+  logger: PowerSyncLogger;
 }
 
 /**
@@ -24,7 +24,7 @@ export class DatabaseServer {
   constructor(options: DatabaseServerOptions) {
     this.#options = options;
     const inner = options.inner;
-    this.#updateBroadcastChannel = new BroadcastChannel(`${inner.options.dbFilename}-table-updates`);
+    this.#updateBroadcastChannel = new BroadcastChannel(`${inner.options.filename}-table-updates`);
 
     this.#updateBroadcastChannel.onmessage = ({ data }) => {
       this.#pushTableUpdateToClients(data as string[]);
@@ -85,7 +85,7 @@ export class DatabaseServer {
 
         // If the client holds a connection lease it hasn't returned, return that now.
         for (const { lease } of connectionLeases.values()) {
-          this.#logger.debug(`Closing connection lease that hasn't been returned.`);
+          this.#logger.log({ level: LogLevels.debug, message: `Closing connection lease that hasn't been returned.` });
           await lease.returnLease();
         }
 
@@ -94,7 +94,10 @@ export class DatabaseServer {
         if (this.#activeClients.size == 0) {
           await this.forceClose();
         } else {
-          this.#logger.debug('Keeping underlying connection active since its used by other clients.');
+          this.#logger.log({
+            level: LogLevels.debug,
+            message: 'Keeping underlying connection active since its used by other clients.'
+          });
         }
       }
     };
@@ -133,9 +136,9 @@ export class DatabaseServer {
         try {
           if (lease.write) {
             // Collect update hooks invoked while the client had the write connection.
-            const { resultSet } = await lease.lease.use((conn) => conn.execute(`SELECT powersync_update_hooks('get')`));
-            if (resultSet) {
-              const updatedTables: string[] = JSON.parse(resultSet.rows[0][0] as string);
+            const { rawRows } = await lease.lease.use((conn) => conn.execute(`SELECT powersync_update_hooks('get')`));
+            if (rawRows.length) {
+              const updatedTables: string[] = JSON.parse(rawRows[0][0] as string);
               if (updatedTables.length) {
                 this.#updateBroadcastChannel.postMessage(updatedTables);
                 this.#pushTableUpdateToClients(updatedTables);
@@ -169,7 +172,10 @@ export class DatabaseServer {
   }
 
   async forceClose() {
-    this.#logger.debug(`Closing connection to ${this.#inner.options}.`);
+    this.#logger.log({
+      level: LogLevels.debug,
+      message: `Closing connection to ${JSON.stringify(this.#inner.options)}.`
+    });
     const connection = this.#inner;
     this.#options.onClose();
     this.#updateBroadcastChannel.close();
@@ -190,8 +196,8 @@ export interface ClientConnectionView {
    * give other clients access to the database afterwards.
    */
   requestAccess(write: boolean, timeoutMs?: number): Promise<string>;
-  execute(token: string, sql: string, params: any[] | undefined): Promise<RawQueryResult>;
-  executeBatch(token: string, sql: string, params: any[][]): Promise<RawQueryResult[]>;
+  execute(token: string, sql: string, params: any[] | undefined): Promise<RawWebResult>;
+  executeBatch(token: string, sql: string, params: any[][]): Promise<RawWebResult[]>;
   completeAccess(token: string): Promise<void>;
 
   /**

package/src/db/adapters/wa-sqlite/RawSqliteConnection.ts

@@ -1,18 +1,29 @@
 import { Factory as WaSqliteFactory, SQLITE_ROW } from '@journeyapps/wa-sqlite';
 
-import { loadModuleAndVfs } from './vfs.js';
-import { ResolvedWASQLiteOpenFactoryOptions } from './WASQLiteOpenFactory.js';
+import { loadModuleAndVfs, WASQLiteVFS } from './vfs.js';
+import { TemporaryStorageOption } from '../options.js';
+import { RawQueryResult, SqliteValue } from '@powersync/common';
+import { maxPathNameLength } from '../resolveAndValidateOptions.js';
+
+export interface RawWebResult extends Required<RawQueryResult> {
+  autocommit: boolean;
+}
 
 export interface RawResultSet {
-  columns: string[];
-  rows: SQLiteCompatibleType[][];
+  columnNames: string[];
+  rawRows: SqliteValue[][];
 }
 
-export interface RawQueryResult {
-  changes: number;
-  lastInsertRowId: number;
-  autocommit: boolean;
-  resultSet: RawResultSet | undefined;
+/**
+ * @internal
+ */
+export interface RawWaSqliteDatabaseOptions {
+  filename: string;
+  readonly: boolean;
+  vfs: WASQLiteVFS;
+  encryptionKey: string | undefined;
+  temporaryStorage: TemporaryStorageOption;
+  cacheSizeKb: number;
 }
 
 /**
@@ -28,7 +39,7 @@ export class RawSqliteConnection {
    */
   private db: number = 0;
 
-  constructor(readonly options: ResolvedWASQLiteOpenFactoryOptions) {}
+  constructor(readonly options: RawWaSqliteDatabaseOptions) {}
 
   get isOpen(): boolean {
     return this.db != 0;
@@ -37,8 +48,8 @@ export class RawSqliteConnection {
   async init() {
     const api = (this._sqliteAPI = await this.openSQLiteAPI());
     this.db = await api.open_v2(
-      this.options.dbFilename,
-      this.options.isReadOnly ? 1 /* SQLITE_OPEN_READONLY */ : 6 /* SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE */
+      this.options.filename,
+      this.options.readonly ? 1 /* SQLITE_OPEN_READONLY */ : 6 /* SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE */
     );
     await this.executeRaw(`PRAGMA temp_store = ${this.options.temporaryStorage};`);
     if (this.options.encryptionKey) {
@@ -52,6 +63,7 @@ export class RawSqliteConnection {
 
   private async openSQLiteAPI(): Promise<SQLiteAPI> {
     const { module, vfs } = await loadModuleAndVfs(this.options);
+    vfs.mxPathname = maxPathNameLength;
     const sqlite3 = WaSqliteFactory(module);
     sqlite3.vfs_register(vfs, true);
     /**
@@ -63,7 +75,7 @@ export class RawSqliteConnection {
      * Create the multiple cipher vfs if an encryption key is provided
      */
     if (this.options.encryptionKey) {
-      const createResult = module.ccall('sqlite3mc_vfs_create', 'int', ['string', 'int'], [this.options.dbFilename, 1]);
+      const createResult = module.ccall('sqlite3mc_vfs_create', 'int', ['string', 'int'], [this.options.filename, 1]);
       if (createResult !== 0) {
         throw new Error('Failed to create multiple cipher vfs, Database encryption will not work');
       }
@@ -87,12 +99,12 @@ export class RawSqliteConnection {
     return this.requireSqlite().get_autocommit(this.db) != 0;
   }
 
-  async execute(sql: string, bindings?: any[]): Promise<RawQueryResult> {
+  async execute(sql: string, bindings?: any[]): Promise<RawWebResult> {
     const resultSet = await this.executeSingleStatementRaw(sql, bindings);
     return this.wrapQueryResults(this.requireSqlite(), resultSet);
   }
 
-  async executeBatch(sql: string, bindings: any[][]): Promise<RawQueryResult[]> {
+  async executeBatch(sql: string, bindings: any[][]): Promise<RawWebResult[]> {
     const results = [];
     const api = this.requireSqlite();
     for await (const stmt of api.statements(this.db, sql)) {
@@ -110,21 +122,22 @@ export class RawSqliteConnection {
     return results;
   }
 
-  private wrapQueryResults(api: SQLiteAPI, rs: RawResultSet | undefined): RawQueryResult {
+  private wrapQueryResults(api: SQLiteAPI, { rawRows, columnNames }: RawResultSet): RawWebResult {
     return {
-      changes: api.changes(this.db),
-      lastInsertRowId: api.last_insert_id(this.db),
+      rowsAffected: api.changes(this.db),
+      insertId: api.last_insert_id(this.db),
       autocommit: api.get_autocommit(this.db) != 0,
-      resultSet: rs
+      rawRows,
+      columnNames
     };
   }
 
   /**
    * This executes a single statement using SQLite3 and returns the results as a {@link RawResultSet}.
    */
-  private async executeSingleStatementRaw(sql: string, bindings?: any[]): Promise<RawResultSet | undefined> {
+  private async executeSingleStatementRaw(sql: string, bindings?: any[]): Promise<RawResultSet> {
     const results = await this.executeRaw(sql, bindings);
-    return results.length ? results[0] : undefined;
+    return results.length ? results[0] : { columnNames: [], rawRows: [] };
   }
 
   async executeRaw(sql: string, bindings?: any[]): Promise<RawResultSet[]> {
@@ -134,7 +147,7 @@ export class RawSqliteConnection {
       let columns;
 
       const rs = await this.stepThroughStatement(api, stmt, bindings ?? [], columns);
-      columns = rs.columns;
+      columns = rs.columnNames;
       if (columns.length) {
         results.push(rs);
       }
@@ -176,7 +189,7 @@ export class RawSqliteConnection {
     }
 
     knownColumns ??= api.column_names(stmt);
-    return { columns: knownColumns, rows };
+    return { columnNames: knownColumns, rawRows: rows };
   }
 
   async close() {

package/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.ts

@@ -1,70 +1,38 @@
-import { createLogger, DBAdapter, ILogger, SQLOpenFactory, type ILogLevel } from '@powersync/common';
+import { DBAdapter, LogLevels, PowerSyncLogger, SQLOpenFactory } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database.js';
-import {
-  DEFAULT_CACHE_SIZE_KB,
-  isServerSide,
-  ResolvedWebSQLFlags,
-  ResolvedWebSQLOpenOptions,
-  resolveWebSQLFlags,
-  TemporaryStorageOption,
-  WebSQLOpenFactoryOptions
-} from '../web-sql-flags.js';
+import { ResolvedWebSQLOpenOptions, WebSQLOpenOptions } from '../options.js';
 import { SSRDBAdapter } from '../SSRDBAdapter.js';
 import { vfsRequiresDedicatedWorkers, WASQLiteVFS } from './vfs.js';
 import { MultiDatabaseServer } from '../../../worker/db/MultiDatabaseServer.js';
 import { DatabaseClient, OpenWorkerConnection } from './DatabaseClient.js';
 import { generateTabCloseSignal } from '../../../shared/tab_close_signal.js';
 import { AsyncDbAdapter, PoolConnection } from '../AsyncWebAdapter.js';
+import { RawWaSqliteDatabaseOptions } from './RawSqliteConnection.js';
+import { maxPathNameLength, resolveAndValidateOptions } from '../resolveAndValidateOptions.js';
+import { connectToExistingWorker, connectToWorker, WorkerConnection } from '../../../worker/client.js';
 
-export interface WASQLiteOpenFactoryOptions extends WebSQLOpenFactoryOptions {
-  vfs?: WASQLiteVFS;
-  /**
-   * If the {@link vfs} supports it, an additional amount of read-only connections to open. Using additional read
-   * connections can speed up queries by dispatching them to multiple workers running them concurrently.
-   *
-   * {@link WASQLiteVFS.OPFSWriteAheadVFS} is the only VFS with support for multiple connections, so this option is
-   * ignored for other VFS implementations.
-   *
-   * Defaults to 1.
-   */
-  additionalReaders?: number;
-}
-
-export interface ResolvedWASQLiteOpenFactoryOptions extends ResolvedWebSQLOpenOptions {
-  vfs: WASQLiteVFS;
-
-  /**
-   * Whether this is a read-only connection opened for the `OPFSWriteAheadVFS` file system.
-   */
-  isReadOnly: boolean;
-}
-
-export interface WorkerDBOpenerOptions extends ResolvedWASQLiteOpenFactoryOptions {
-  logLevel: ILogLevel;
-  /**
-   * A lock that is currently held by the client. When the lock is returned, we know the client is gone and that we need
-   * to clean up resources.
-   */
-  lockName: string;
+export interface WASQLiteOpenFactoryOptions {
+  open: WebSQLOpenOptions;
+  logger: PowerSyncLogger;
 }
 
 /**
  * Opens a SQLite connection using WA-SQLite.
  */
 export class WASQLiteOpenFactory implements SQLOpenFactory {
-  private resolvedFlags: ResolvedWebSQLFlags;
-  private logger: ILogger;
+  private options: ResolvedWebSQLOpenOptions;
+  private logger: PowerSyncLogger;
 
-  constructor(private options: WASQLiteOpenFactoryOptions) {
-    assertValidWASQLiteOpenFactoryOptions(options);
-    this.resolvedFlags = resolveWebSQLFlags(options.flags);
-    this.logger = options.logger ?? createLogger(`WASQLiteOpenFactory - ${this.options.dbFilename}`);
-  }
+  constructor(options: WASQLiteOpenFactoryOptions) {
+    this.options = resolveAndValidateOptions(options.open);
 
-  get waOptions(): WASQLiteOpenFactoryOptions {
-    // Cast to extended type
-    return this.options;
+    // Account for the fact that SQLite might append -journal suffixes
+    const maxLength = maxPathNameLength - 16;
+    if (this.options.dbFilename.length > maxLength) {
+      throw new Error(`dbFilename too long (max length is ${maxLength})`);
+    }
+
+    this.logger = options.logger;
   }
 
   protected openAdapter(): DBAdapter {
@@ -72,84 +40,81 @@ export class WASQLiteOpenFactory implements SQLOpenFactory {
   }
 
   openDB(): DBAdapter {
-    const {
-      resolvedFlags: { disableSSRWarning, enableMultiTabs, ssrMode = isServerSide() }
-    } = this;
+    const { disableSSRWarning, enableMultiTabs, ssrMode } = this.options;
+
     if (ssrMode) {
       if (!disableSSRWarning) {
-        this.logger.warn(
-          `
+        this.logger.log({
+          level: LogLevels.warn,
+          message: `
       Running PowerSync in SSR mode.
       Only empty query results will be returned.
       Disable this warning by setting 'disableSSRWarning: true' in options.`
-        );
+        });
       }
 
       return new SSRDBAdapter();
     }
 
     if (!enableMultiTabs) {
-      this.logger.warn(
-        'Multiple tab support is not enabled. Using this site across multiple tabs may not function correctly.'
-      );
+      this.logger.log({
+        level: LogLevels.warn,
+        message: 'Multiple tab support is not enabled. Using this site across multiple tabs may not function correctly.'
+      });
     }
 
     return this.openAdapter();
   }
 
   async openConnection(): Promise<PoolConnection> {
-    const { enableMultiTabs, useWebWorker } = this.resolvedFlags;
-    const {
-      vfs = WASQLiteVFS.IDBBatchAtomicVFS,
-      temporaryStorage = TemporaryStorageOption.MEMORY,
-      cacheSizeKb = DEFAULT_CACHE_SIZE_KB,
-      encryptionKey
-    } = this.waOptions;
+    const { enableMultiTabs, useWebWorker, vfs, dbFilename, encryptionKey, temporaryStorage, cacheSizeKb } =
+      this.options;
 
     if (!enableMultiTabs) {
-      this.logger.warn('Multiple tabs are not enabled in this browser');
+      this.logger.log({ level: LogLevels.warn, message: 'Multiple tabs are not enabled in this browser' });
     }
 
-    const resolveOptions = (isReadOnly: boolean): ResolvedWASQLiteOpenFactoryOptions => ({
-      dbFilename: this.options.dbFilename,
-      dbLocation: this.options.dbLocation,
-      debugMode: this.options.debugMode,
-      vfs,
-      temporaryStorage,
-      cacheSizeKb,
-      flags: this.resolvedFlags,
-      encryptionKey: encryptionKey,
-      isReadOnly
-    });
-
     let client: DatabaseClient;
     let additionalReaders: DatabaseClient[] = [];
     let requiresPersistentTriggers = vfsRequiresDedicatedWorkers(vfs);
 
+    function resolveRawWaSqliteDatabaseOptions(readonly: boolean): RawWaSqliteDatabaseOptions {
+      return {
+        filename: dbFilename,
+        readonly,
+        vfs,
+        encryptionKey,
+        temporaryStorage,
+        cacheSizeKb
+      };
+    }
+
     if (useWebWorker) {
       const optionsDbWorker = this.options.worker;
 
-      const openDatabaseWorker = async (
-        resolvedOptions: ResolvedWASQLiteOpenFactoryOptions
-      ): Promise<DatabaseClient> => {
-        const workerPort =
-          typeof optionsDbWorker == 'function'
-            ? resolveWorkerDatabasePortFactory(() =>
-                optionsDbWorker({
-                  ...this.options,
-                  temporaryStorage,
-                  cacheSizeKb,
-                  flags: this.resolvedFlags,
-                  encryptionKey
-                })
-              )
-            : openWorkerDatabasePort(this.options.dbFilename, enableMultiTabs, optionsDbWorker, this.waOptions.vfs);
-
-        const source = Comlink.wrap<OpenWorkerConnection>(workerPort);
+      const openDatabaseWorker = async (readonly: boolean): Promise<DatabaseClient> => {
+        let workerConnection: WorkerConnection;
+        if (typeof optionsDbWorker == 'function') {
+          const worker = optionsDbWorker(this.options);
+          workerConnection = connectToExistingWorker(worker, this.logger, 'database');
+        } else {
+          const needsDedicated = vfsRequiresDedicatedWorkers(vfs);
+          const useShared = !needsDedicated && enableMultiTabs;
+
+          workerConnection = connectToWorker({
+            service: 'database',
+            databaseIdentifier: this.options.dbFilename,
+            shared: useShared,
+            customWorker: optionsDbWorker,
+            loggerForErrors: this.logger
+          });
+        }
+
+        const source = Comlink.wrap<OpenWorkerConnection>(workerConnection.endpoint);
         const closeSignal = new AbortController();
         const connection = await source.connect({
-          ...resolvedOptions,
-          logLevel: this.logger.getLevel(),
+          database: resolveRawWaSqliteDatabaseOptions(readonly),
+          logLevel: this.options.databaseWorkerLogLevel,
           lockName: await generateTabCloseSignal(closeSignal.signal)
         });
         const clientOptions = {
@@ -159,28 +124,24 @@ export class WASQLiteOpenFactory implements SQLOpenFactory {
           remoteCanCloseUnexpectedly: false,
           onClose: () => {
             closeSignal.abort();
-            if (workerPort instanceof Worker) {
-              workerPort.terminate();
-            } else {
-              workerPort.close();
-            }
+            workerConnection.close();
           }
         };
 
         return new DatabaseClient(clientOptions, {
-          ...resolvedOptions,
+          ...this.options,
           requiresPersistentTriggers
         });
       };
 
-      client = await openDatabaseWorker(resolveOptions(false));
+      client = await openDatabaseWorker(false);
 
       if (vfs == WASQLiteVFS.OPFSWriteAheadVFS) {
         // This VFS supports concurrent reads, so we can open additional workers to host read-only connections for
         // concurrent reads / writes.
         const additionalReadersCount = this.options.additionalReaders ?? 1;
         for (let i = 0; i < additionalReadersCount; i++) {
-          const reader = await openDatabaseWorker(resolveOptions(true));
+          const reader = await openDatabaseWorker(true);
           additionalReaders.push(reader);
         }
       }
@@ -189,12 +150,11 @@ export class WASQLiteOpenFactory implements SQLOpenFactory {
       const localServer = new MultiDatabaseServer(this.logger);
       requiresPersistentTriggers = true;
 
-      const resolvedOptions = resolveOptions(false);
-      const connection = await localServer.openConnectionLocally(resolvedOptions);
+      const connection = await localServer.openConnectionLocally(this.logger, resolveRawWaSqliteDatabaseOptions(false));
       client = new DatabaseClient(
         { connection, source: null, remoteCanCloseUnexpectedly: false },
         {
-          ...resolvedOptions,
+          ...this.options,
           requiresPersistentTriggers
         }
       );
@@ -206,18 +166,3 @@ export class WASQLiteOpenFactory implements SQLOpenFactory {
     };
   }
 }
-
-/**
- * Asserts that the factory options are valid.
- */
-function assertValidWASQLiteOpenFactoryOptions(options: WASQLiteOpenFactoryOptions): void {
-  // The OPFS VFS only works in dedicated web workers.
-  if ('vfs' in options && 'flags' in options) {
-    const { vfs, flags = {} } = options;
-    if (vfs && vfsRequiresDedicatedWorkers(vfs) && 'useWebWorker' in flags && !flags.useWebWorker) {
-      throw new Error(
-        `Invalid configuration: The 'useWebWorker' flag must be true when using an OPFS-based VFS (${vfs}).`
-      );
-    }
-  }
-}