@powersync/web 1.28.0 → 1.28.2

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

@@ -0,0 +1,444 @@
+import * as SQLite from '@journeyapps/wa-sqlite';
+import { BaseObserver, BatchedUpdateNotification } from '@powersync/common';
+import { Mutex } from 'async-mutex';
+import { AsyncDatabaseConnection, OnTableChangeCallback, ProxiedQueryResult } from '../AsyncDatabaseConnection';
+import { ResolvedWASQLiteOpenFactoryOptions } from './WASQLiteOpenFactory';
+
+/**
+ * List of currently tested virtual filesystems
+ */
+export enum WASQLiteVFS {
+  IDBBatchAtomicVFS = 'IDBBatchAtomicVFS',
+  OPFSCoopSyncVFS = 'OPFSCoopSyncVFS',
+  AccessHandlePoolVFS = 'AccessHandlePoolVFS'
+}
+
+/**
+ * @internal
+ */
+export type WASQLiteBroadCastTableUpdateEvent = {
+  changedTables: Set<string>;
+  connectionId: number;
+};
+
+/**
+ * @internal
+ */
+export type WASQLiteConnectionListener = {
+  tablesUpdated: (event: BatchedUpdateNotification) => void;
+};
+
+/**
+ * @internal
+ */
+export type SQLiteModule = Parameters<typeof SQLite.Factory>[0];
+
+/**
+ * @internal
+ */
+export type WASQLiteModuleFactoryOptions = { dbFileName: string; encryptionKey?: string };
+
+/**
+ * @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');
+    return {
+      module,
+      vfs: await OPFSCoopSyncVFS.create(options.dbFileName, module)
+    };
+  }
+};
+
+/**
+ * @internal
+ * WA-SQLite connection which directly interfaces with WA-SQLite.
+ * This is usually instantiated inside a worker.
+ */
+export class WASqliteConnection
+  extends BaseObserver<WASQLiteConnectionListener>
+  implements AsyncDatabaseConnection<ResolvedWASQLiteOpenFactoryOptions>
+{
+  private _sqliteAPI: SQLiteAPI | null = null;
+  private _dbP: number | null = null;
+  private _moduleFactory: WASQLiteModuleFactory;
+
+  protected updatedTables: Set<string>;
+  protected updateTimer: ReturnType<typeof setTimeout> | null;
+  protected statementMutex: Mutex;
+  protected broadcastChannel: BroadcastChannel | null;
+  /**
+   * Unique id for this specific connection. This is used to prevent broadcast table change
+   * notification loops.
+   */
+  protected connectionId: number;
+
+  constructor(protected options: ResolvedWASQLiteOpenFactoryOptions) {
+    super();
+    this.updatedTables = new Set();
+    this.updateTimer = null;
+    this.broadcastChannel = null;
+    this.connectionId = new Date().valueOf() + Math.random();
+    this.statementMutex = new Mutex();
+    this._moduleFactory = DEFAULT_MODULE_FACTORIES[this.options.vfs];
+  }
+
+  protected get sqliteAPI() {
+    if (!this._sqliteAPI) {
+      throw new Error(`Initialization has not completed`);
+    }
+    return this._sqliteAPI;
+  }
+
+  protected get dbP() {
+    if (!this._dbP) {
+      throw new Error(`Initialization has not completed`);
+    }
+    return this._dbP;
+  }
+
+  protected async openDB() {
+    this._dbP = await this.sqliteAPI.open_v2(this.options.dbFilename);
+    return this._dbP;
+  }
+
+  protected async executeEncryptionPragma(): Promise<void> {
+    if (this.options.encryptionKey) {
+      await this.executeSingleStatement(`PRAGMA key = "${this.options.encryptionKey}"`);
+    }
+    return;
+  }
+
+  protected async openSQLiteAPI(): Promise<SQLiteAPI> {
+    const { module, vfs } = await this._moduleFactory({
+      dbFileName: this.options.dbFilename,
+      encryptionKey: this.options.encryptionKey
+    });
+    const sqlite3 = SQLite.Factory(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;
+  }
+
+  protected registerBroadcastListeners() {
+    this.broadcastChannel = new BroadcastChannel(`${this.options.dbFilename}-table-updates`);
+    this.broadcastChannel.addEventListener('message', (event) => {
+      const data: WASQLiteBroadCastTableUpdateEvent = event.data;
+      if (this.connectionId == data.connectionId) {
+        // Ignore messages from the same connection
+        return;
+      }
+
+      // Ensuring that we don't rebroadcast the same message
+      this.queueTableUpdate(data.changedTables, false);
+    });
+  }
+
+  protected queueTableUpdate(tableNames: Set<string>, shouldBroadcast = true) {
+    tableNames.forEach((tableName) => this.updatedTables.add(tableName));
+    if (this.updateTimer == null) {
+      this.updateTimer = setTimeout(() => this.fireUpdates(shouldBroadcast), 0);
+    }
+  }
+
+  async init() {
+    this._sqliteAPI = await this.openSQLiteAPI();
+    await this.openDB();
+    this.registerBroadcastListeners();
+    await this.executeSingleStatement(`PRAGMA temp_store = ${this.options.temporaryStorage};`);
+    await this.executeEncryptionPragma();
+    await this.executeSingleStatement(`PRAGMA cache_size = -${this.options.cacheSizeKb};`);
+
+    this.sqliteAPI.update_hook(this.dbP, (updateType: number, dbName: string | null, tableName: string | null) => {
+      if (!tableName) {
+        return;
+      }
+      const changedTables = new Set([tableName]);
+      this.queueTableUpdate(changedTables);
+    });
+  }
+
+  async getConfig(): Promise<ResolvedWASQLiteOpenFactoryOptions> {
+    return this.options;
+  }
+
+  fireUpdates(shouldBroadcast = true) {
+    this.updateTimer = null;
+    const event: BatchedUpdateNotification = { tables: [...this.updatedTables], groupedUpdates: {}, rawUpdates: [] };
+    // Share to other connections
+    if (shouldBroadcast) {
+      this.broadcastChannel!.postMessage({
+        changedTables: this.updatedTables,
+        connectionId: this.connectionId
+      } satisfies WASQLiteBroadCastTableUpdateEvent);
+    }
+    this.updatedTables.clear();
+    this.iterateListeners((cb) => cb.tablesUpdated?.(event));
+  }
+
+  /**
+   * This executes SQL statements in a batch.
+   */
+  async executeBatch(sql: string, bindings?: any[][]): Promise<ProxiedQueryResult> {
+    return this.acquireExecuteLock(async (): Promise<ProxiedQueryResult> => {
+      let affectedRows = 0;
+
+      try {
+        await this.executeSingleStatement('BEGIN TRANSACTION');
+
+        const wrappedBindings = bindings ? bindings : [];
+        for await (const stmt of this.sqliteAPI.statements(this.dbP, sql)) {
+          if (stmt === null) {
+            return {
+              rowsAffected: 0,
+              rows: { _array: [], length: 0 }
+            };
+          }
+
+          //Prepare statement once
+          for (const binding of wrappedBindings) {
+            // TODO not sure why this is needed currently, but booleans break
+            for (let i = 0; i < binding.length; i++) {
+              const b = binding[i];
+              if (typeof b == 'boolean') {
+                binding[i] = b ? 1 : 0;
+              }
+            }
+
+            if (bindings) {
+              this.sqliteAPI.bind_collection(stmt, binding);
+            }
+            const result = await this.sqliteAPI.step(stmt);
+            if (result === SQLite.SQLITE_DONE) {
+              //The value returned by sqlite3_changes() immediately after an INSERT, UPDATE or DELETE statement run on a view is always zero.
+              affectedRows += this.sqliteAPI.changes(this.dbP);
+            }
+
+            this.sqliteAPI.reset(stmt);
+          }
+        }
+
+        await this.executeSingleStatement('COMMIT');
+      } catch (err) {
+        await this.executeSingleStatement('ROLLBACK');
+        return {
+          rowsAffected: 0,
+          rows: { _array: [], length: 0 }
+        };
+      }
+      const result = {
+        rowsAffected: affectedRows,
+        rows: { _array: [], length: 0 }
+      };
+
+      return result;
+    });
+  }
+
+  /**
+   * This executes single SQL statements inside a requested lock.
+   */
+  async execute(sql: string | TemplateStringsArray, bindings?: any[]): Promise<ProxiedQueryResult> {
+    // Running multiple statements on the same connection concurrently should not be allowed
+    return this.acquireExecuteLock(async () => {
+      return this.executeSingleStatement(sql, bindings);
+    });
+  }
+
+  async executeRaw(sql: string | TemplateStringsArray, bindings?: any[]): Promise<any[][]> {
+    return this.acquireExecuteLock(async () => {
+      return this.executeSingleStatementRaw(sql, bindings);
+    });
+  }
+
+  async close() {
+    this.broadcastChannel?.close();
+    await this.sqliteAPI.close(this.dbP);
+  }
+
+  async registerOnTableChange(callback: OnTableChangeCallback) {
+    return this.registerListener({
+      tablesUpdated: (event) => callback(event)
+    });
+  }
+
+  /**
+   * This requests a lock for executing statements.
+   * Should only be used internally.
+   */
+  protected acquireExecuteLock = <T>(callback: () => Promise<T>): Promise<T> => {
+    return this.statementMutex.runExclusive(callback);
+  };
+
+  /**
+   * This executes a single statement using SQLite3.
+   */
+  protected async executeSingleStatement(
+    sql: string | TemplateStringsArray,
+    bindings?: any[]
+  ): Promise<ProxiedQueryResult> {
+    const results = await this._execute(sql, bindings);
+
+    const rows: Record<string, any>[] = [];
+    for (const resultSet of results) {
+      for (const row of resultSet.rows) {
+        const outRow: Record<string, any> = {};
+        resultSet.columns.forEach((key, index) => {
+          outRow[key] = row[index];
+        });
+        rows.push(outRow);
+      }
+    }
+
+    const result = {
+      insertId: this.sqliteAPI.last_insert_id(this.dbP),
+      rowsAffected: this.sqliteAPI.changes(this.dbP),
+      rows: {
+        _array: rows,
+        length: rows.length
+      }
+    };
+
+    return result;
+  }
+
+  /**
+   * This executes a single statement using SQLite3 and returns the results as an array of arrays.
+   */
+  protected async executeSingleStatementRaw(sql: string | TemplateStringsArray, bindings?: any[]): Promise<any[][]> {
+    const results = await this._execute(sql, bindings);
+
+    return results.flatMap((resultset) => resultset.rows.map((row) => resultset.columns.map((_, index) => row[index])));
+  }
+
+  private async _execute(
+    sql: string | TemplateStringsArray,
+    bindings?: any[]
+  ): Promise<{ columns: string[]; rows: SQLiteCompatibleType[][] }[]> {
+    const results = [];
+    for await (const stmt of this.sqliteAPI.statements(this.dbP, sql as string)) {
+      let columns;
+      const wrappedBindings = bindings ? [bindings] : [[]];
+      for (const binding of wrappedBindings) {
+        // TODO not sure why this is needed currently, but booleans break
+        binding.forEach((b, index, arr) => {
+          if (typeof b == 'boolean') {
+            arr[index] = b ? 1 : 0;
+          }
+        });
+
+        this.sqliteAPI.reset(stmt);
+        if (bindings) {
+          this.sqliteAPI.bind_collection(stmt, binding);
+        }
+
+        const rows = [];
+        while ((await this.sqliteAPI.step(stmt)) === SQLite.SQLITE_ROW) {
+          const row = this.sqliteAPI.row(stmt);
+          rows.push(row);
+        }
+
+        columns = columns ?? this.sqliteAPI.column_names(stmt);
+        if (columns.length) {
+          results.push({ columns, rows });
+        }
+      }
+
+      // When binding parameters, only a single statement is executed.
+      if (bindings) {
+        break;
+      }
+    }
+
+    return results;
+  }
+}

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

@@ -0,0 +1,86 @@
+import { type PowerSyncOpenFactoryOptions } from '@powersync/common';
+import * as Comlink from 'comlink';
+import { resolveWebPowerSyncFlags } from '../../PowerSyncDatabase';
+import { OpenAsyncDatabaseConnection } from '../AsyncDatabaseConnection';
+import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter';
+import {
+  DEFAULT_CACHE_SIZE_KB,
+  ResolvedWebSQLOpenOptions,
+  TemporaryStorageOption,
+  WebSQLFlags
+} from '../web-sql-flags';
+import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection';
+import { WASQLiteVFS } from './WASQLiteConnection';
+import { WASQLiteOpenFactory } from './WASQLiteOpenFactory';
+
+/**
+ * These flags are the same as {@link WebSQLFlags}.
+ * This export is maintained only for API consistency
+ */
+export type WASQLiteFlags = WebSQLFlags;
+
+export interface WASQLiteDBAdapterOptions extends Omit<PowerSyncOpenFactoryOptions, 'schema'> {
+  flags?: WASQLiteFlags;
+
+  /**
+   * Use an existing port to an initialized worker.
+   * A worker will be initialized if none is provided
+   */
+  workerPort?: MessagePort;
+
+  worker?: string | URL | ((options: ResolvedWebSQLOpenOptions) => Worker | SharedWorker);
+
+  vfs?: WASQLiteVFS;
+  temporaryStorage?: TemporaryStorageOption;
+  cacheSizeKb?: number;
+
+  /**
+   * Encryption key for the database.
+   * If set, the database will be encrypted using multiple-ciphers.
+   */
+  encryptionKey?: string;
+}
+
+/**
+ * Adapter for WA-SQLite SQLite connections.
+ */
+export class WASQLiteDBAdapter extends LockedAsyncDatabaseAdapter {
+  constructor(options: WASQLiteDBAdapterOptions) {
+    super({
+      name: options.dbFilename,
+      openConnection: async () => {
+        const { workerPort, temporaryStorage, cacheSizeKb } = options;
+        if (workerPort) {
+          const remote = Comlink.wrap<OpenAsyncDatabaseConnection>(workerPort);
+          return new WorkerWrappedAsyncDatabaseConnection({
+            remote,
+            remoteCanCloseUnexpectedly: false,
+            identifier: options.dbFilename,
+            baseConnection: await remote({
+              ...options,
+              temporaryStorage: temporaryStorage ?? TemporaryStorageOption.MEMORY,
+              cacheSizeKb: cacheSizeKb ?? DEFAULT_CACHE_SIZE_KB,
+              flags: resolveWebPowerSyncFlags(options.flags),
+              encryptionKey: options.encryptionKey
+            })
+          });
+        }
+        const openFactory = new WASQLiteOpenFactory({
+          dbFilename: options.dbFilename,
+          dbLocation: options.dbLocation,
+          debugMode: options.debugMode,
+          flags: options.flags,
+          temporaryStorage,
+          cacheSizeKb,
+          logger: options.logger,
+          vfs: options.vfs,
+          encryptionKey: options.encryptionKey,
+          worker: options.worker
+        });
+        return openFactory.openConnection();
+      },
+      debugMode: options.debugMode,
+      logger: options.logger
+    });
+  }
+}

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

@@ -0,0 +1,134 @@
+import { type ILogLevel, DBAdapter } from '@powersync/common';
+import * as Comlink from 'comlink';
+import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database';
+import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory';
+import { AsyncDatabaseConnection, OpenAsyncDatabaseConnection } from '../AsyncDatabaseConnection';
+import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter';
+import {
+  DEFAULT_CACHE_SIZE_KB,
+  ResolvedWebSQLOpenOptions,
+  TemporaryStorageOption,
+  WebSQLOpenFactoryOptions
+} from '../web-sql-flags';
+import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection';
+import { WASqliteConnection, WASQLiteVFS } from './WASQLiteConnection';
+
+export interface WASQLiteOpenFactoryOptions extends WebSQLOpenFactoryOptions {
+  vfs?: WASQLiteVFS;
+}
+
+export interface ResolvedWASQLiteOpenFactoryOptions extends ResolvedWebSQLOpenOptions {
+  vfs: WASQLiteVFS;
+}
+
+export interface WorkerDBOpenerOptions extends ResolvedWASQLiteOpenFactoryOptions {
+  logLevel: ILogLevel;
+}
+
+/**
+ * Opens a SQLite connection using WA-SQLite.
+ */
+export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
+  constructor(options: WASQLiteOpenFactoryOptions) {
+    super(options);
+
+    assertValidWASQLiteOpenFactoryOptions(options);
+  }
+
+  get waOptions(): WASQLiteOpenFactoryOptions {
+    // Cast to extended type
+    return this.options;
+  }
+
+  protected openAdapter(): DBAdapter {
+    return new LockedAsyncDatabaseAdapter({
+      name: this.options.dbFilename,
+      openConnection: () => this.openConnection(),
+      debugMode: this.options.debugMode,
+      logger: this.logger
+    });
+  }
+
+  async openConnection(): Promise<AsyncDatabaseConnection> {
+    const { enableMultiTabs, useWebWorker } = this.resolvedFlags;
+    const {
+      vfs = WASQLiteVFS.IDBBatchAtomicVFS,
+      temporaryStorage = TemporaryStorageOption.MEMORY,
+      cacheSizeKb = DEFAULT_CACHE_SIZE_KB,
+      encryptionKey
+    } = this.waOptions;
+
+    if (!enableMultiTabs) {
+      this.logger.warn('Multiple tabs are not enabled in this browser');
+    }
+
+    if (useWebWorker) {
+      const optionsDbWorker = this.options.worker;
+
+      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 workerDBOpener = Comlink.wrap<OpenAsyncDatabaseConnection<WorkerDBOpenerOptions>>(workerPort);
+
+      return new WorkerWrappedAsyncDatabaseConnection({
+        remote: workerDBOpener,
+        // 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: () => {
+          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
+      });
+    }
+  }
+}
+
+/**
+ * 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 !== WASQLiteVFS.IDBBatchAtomicVFS && '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/WASQLitePowerSyncDatabaseOpenFactory.ts

@@ -0,0 +1,24 @@
+import { AbstractPowerSyncDatabase, DBAdapter, PowerSyncDatabaseOptions } from '@powersync/common';
+import { PowerSyncDatabase } from '../../../db/PowerSyncDatabase';
+import { AbstractWebPowerSyncDatabaseOpenFactory } from '../AbstractWebPowerSyncDatabaseOpenFactory';
+import { WASQLiteOpenFactory } from './WASQLiteOpenFactory';
+
+/**
+ * @deprecated {@link PowerSyncDatabase} can now be constructed directly
+ * @example
+ * ```typescript
+ * const powersync = new PowerSyncDatabase({database: {
+ *  dbFileName: 'powersync.db'
+ * }});
+ * ```
+ */
+export class WASQLitePowerSyncDatabaseOpenFactory extends AbstractWebPowerSyncDatabaseOpenFactory {
+  protected openDB(): DBAdapter {
+    const factory = new WASQLiteOpenFactory(this.options);
+    return factory.openDB();
+  }
+
+  generateInstance(options: PowerSyncDatabaseOptions): AbstractPowerSyncDatabase {
+    return new PowerSyncDatabase(options);
+  }
+}