@powersync/web 0.0.0-dev-20260311103504 → 0.0.0-dev-20260503073249

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

@@ -0,0 +1,194 @@
+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,
+      this.options.isReadOnly ? 1 /* SQLITE_OPEN_READONLY */ : 6 /* SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE */
+    );
+    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,38 +1,65 @@
-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 { DatabaseClient, OpenWorkerConnection } from './DatabaseClient.js';
+import { generateTabCloseSignal } from '../../../shared/tab_close_signal.js';
+import { AsyncDbAdapter, PoolConnection } from '../AsyncWebAdapter.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;
 }
 
 /**
  * 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 +68,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<PoolConnection> {
     const { enableMultiTabs, useWebWorker } = this.resolvedFlags;
     const {
       vfs = WASQLiteVFS.IDBBatchAtomicVFS,
@@ -62,59 +110,100 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
       this.logger.warn('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);
+
     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();
+      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 closeSignal = new AbortController();
+        const connection = await source.connect({
+          ...resolvedOptions,
+          logLevel: this.logger.getLevel(),
+          lockName: await generateTabCloseSignal(closeSignal.signal)
+        });
+        const clientOptions = {
+          connection,
+          source,
+          // This tab owns the worker, so we're guaranteed to outlive it.
+          remoteCanCloseUnexpectedly: false,
+          onClose: () => {
+            closeSignal.abort();
+            if (workerPort instanceof Worker) {
+              workerPort.terminate();
+            } else {
+              workerPort.close();
+            }
           }
+        };
+
+        return new DatabaseClient(clientOptions, {
+          ...resolvedOptions,
+          requiresPersistentTriggers
+        });
+      };
+
+      client = await openDatabaseWorker(resolveOptions(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));
+          additionalReaders.push(reader);
         }
-      });
+      }
     } 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 resolvedOptions = resolveOptions(false);
+      const connection = await localServer.openConnectionLocally(resolvedOptions);
+      client = new DatabaseClient(
+        { connection, source: null, remoteCanCloseUnexpectedly: false },
+        {
+          ...resolvedOptions,
+          requiresPersistentTriggers
+        }
+      );
     }
+
+    return {
+      writer: client,
+      additionalReaders
+    };
   }
 }
 
@@ -125,7 +214,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,96 @@
+import type * as SQLite from '@journeyapps/wa-sqlite';
+
+/**
+ * List of currently tested virtual filesystems
+ */
+export enum WASQLiteVFS {
+  IDBBatchAtomicVFS = 'IDBBatchAtomicVFS',
+  OPFSCoopSyncVFS = 'OPFSCoopSyncVFS',
+  AccessHandlePoolVFS = 'AccessHandlePoolVFS',
+  OPFSWriteAheadVFS = 'OPFSWriteAheadVFS'
+}
+
+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 }>;
+
+async function asyncModuleFactory(encryptionKey: unknown) {
+  if (encryptionKey) {
+    const { default: factory } = await import('@journeyapps/wa-sqlite/dist/mc-wa-sqlite-async.mjs');
+    return factory();
+  } else {
+    const { default: factory } = await import('@journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs');
+    return factory();
+  }
+}
+
+async function syncModuleFactory(encryptionKey: unknown) {
+  if (encryptionKey) {
+    const { default: factory } = await import('@journeyapps/wa-sqlite/dist/mc-wa-sqlite.mjs');
+    return factory();
+  } else {
+    const { default: factory } = await import('@journeyapps/wa-sqlite/dist/wa-sqlite.mjs');
+    return factory();
+  }
+}
+
+/**
+ * @internal
+ */
+export const DEFAULT_MODULE_FACTORIES = {
+  [WASQLiteVFS.IDBBatchAtomicVFS]: async (options: WASQLiteModuleFactoryOptions) => {
+    const module = await asyncModuleFactory(options.encryptionKey);
+    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) => {
+    const module = await syncModuleFactory(options.encryptionKey);
+    // @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) => {
+    const module = await syncModuleFactory(options.encryptionKey);
+    // @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
+    };
+  },
+  [WASQLiteVFS.OPFSWriteAheadVFS]: async (options: WASQLiteModuleFactoryOptions) => {
+    const module = await syncModuleFactory(options.encryptionKey);
+    // @ts-expect-error The types for this static method are missing upstream
+    const { OPFSWriteAheadVFS } = await import('@journeyapps/wa-sqlite/src/examples/OPFSWriteAheadVFS.js');
+    const vfs = await OPFSWriteAheadVFS.create(options.dbFileName, module, {});
+    return {
+      module,
+      vfs
+    };
+  }
+};

package/src/db/adapters/web-sql-flags.ts

@@ -76,6 +76,12 @@ export interface WebSQLOpenFactoryOptions extends SQLOpenOptions {
    */
   worker?: string | URL | ((options: ResolvedWebSQLOpenOptions) => Worker | SharedWorker);
 
+  /**
+   * Use an existing port to an initialized worker.
+   * A worker will be initialized if none is provided
+   */
+  workerPort?: MessagePort;
+
   logger?: ILogger;
 
   /**

package/src/db/sync/SSRWebStreamingSyncImplementation.ts

@@ -3,13 +3,12 @@ import {
   BaseObserver,
   LockOptions,
   LockType,
+  Mutex,
   PowerSyncConnectionOptions,
   StreamingSyncImplementation,
-  SubscribedStream,
   SyncStatus,
   SyncStatusOptions
 } from '@powersync/common';
-import { Mutex } from 'async-mutex';
 
 export class SSRStreamingSyncImplementation extends BaseObserver implements StreamingSyncImplementation {
   syncMutex: Mutex;
@@ -29,7 +28,7 @@ export class SSRStreamingSyncImplementation extends BaseObserver implements Stre
 
   obtainLock<T>(lockOptions: LockOptions<T>): Promise<T> {
     const mutex = lockOptions.type == LockType.CRUD ? this.crudMutex : this.syncMutex;
-    return mutex.runExclusive(lockOptions.callback);
+    return mutex.runExclusive(lockOptions.callback, lockOptions.signal);
   }
 
   /**
@@ -86,4 +85,9 @@ export class SSRStreamingSyncImplementation extends BaseObserver implements Stre
    * No-op in SSR mode.
    */
   updateSubscriptions(): void {}
+
+  /**
+   * No-op in SSR mode.
+   */
+  markConnectionMayHaveChanged(): void {}
 }

package/src/db/sync/SharedWebStreamingSyncImplementation.ts

@@ -15,6 +15,7 @@ import {
   WebStreamingSyncImplementation,
   WebStreamingSyncImplementationOptions
 } from './WebStreamingSyncImplementation.js';
+import { generateTabCloseSignal } from '../../shared/tab_close_signal.js';
 
 /**
  * The shared worker will trigger methods on this side of the message port
@@ -192,26 +193,9 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
      *    - We resolve the top-level promise after the lock has been registered with the shared worker.
      * - The client sends the params to the shared worker after locks have been registered.
      */
-    await new Promise<void>((resolve) => {
-      // Request a random lock until this client is disposed. The name of the lock is sent to the shared worker, which
-      // will also attempt to acquire it. Since the lock is returned when the tab is closed, this allows the share worker
-      // to free resources associated with this tab.
-      // We take hold of this lock as soon-as-possible in order to cater for potentially closed tabs.
-      getNavigatorLocks().request(`tab-close-signal-${crypto.randomUUID()}`, async (lock) => {
-        if (this.abortOnClose.signal.aborted) {
-          return;
-        }
-        // Awaiting here ensures the worker is waiting for the lock
-        await this.syncManager.addLockBasedCloseSignal(lock!.name);
-
-        // The lock has been registered, we can continue with the initialization
-        resolve();
-
-        await new Promise<void>((r) => {
-          this.abortOnClose.signal.onabort = () => r();
-        });
-      });
-    });
+    const closeSignal = await generateTabCloseSignal(this.abortOnClose.signal);
+    // Awaiting here ensures the worker is waiting for the lock
+    await this.syncManager.addLockBasedCloseSignal(closeSignal);
 
     const { crudUploadThrottleMs, identifier, retryDelayMs } = this.options;
     const flags = { ...this.webOptions.flags, workers: undefined };

package/src/index.ts

@@ -1,10 +1,7 @@
 export * from '@powersync/common';
 export * from './attachments/IndexDBFileSystemAdapter.js';
 export * from './db/adapters/AbstractWebPowerSyncDatabaseOpenFactory.js';
-export * from './db/adapters/AbstractWebSQLOpenFactory.js';
-export * from './db/adapters/AsyncDatabaseConnection.js';
-export * from './db/adapters/wa-sqlite/WASQLiteConnection.js';
-export * from './db/adapters/wa-sqlite/WASQLiteDBAdapter.js';
+export { WASQLiteVFS } from './db/adapters/wa-sqlite/vfs.js';
 export * from './db/adapters/wa-sqlite/WASQLiteOpenFactory.js';
 export * from './db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory.js';
 export * from './db/adapters/web-sql-flags.js';