@powersync/web 1.35.0 → 1.37.0

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

@@ -0,0 +1,201 @@
+import { ILogger } from '@powersync/common';
+import { ConcurrentSqliteConnection, ConnectionLeaseToken } from './ConcurrentConnection.js';
+import { RawQueryResult } from './RawSqliteConnection.js';
+
+export interface DatabaseServerOptions {
+  inner: ConcurrentSqliteConnection;
+  onClose: () => void;
+  logger: ILogger;
+}
+
+/**
+ * Access to a WA-sqlite connection that can be shared with multiple clients sending queries over an RPC protocol built
+ * with the Comlink package.
+ */
+export class DatabaseServer {
+  #options: DatabaseServerOptions;
+  #nextClientId = 0;
+  #activeClients = new Set<number>();
+
+  // TODO: Don't use a broadcast channel for connections managed by a shared worker.
+  #updateBroadcastChannel: BroadcastChannel;
+  #clientTableListeners = new Set<MessagePort>();
+
+  constructor(options: DatabaseServerOptions) {
+    this.#options = options;
+    const inner = options.inner;
+    this.#updateBroadcastChannel = new BroadcastChannel(`${inner.options.dbFilename}-table-updates`);
+
+    this.#updateBroadcastChannel.onmessage = ({ data }) => {
+      this.#pushTableUpdateToClients(data as string[]);
+    };
+  }
+
+  #pushTableUpdateToClients(changedTables: string[]) {
+    for (const listener of this.#clientTableListeners) {
+      listener.postMessage(changedTables);
+    }
+  }
+
+  get #inner() {
+    return this.#options.inner;
+  }
+
+  get #logger() {
+    return this.#options.logger;
+  }
+
+  /**
+   * Called by clients when they wish to connect to this database.
+   *
+   * @param lockName 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.
+   */
+  async connect(lockName?: string): Promise<ClientConnectionView> {
+    let isOpen = true;
+    const clientId = this.#nextClientId++;
+    this.#activeClients.add(clientId);
+
+    let connectionLeases = new Map<string, { lease: ConnectionLeaseToken; write: boolean }>();
+    let currentTableListener: MessagePort | undefined;
+
+    function requireOpen() {
+      if (!isOpen) {
+        throw new Error('Client has already been closed');
+      }
+    }
+
+    function requireOpenAndLease(lease: string) {
+      requireOpen();
+      const token = connectionLeases.get(lease);
+      if (!token) {
+        throw new Error('Attempted to use a connection lease that has already been returned.');
+      }
+
+      return token;
+    }
+
+    const close = async () => {
+      if (isOpen) {
+        isOpen = false;
+
+        if (currentTableListener) {
+          this.#clientTableListeners.delete(currentTableListener);
+        }
+
+        // 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.`);
+          await lease.returnLease();
+        }
+
+        this.#activeClients.delete(clientId);
+
+        if (this.#activeClients.size == 0) {
+          await this.forceClose();
+        } else {
+          this.#logger.debug('Keeping underlying connection active since its used by other clients.');
+        }
+      }
+    };
+
+    if (lockName) {
+      navigator.locks!.request(lockName, {}, () => {
+        close();
+      });
+    }
+
+    return {
+      close,
+      debugIsAutoCommit: async () => {
+        return this.#inner.unsafeUseInner().isAutoCommit();
+      },
+      requestAccess: async (write, timeoutMs) => {
+        requireOpen();
+        // TODO: Support timeouts, they don't seem to be supported by the async-mutex package.
+        const lease = await this.#inner.acquireConnection();
+        if (!isOpen) {
+          // Race between requestAccess and close(), the connection was closed while we tried to acquire a lease.
+          await lease.returnLease();
+          return requireOpen() as never;
+        }
+
+        const token = crypto.randomUUID();
+        connectionLeases.set(token, { lease, write });
+        return token;
+      },
+      completeAccess: async (token) => {
+        const lease = requireOpenAndLease(token);
+        connectionLeases.delete(token);
+
+        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);
+              if (updatedTables.length) {
+                this.#updateBroadcastChannel.postMessage(updatedTables);
+                this.#pushTableUpdateToClients(updatedTables);
+              }
+            }
+          }
+        } finally {
+          await lease.lease.returnLease();
+        }
+      },
+      execute: async (token, sql, params) => {
+        const { lease } = requireOpenAndLease(token);
+        return await lease.use((db) => db.execute(sql, params));
+      },
+      executeBatch: async (token, sql, params) => {
+        const { lease } = requireOpenAndLease(token);
+        return await lease.use((db) => db.executeBatch(sql, params));
+      },
+      setUpdateListener: async (listener) => {
+        requireOpen();
+        if (currentTableListener) {
+          this.#clientTableListeners.delete(currentTableListener);
+        }
+
+        currentTableListener = listener;
+        if (listener) {
+          this.#clientTableListeners.add(listener);
+        }
+      }
+    };
+  }
+
+  async forceClose() {
+    this.#logger.debug(`Closing connection to ${this.#inner.options}.`);
+    const connection = this.#inner;
+    this.#options.onClose();
+    this.#updateBroadcastChannel.close();
+    await connection.close();
+  }
+}
+
+export interface ClientConnectionView {
+  close(): Promise<void>;
+  /**
+   * Only used for testing purposes.
+   */
+  debugIsAutoCommit(): Promise<boolean>;
+  /**
+   * Requests exclusive access to this database connection.
+   *
+   * Returns a token that can be used with the query methods. It must be returned with {@link completeAccess} to
+   * 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[]>;
+  completeAccess(token: string): Promise<void>;
+
+  /**
+   * Sends update notifications to the given message port.
+   *
+   * Update notifications are posted as a `string[]` message.
+   */
+  setUpdateListener(listener: MessagePort): Promise<void>;
+}

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

@@ -0,0 +1,191 @@
+import { Factory as WaSqliteFactory, SQLITE_ROW } from '@journeyapps/wa-sqlite';
+
+import { DEFAULT_MODULE_FACTORIES, WASQLiteModuleFactory } from './vfs.js';
+import { ResolvedWASQLiteOpenFactoryOptions } from './WASQLiteOpenFactory.js';
+
+export interface RawResultSet {
+  columns: string[];
+  rows: SQLiteCompatibleType[][];
+}
+
+export interface RawQueryResult {
+  changes: number;
+  lastInsertRowId: number;
+  autocommit: boolean;
+  resultSet: RawResultSet | undefined;
+}
+
+/**
+ * A small wrapper around WA-sqlite to help with opening databases and running statements by preparing them internally.
+ *
+ * This is an internal class, and it must never be used directly. Wrappers are required to ensure raw connections aren't
+ * used concurrently across tabs.
+ */
+export class RawSqliteConnection {
+  private _sqliteAPI: SQLiteAPI | null = null;
+  /**
+   * The `sqlite3*` connection pointer.
+   */
+  private db: number = 0;
+  private _moduleFactory: WASQLiteModuleFactory;
+
+  constructor(readonly options: ResolvedWASQLiteOpenFactoryOptions) {
+    this._moduleFactory = DEFAULT_MODULE_FACTORIES[this.options.vfs];
+  }
+
+  get isOpen(): boolean {
+    return this.db != 0;
+  }
+
+  async init() {
+    const api = (this._sqliteAPI = await this.openSQLiteAPI());
+    this.db = await api.open_v2(this.options.dbFilename);
+    await this.executeRaw(`PRAGMA temp_store = ${this.options.temporaryStorage};`);
+    if (this.options.encryptionKey) {
+      const escapedKey = this.options.encryptionKey.replace("'", "''");
+      await this.executeRaw(`PRAGMA key = '${escapedKey}'`);
+    }
+    await this.executeRaw(`PRAGMA cache_size = -${this.options.cacheSizeKb};`);
+
+    await this.executeRaw(`SELECT powersync_update_hooks('install');`);
+  }
+
+  private async openSQLiteAPI(): Promise<SQLiteAPI> {
+    const { module, vfs } = await this._moduleFactory({
+      dbFileName: this.options.dbFilename,
+      encryptionKey: this.options.encryptionKey
+    });
+    const sqlite3 = WaSqliteFactory(module);
+    sqlite3.vfs_register(vfs, true);
+    /**
+     * Register the PowerSync core SQLite extension
+     */
+    module.ccall('powersync_init_static', 'int', []);
+
+    /**
+     * 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]);
+      if (createResult !== 0) {
+        throw new Error('Failed to create multiple cipher vfs, Database encryption will not work');
+      }
+    }
+
+    return sqlite3;
+  }
+
+  requireSqlite(): SQLiteAPI {
+    if (!this._sqliteAPI) {
+      throw new Error(`Initialization has not completed`);
+    }
+    return this._sqliteAPI;
+  }
+
+  /**
+   * Checks if the database connection is in autocommit mode.
+   * @returns true if in autocommit mode, false if in a transaction
+   */
+  isAutoCommit(): boolean {
+    return this.requireSqlite().get_autocommit(this.db) != 0;
+  }
+
+  async execute(sql: string, bindings?: any[]): Promise<RawQueryResult> {
+    const resultSet = await this.executeSingleStatementRaw(sql, bindings);
+    return this.wrapQueryResults(this.requireSqlite(), resultSet);
+  }
+
+  async executeBatch(sql: string, bindings: any[][]): Promise<RawQueryResult[]> {
+    const results = [];
+    const api = this.requireSqlite();
+    for await (const stmt of api.statements(this.db, sql)) {
+      let columns;
+
+      for (const parameterSet of bindings) {
+        const rs = await this.stepThroughStatement(api, stmt, parameterSet, columns, false);
+        results.push(this.wrapQueryResults(api, rs));
+      }
+
+      // executeBatch can only use a single statement
+      break;
+    }
+
+    return results;
+  }
+
+  private wrapQueryResults(api: SQLiteAPI, rs: RawResultSet | undefined): RawQueryResult {
+    return {
+      changes: api.changes(this.db),
+      lastInsertRowId: api.last_insert_id(this.db),
+      autocommit: api.get_autocommit(this.db) != 0,
+      resultSet: rs
+    };
+  }
+
+  /**
+   * 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> {
+    const results = await this.executeRaw(sql, bindings);
+    return results.length ? results[0] : undefined;
+  }
+
+  async executeRaw(sql: string, bindings?: any[]): Promise<RawResultSet[]> {
+    const results = [];
+    const api = this.requireSqlite();
+    for await (const stmt of api.statements(this.db, sql)) {
+      let columns;
+
+      const rs = await this.stepThroughStatement(api, stmt, bindings ?? [], columns);
+      columns = rs.columns;
+      if (columns.length) {
+        results.push(rs);
+      }
+
+      // When binding parameters, only a single statement is executed.
+      if (bindings) {
+        break;
+      }
+    }
+
+    return results;
+  }
+
+  private async stepThroughStatement(
+    api: SQLiteAPI,
+    stmt: number,
+    bindings: any[],
+    knownColumns: string[] | undefined,
+    includeResults: boolean = true
+  ): Promise<RawResultSet> {
+    // TODO not sure why this is needed currently, but booleans break
+    bindings.forEach((b, index, arr) => {
+      if (typeof b == 'boolean') {
+        arr[index] = b ? 1 : 0;
+      }
+    });
+
+    api.reset(stmt);
+    if (bindings) {
+      api.bind_collection(stmt, bindings);
+    }
+
+    const rows = [];
+    while ((await api.step(stmt)) === SQLITE_ROW) {
+      if (includeResults) {
+        const row = api.row(stmt);
+        rows.push(row);
+      }
+    }
+
+    knownColumns ??= api.column_names(stmt);
+    return { columns: knownColumns, rows };
+  }
+
+  async close() {
+    if (this.isOpen) {
+      await this.requireSqlite().close(this.db);
+      this.db = 0;
+    }
+  }
+}

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

@@ -1,17 +1,21 @@
-import { DBAdapter, type ILogLevel } from '@powersync/common';
+import { createLogger, DBAdapter, ILogger, SQLOpenFactory, type ILogLevel } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database.js';
-import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory.js';
-import { AsyncDatabaseConnection, OpenAsyncDatabaseConnection } from '../AsyncDatabaseConnection.js';
-import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection.js';
 import {
   DEFAULT_CACHE_SIZE_KB,
+  isServerSide,
+  ResolvedWebSQLFlags,
   ResolvedWebSQLOpenOptions,
+  resolveWebSQLFlags,
   TemporaryStorageOption,
   WebSQLOpenFactoryOptions
 } from '../web-sql-flags.js';
-import { InternalWASQLiteDBAdapter } from './InternalWASQLiteDBAdapter.js';
-import { WASQLiteVFS, WASqliteConnection } from './WASQLiteConnection.js';
+import { SSRDBAdapter } from '../SSRDBAdapter.js';
+import { vfsRequiresDedicatedWorkers, WASQLiteVFS } from './vfs.js';
+import { MultiDatabaseServer } from '../../../worker/db/MultiDatabaseServer.js';
+import { ClientOptions, DatabaseClient, OpenWorkerConnection } from './DatabaseClient.js';
+import { generateTabCloseSignal } from '../../../shared/tab_close_signal.js';
+import { AsyncDbAdapter } from '../AsyncWebAdapter.js';
 
 export interface WASQLiteOpenFactoryOptions extends WebSQLOpenFactoryOptions {
   vfs?: WASQLiteVFS;
@@ -23,16 +27,24 @@ export interface ResolvedWASQLiteOpenFactoryOptions extends ResolvedWebSQLOpenOp
 
 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;
 }
 
 /**
  * Opens a SQLite connection using WA-SQLite.
  */
-export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
-  constructor(options: WASQLiteOpenFactoryOptions) {
-    super(options);
+export class WASQLiteOpenFactory implements SQLOpenFactory {
+  private resolvedFlags: ResolvedWebSQLFlags;
+  private logger: ILogger;
 
+  constructor(private options: WASQLiteOpenFactoryOptions) {
     assertValidWASQLiteOpenFactoryOptions(options);
+    this.resolvedFlags = resolveWebSQLFlags(options.flags);
+    this.logger = options.logger ?? createLogger(`WASQLiteOpenFactory - ${this.options.dbFilename}`);
   }
 
   get waOptions(): WASQLiteOpenFactoryOptions {
@@ -41,15 +53,36 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
   }
 
   protected openAdapter(): DBAdapter {
-    return new InternalWASQLiteDBAdapter({
-      name: this.options.dbFilename,
-      openConnection: () => this.openConnection(),
-      debugMode: this.options.debugMode,
-      logger: this.logger
-    });
+    return new AsyncDbAdapter(this.openConnection(), this.options.dbFilename);
+  }
+
+  openDB(): DBAdapter {
+    const {
+      resolvedFlags: { disableSSRWarning, enableMultiTabs, ssrMode = isServerSide() }
+    } = this;
+    if (ssrMode) {
+      if (!disableSSRWarning) {
+        this.logger.warn(
+          `
+      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.'
+      );
+    }
+
+    return this.openAdapter();
   }
 
-  async openConnection(): Promise<AsyncDatabaseConnection> {
+  async openConnection(): Promise<DatabaseClient> {
     const { enableMultiTabs, useWebWorker } = this.resolvedFlags;
     const {
       vfs = WASQLiteVFS.IDBBatchAtomicVFS,
@@ -62,6 +95,20 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
       this.logger.warn('Multiple tabs are not enabled in this browser');
     }
 
+    const resolvedOptions: ResolvedWASQLiteOpenFactoryOptions = {
+      dbFilename: this.options.dbFilename,
+      dbLocation: this.options.dbLocation,
+      debugMode: this.options.debugMode,
+      vfs,
+      temporaryStorage,
+      cacheSizeKb,
+      flags: this.resolvedFlags,
+      encryptionKey: encryptionKey
+    };
+
+    let clientOptions: ClientOptions;
+    let requiresPersistentTriggers = vfsRequiresDedicatedWorkers(vfs);
+
     if (useWebWorker) {
       const optionsDbWorker = this.options.worker;
 
@@ -78,43 +125,40 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
             )
           : openWorkerDatabasePort(this.options.dbFilename, enableMultiTabs, optionsDbWorker, this.waOptions.vfs);
 
-      const workerDBOpener = Comlink.wrap<OpenAsyncDatabaseConnection<WorkerDBOpenerOptions>>(workerPort);
-
-      return new WorkerWrappedAsyncDatabaseConnection({
-        remote: workerDBOpener,
+      const source = Comlink.wrap<OpenWorkerConnection>(workerPort);
+      const closeSignal = new AbortController();
+      const connection = await source.connect({
+        ...resolvedOptions,
+        logLevel: this.logger.getLevel(),
+        lockName: await generateTabCloseSignal(closeSignal.signal)
+      });
+      clientOptions = {
+        connection,
+        source,
         // This tab owns the worker, so we're guaranteed to outlive it.
         remoteCanCloseUnexpectedly: false,
-        baseConnection: await workerDBOpener({
-          dbFilename: this.options.dbFilename,
-          vfs,
-          temporaryStorage,
-          cacheSizeKb,
-          flags: this.resolvedFlags,
-          encryptionKey: encryptionKey,
-          logLevel: this.logger.getLevel()
-        }),
-        identifier: this.options.dbFilename,
         onClose: () => {
+          closeSignal.abort();
           if (workerPort instanceof Worker) {
             workerPort.terminate();
           } else {
             workerPort.close();
           }
         }
-      });
+      };
     } else {
-      // Don't use a web worker
-      return new WASqliteConnection({
-        dbFilename: this.options.dbFilename,
-        dbLocation: this.options.dbLocation,
-        debugMode: this.options.debugMode,
-        vfs,
-        temporaryStorage,
-        cacheSizeKb,
-        flags: this.resolvedFlags,
-        encryptionKey: encryptionKey
-      });
+      // Don't use a web worker. Instead, open the MultiDatabaseServer a worker would use locally.
+      const localServer = new MultiDatabaseServer(this.logger);
+      requiresPersistentTriggers = true;
+
+      const connection = await localServer.openConnectionLocally(resolvedOptions);
+      clientOptions = { connection, source: null, remoteCanCloseUnexpectedly: false };
     }
+
+    return new DatabaseClient(clientOptions, {
+      ...resolvedOptions,
+      requiresPersistentTriggers
+    });
   }
 }
 
@@ -125,7 +169,7 @@ function assertValidWASQLiteOpenFactoryOptions(options: WASQLiteOpenFactoryOptio
   // The OPFS VFS only works in dedicated web workers.
   if ('vfs' in options && 'flags' in options) {
     const { vfs, flags = {} } = options;
-    if (vfs !== WASQLiteVFS.IDBBatchAtomicVFS && 'useWebWorker' in flags && !flags.useWebWorker) {
+    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}).`
       );

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

@@ -0,0 +1,112 @@
+import type * as SQLite from '@journeyapps/wa-sqlite';
+
+/**
+ * List of currently tested virtual filesystems
+ */
+export enum WASQLiteVFS {
+  IDBBatchAtomicVFS = 'IDBBatchAtomicVFS',
+  OPFSCoopSyncVFS = 'OPFSCoopSyncVFS',
+  AccessHandlePoolVFS = 'AccessHandlePoolVFS'
+}
+
+export function vfsRequiresDedicatedWorkers(vfs: WASQLiteVFS) {
+  return vfs != WASQLiteVFS.IDBBatchAtomicVFS;
+}
+
+/**
+ * @internal
+ */
+export type WASQLiteModuleFactoryOptions = { dbFileName: string; encryptionKey?: string };
+
+/**
+ * @internal
+ */
+export type SQLiteModule = Parameters<typeof SQLite.Factory>[0];
+
+/**
+ * @internal
+ */
+export type WASQLiteModuleFactory = (
+  options: WASQLiteModuleFactoryOptions
+) => Promise<{ module: SQLiteModule; vfs: SQLiteVFS }>;
+
+/**
+ * @internal
+ */
+export const AsyncWASQLiteModuleFactory = async () => {
+  const { default: factory } = await import('@journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs');
+  return factory();
+};
+
+/**
+ * @internal
+ */
+export const MultiCipherAsyncWASQLiteModuleFactory = async () => {
+  const { default: factory } = await import('@journeyapps/wa-sqlite/dist/mc-wa-sqlite-async.mjs');
+  return factory();
+};
+
+/**
+ * @internal
+ */
+export const SyncWASQLiteModuleFactory = async () => {
+  const { default: factory } = await import('@journeyapps/wa-sqlite/dist/wa-sqlite.mjs');
+  return factory();
+};
+
+/**
+ * @internal
+ */
+export const MultiCipherSyncWASQLiteModuleFactory = async () => {
+  const { default: factory } = await import('@journeyapps/wa-sqlite/dist/mc-wa-sqlite.mjs');
+  return factory();
+};
+
+/**
+ * @internal
+ */
+export const DEFAULT_MODULE_FACTORIES = {
+  [WASQLiteVFS.IDBBatchAtomicVFS]: async (options: WASQLiteModuleFactoryOptions) => {
+    let module;
+    if (options.encryptionKey) {
+      module = await MultiCipherAsyncWASQLiteModuleFactory();
+    } else {
+      module = await AsyncWASQLiteModuleFactory();
+    }
+    const { IDBBatchAtomicVFS } = await import('@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js');
+    return {
+      module,
+      // @ts-expect-error The types for this static method are missing upstream
+      vfs: await IDBBatchAtomicVFS.create(options.dbFileName, module, { lockPolicy: 'exclusive' })
+    };
+  },
+  [WASQLiteVFS.AccessHandlePoolVFS]: async (options: WASQLiteModuleFactoryOptions) => {
+    let module;
+    if (options.encryptionKey) {
+      module = await MultiCipherSyncWASQLiteModuleFactory();
+    } else {
+      module = await SyncWASQLiteModuleFactory();
+    }
+    // @ts-expect-error The types for this static method are missing upstream
+    const { AccessHandlePoolVFS } = await import('@journeyapps/wa-sqlite/src/examples/AccessHandlePoolVFS.js');
+    return {
+      module,
+      vfs: await AccessHandlePoolVFS.create(options.dbFileName, module)
+    };
+  },
+  [WASQLiteVFS.OPFSCoopSyncVFS]: async (options: WASQLiteModuleFactoryOptions) => {
+    let module;
+    if (options.encryptionKey) {
+      module = await MultiCipherSyncWASQLiteModuleFactory();
+    } else {
+      module = await SyncWASQLiteModuleFactory();
+    }
+    // @ts-expect-error The types for this static method are missing upstream
+    const { OPFSCoopSyncVFS } = await import('@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js');
+    const vfs = await OPFSCoopSyncVFS.create(options.dbFileName, module);
+    return {
+      module,
+      vfs
+    };
+  }
+};