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

package/src/shared/tab_close_signal.ts

@@ -0,0 +1,28 @@
+import { getNavigatorLocks } from './navigator.js';
+
+/**
+ * Requests a random lock that will be released once the optional signal is aborted (or, if no signal is given, when the
+ * tab is closed).
+ *
+ * This allows sending the name of the lock to another context (e.g. a shared worker), which will also attempt to
+ * acquire it. Since the lock is returned when the tab is closed, this allows the shared worker to free resources
+ * assocatiated with this tab.
+ *
+ *  We take hold of this lock as soon-as-possible in order to cater for potentially closed tabs.
+ */
+export function generateTabCloseSignal(abort?: AbortSignal): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const options: LockOptions = { signal: abort };
+    getNavigatorLocks()
+      .request(`tab-close-signal-${crypto.randomUUID()}`, options, (lock) => {
+        resolve(lock!.name);
+
+        return new Promise<void>((resolve) => {
+          if (abort) {
+            abort.addEventListener('abort', () => resolve());
+          }
+        });
+      })
+      .catch(reject);
+  });
+}

package/src/worker/db/MultiDatabaseServer.ts

@@ -0,0 +1,107 @@
+import { ILogger } from '@powersync/common';
+import * as Comlink from 'comlink';
+import { ClientConnectionView, DatabaseServer } from '../../db/adapters/wa-sqlite/DatabaseServer.js';
+import {
+  ResolvedWASQLiteOpenFactoryOptions,
+  WorkerDBOpenerOptions
+} from '../../db/adapters/wa-sqlite/WASQLiteOpenFactory.js';
+import { getNavigatorLocks } from '../../shared/navigator.js';
+import { RawSqliteConnection } from '../../db/adapters/wa-sqlite/RawSqliteConnection.js';
+import { ConcurrentSqliteConnection } from '../../db/adapters/wa-sqlite/ConcurrentConnection.js';
+
+const OPEN_DB_LOCK = 'open-wasqlite-db';
+
+/**
+ * Shared state to manage multiple database connections hosted by a worker.
+ */
+export class MultiDatabaseServer {
+  private activeDatabases = new Map<string, DatabaseServer>();
+
+  constructor(readonly logger: ILogger) {}
+
+  async handleConnection(options: WorkerDBOpenerOptions): Promise<ClientConnectionView> {
+    this.logger.setLevel(options.logLevel);
+    return Comlink.proxy(await this.openConnectionLocally(options, options.lockName));
+  }
+
+  async connectToExisting(name: string, lockName: string): Promise<ClientConnectionView> {
+    return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
+      const server = this.activeDatabases.get(name);
+      if (server == null) {
+        throw new Error(`connectToExisting(${name}) failed because the worker doesn't own a database with that name.`);
+      }
+
+      return Comlink.proxy(await server.connect(lockName));
+    });
+  }
+
+  async openConnectionLocally(options: ResolvedWASQLiteOpenFactoryOptions, lockName?: string) {
+    // Especially on Firefox, we're sometimes seeing "NoModificationAllowedError"s when opening OPFS databases we can
+    // work around by retrying.
+    const maxAttempts = 3;
+    let server: DatabaseServer | null;
+
+    for (let count = 0; count < maxAttempts - 1; count++) {
+      try {
+        server = await this.databaseOpenAttempt(options);
+      } catch (ex) {
+        this.logger.warn(`Attempt ${count + 1} of ${maxAttempts} to open database failed, retrying in 1 second...`, ex);
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+      }
+    }
+
+    // Final attempt if we haven't been able to open the server - rethrow errors if we still can't open.
+    server ??= await this.databaseOpenAttempt(options);
+    return server.connect(lockName);
+  }
+
+  private async databaseOpenAttempt(options: ResolvedWASQLiteOpenFactoryOptions): Promise<DatabaseServer> {
+    return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
+      const { dbFilename } = options;
+
+      let server: DatabaseServer | undefined = this.activeDatabases.get(dbFilename);
+      if (server == null) {
+        // We don't need navigator locks for shared workers because all queries run in this shared worker exclusively.
+        // For read-only connections, we use a VFS that supports concurrent reads (so a single lock on the connection is
+        // fine).
+        const needsNavigatorLocks = !(isSharedWorker || options.isReadOnly);
+        const connection = new RawSqliteConnection(options);
+        const withSafeConcurrency = new ConcurrentSqliteConnection(connection, needsNavigatorLocks);
+
+        // Initializing the RawSqliteConnection will run some pragmas that might write to the database file, so we want
+        // to do that in an exclusive lock. Note that OPEN_DB_LOCK is not enough for that, as another tab might have
+        // already created a connection (and is thus outside of OPEN_DB_LOCK) while currently writing to it.
+        const returnLease = await withSafeConcurrency.acquireMutex();
+        try {
+          await connection.init();
+        } catch (e) {
+          returnLease();
+          await connection.close();
+          throw e;
+        }
+        returnLease();
+
+        const onClose = () => this.activeDatabases.delete(dbFilename);
+        server = new DatabaseServer({
+          inner: withSafeConcurrency,
+          logger: this.logger,
+          onClose
+        });
+        this.activeDatabases.set(dbFilename, server);
+      }
+
+      return server;
+    });
+  }
+
+  closeAll() {
+    const existingDatabases = [...this.activeDatabases.values()];
+    return Promise.all(
+      existingDatabases.map((db) => {
+        db.forceClose();
+      })
+    );
+  }
+}
+
+export const isSharedWorker = 'SharedWorkerGlobalScope' in globalThis;

package/src/worker/db/WASQLiteDB.worker.ts

@@ -5,78 +5,31 @@
 import '@journeyapps/wa-sqlite';
 import { createBaseLogger, createLogger } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { AsyncDatabaseConnection } from '../../db/adapters/AsyncDatabaseConnection.js';
-import { WorkerDBOpenerOptions } from '../../db/adapters/wa-sqlite/WASQLiteOpenFactory.js';
-import { getNavigatorLocks } from '../../shared/navigator.js';
-import { SharedDBWorkerConnection, SharedWASQLiteConnection } from './SharedWASQLiteConnection.js';
-import { WorkerWASQLiteConnection } from './WorkerWASQLiteConnection.js';
+import { isSharedWorker, MultiDatabaseServer } from './MultiDatabaseServer.js';
+import { OpenWorkerConnection } from '../../db/adapters/wa-sqlite/DatabaseClient.js';
 
 const baseLogger = createBaseLogger();
 baseLogger.useDefaults();
 const logger = createLogger('db-worker');
 
-const DBMap = new Map<string, SharedDBWorkerConnection>();
-const OPEN_DB_LOCK = 'open-wasqlite-db';
-let nextClientId = 1;
-
-const openDBShared = async (options: WorkerDBOpenerOptions): Promise<AsyncDatabaseConnection> => {
-  // Prevent multiple simultaneous opens from causing race conditions
-  return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
-    const clientId = nextClientId++;
-    const { dbFilename, logLevel } = options;
-
-    logger.setLevel(logLevel);
-
-    if (!DBMap.has(dbFilename)) {
-      const clientIds = new Set<number>();
-      // This format returns proxy objects for function callbacks
-      const connection = new WorkerWASQLiteConnection(options);
-      await connection.init();
-
-      connection.registerListener({
-        holdOverwritten: async () => {
-          /**
-           * The previous hold has been overwritten, without being released.
-           * we need to cleanup any resources associated with it.
-           * We can perform a rollback to release any potential transactions that were started.
-           */
-          await connection.execute('ROLLBACK').catch(() => {});
-        }
-      });
-
-      DBMap.set(dbFilename, {
-        clientIds,
-        db: connection
-      });
-    }
-
-    // Associates this clientId with the shared connection entry
-    const sharedConnection = new SharedWASQLiteConnection({
-      dbMap: DBMap,
-      dbFilename,
-      clientId,
-      logger
-    });
-
-    return Comlink.proxy(sharedConnection);
-  });
+const server = new MultiDatabaseServer(logger);
+const exposedFunctions: OpenWorkerConnection = {
+  connect: (config) => server.handleConnection(config),
+  connectToExisting: ({ identifier, lockName }) => server.connectToExisting(identifier, lockName)
 };
 
 // Check if we're in a SharedWorker context
-if (typeof SharedWorkerGlobalScope !== 'undefined') {
+if (isSharedWorker) {
   const _self: SharedWorkerGlobalScope = self as any;
   _self.onconnect = function (event: MessageEvent<string>) {
     const port = event.ports[0];
-    Comlink.expose(openDBShared, port);
+    Comlink.expose(exposedFunctions, port);
   };
 } else {
   // A dedicated worker can be shared externally
-  Comlink.expose(openDBShared);
+  Comlink.expose(exposedFunctions);
 }
 
 addEventListener('unload', () => {
-  Array.from(DBMap.values()).forEach(async (dbConnection) => {
-    const { db } = dbConnection;
-    db.close?.();
-  });
+  server.closeAll();
 });

package/src/worker/db/open-worker-database.ts

@@ -1,6 +1,6 @@
 import * as Comlink from 'comlink';
-import { OpenAsyncDatabaseConnection } from '../../db/adapters/AsyncDatabaseConnection.js';
-import { WASQLiteVFS } from '../../db/adapters/wa-sqlite/WASQLiteConnection.js';
+import { vfsRequiresDedicatedWorkers, WASQLiteVFS } from '../../db/adapters/wa-sqlite/vfs.js';
+import { OpenWorkerConnection } from '../../db/adapters/wa-sqlite/DatabaseClient.js';
 
 /**
  * Opens a shared or dedicated worker which exposes opening of database connections
@@ -11,7 +11,7 @@ export function openWorkerDatabasePort(
   worker: string | URL = '',
   vfs?: WASQLiteVFS
 ) {
-  const needsDedicated = vfs == WASQLiteVFS.AccessHandlePoolVFS || vfs == WASQLiteVFS.OPFSCoopSyncVFS;
+  const needsDedicated = vfs && vfsRequiresDedicatedWorkers(vfs);
 
   if (worker) {
     return !needsDedicated && multipleTabs
@@ -49,7 +49,7 @@ export function openWorkerDatabasePort(
  * a worker.
  */
 export function getWorkerDatabaseOpener(workerIdentifier: string, multipleTabs = true, worker: string | URL = '') {
-  return Comlink.wrap<OpenAsyncDatabaseConnection>(openWorkerDatabasePort(workerIdentifier, multipleTabs, worker));
+  return Comlink.wrap<OpenWorkerConnection>(openWorkerDatabasePort(workerIdentifier, multipleTabs, worker));
 }
 
 export function resolveWorkerDatabasePortFactory(worker: () => Worker | SharedWorker) {

package/src/worker/sync/SharedSyncImplementation.ts

@@ -2,12 +2,18 @@ import {
   AbortOperation,
   BaseObserver,
   ConnectionManager,
+  ConnectionPool,
   DBAdapter,
+  DBAdapterDefaultMixin,
+  DBAdapterListener,
+  DBLockOptions,
+  LockContext,
   PowerSyncBackendConnector,
   SqliteBucketStorage,
   SubscribedStream,
   SyncStatus,
   createLogger,
+  Mutex,
   type ILogLevel,
   type ILogger,
   type PowerSyncConnectionOptions,
@@ -15,7 +21,6 @@ import {
   type StreamingSyncImplementationListener,
   type SyncStatusOptions
 } from '@powersync/common';
-import { Mutex } from 'async-mutex';
 import * as Comlink from 'comlink';
 import { WebRemote } from '../../db/sync/WebRemote.js';
 import {
@@ -23,12 +28,11 @@ import {
   WebStreamingSyncImplementationOptions
 } from '../../db/sync/WebStreamingSyncImplementation.js';
 
-import { OpenAsyncDatabaseConnection } from '../../db/adapters/AsyncDatabaseConnection.js';
-import { LockedAsyncDatabaseAdapter } from '../../db/adapters/LockedAsyncDatabaseAdapter.js';
-import { WorkerWrappedAsyncDatabaseConnection } from '../../db/adapters/WorkerWrappedAsyncDatabaseConnection.js';
 import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags.js';
 import { AbstractSharedSyncClientProvider } from './AbstractSharedSyncClientProvider.js';
 import { BroadcastLogger } from './BroadcastLogger.js';
+import { DatabaseClient, OpenWorkerConnection } from '../../db/adapters/wa-sqlite/DatabaseClient.js';
+import { generateTabCloseSignal } from '../../shared/tab_close_signal.js';
 
 /**
  * @internal
@@ -116,7 +120,7 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
   protected connectionManager: ConnectionManager;
   syncStatus: SyncStatus;
   broadCastLogger: ILogger;
-  protected distributedDB: DBAdapter | null;
+  protected readonly database = this.generateReconnectableDatabase();
 
   constructor() {
     super();
@@ -135,9 +139,6 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
       });
     });
 
-    // Should be configured once we get params
-    this.distributedDB = null;
-
     this.syncStatus = new SyncStatus({});
     this.broadCastLogger = new BroadcastLogger(this.ports);
 
@@ -254,40 +255,8 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
       this.logger = this.broadCastLogger;
     }
 
-    const lockedAdapter = new LockedAsyncDatabaseAdapter({
-      name: params.dbParams.dbFilename,
-      openConnection: async () => {
-        // Gets a connection from the clients when a new connection is requested.
-        const db = await this.openInternalDB();
-        db.registerListener({
-          closing: () => {
-            lockedAdapter.reOpenInternalDB();
-          }
-        });
-        return db;
-      },
-      logger: this.logger,
-      reOpenOnConnectionClosed: true
-    });
-    this.distributedDB = lockedAdapter;
-    await lockedAdapter.init();
-
-    lockedAdapter.registerListener({
-      databaseReOpened: () => {
-        // We may have missed some table updates while the database was closed.
-        // We can poke the crud in case we missed any updates.
-        this.connectionManager.syncStreamImplementation?.triggerCrudUpload();
-
-        /**
-         * FIXME or IMPROVE ME
-         * The Rust client implementation stores sync state on the connection level.
-         * Reopening the database causes a state machine error which should cause the
-         * StreamingSyncImplementation to reconnect. It would be nicer if we could trigger
-         * this reconnect earlier.
-         * This reconnect is not required for IndexedDB.
-         */
-      }
-    });
+    // Ensure we have a usable database connection, the reconnectable database will connect lazily on first use.
+    await this.database.readLock(async () => {});
 
     self.onerror = (event) => {
       // Share any uncaught events on the broadcast logger
@@ -429,7 +398,7 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
     const syncParams = this.syncParams!;
     // Create a new StreamingSyncImplementation for each connect call. This is usually done is all SDKs.
     return new WebStreamingSyncImplementation({
-      adapter: new SqliteBucketStorage(this.distributedDB!, this.logger),
+      adapter: new SqliteBucketStorage(this.database, this.logger),
       remote: new WebRemote(
         {
           invalidateCredentials: async () => {
@@ -502,9 +471,11 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
   }
 
   /**
-   * Opens a worker wrapped database connection. Using the last connected client port.
+   * Requests a random client to share its database connection with us.
    */
-  protected async openInternalDB() {
+  private async openInternalDB(
+    handleClosed: (db: DatabaseClient<ResolvedWebSQLOpenOptions>) => void
+  ): Promise<DatabaseClient<ResolvedWebSQLOpenOptions>> {
     const client = await this.getRandomWrappedPort();
     if (!client) {
       // Should not really happen in practice
@@ -544,9 +515,11 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
       throw ex;
     });
 
-    const remote = Comlink.wrap<OpenAsyncDatabaseConnection>(workerPort);
+    const remote = Comlink.wrap<OpenWorkerConnection>(workerPort);
     const identifier = this.syncParams!.dbParams.dbFilename;
 
+    const clientLockName = await generateTabCloseSignal();
+
     /**
      * The open could fail if the tab is closed while we're busy opening the database.
      * This operation is typically executed inside an exclusive portMutex lock.
@@ -554,7 +527,19 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
      * We can't rely on the closeListeners to abort the operation if the tab is closed.
      */
     const db = await withAbort({
-      action: () => remote(this.syncParams!.dbParams),
+      action: async () => {
+        const clientView = await remote.connectToExisting({ identifier, lockName: clientLockName });
+        return new DatabaseClient<ResolvedWebSQLOpenOptions>(
+          {
+            connection: clientView,
+            source: remote,
+            // It's possible for this worker to outlive the client hosting the database for us. We need to be prepared for
+            // that and ensure pending requests are aborted when the tab is closed.
+            remoteCanCloseUnexpectedly: true
+          },
+          this.syncParams!.dbParams
+        );
+      },
       signal: abortController.signal,
       cleanupOnAbort: (db) => {
         db.close();
@@ -566,26 +551,97 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
 
     clearTimeout(timeout);
 
-    const wrapped = new WorkerWrappedAsyncDatabaseConnection({
-      remote,
-      baseConnection: db,
-      identifier,
-      // It's possible for this worker to outlive the client hosting the database for us. We need to be prepared for
-      // that and ensure pending requests are aborted when the tab is closed.
-      remoteCanCloseUnexpectedly: true
-    });
     client.closeListeners.push(async () => {
       this.logger.info('Aborting open connection because associated tab closed.');
+      handleClosed(db);
       /**
        * Don't await this close operation. It might never resolve if the tab is closed.
        * We mark the remote as closed first, this will reject any pending requests.
        * We then call close. The close operation is configured to fire-and-forget, the main promise will reject immediately.
        */
-      wrapped.markRemoteClosed();
-      wrapped.close().catch((ex) => this.logger.warn('error closing database connection', ex));
+      db.markRemoteClosed();
+      db.close().catch((ex) => this.logger.warn('error closing database connection', ex));
     });
+    return db;
+  }
+
+  private generateReconnectableDatabase(): DBAdapter {
+    const syncParams = this.syncParams;
+    const sharedSync = this;
+
+    class ReconnectPool extends BaseObserver<DBAdapterListener> implements ConnectionPool {
+      private connectionState:
+        | null
+        | DatabaseClient<ResolvedWebSQLOpenOptions>
+        | Promise<DatabaseClient<ResolvedWebSQLOpenOptions>> = null;
+
+      get name(): string {
+        return syncParams?.dbParams.dbFilename!;
+      }
+
+      private async connect(): Promise<DatabaseClient<ResolvedWebSQLOpenOptions>> {
+        if (this.connectionState == null) {
+          const handleClosed = this.handleClientClosed.bind(this);
+          this.connectionState = (async () => {
+            try {
+              const db = await sharedSync.openInternalDB(handleClosed);
+              db.registerListener({
+                tablesUpdated: (notification) => {
+                  this.iterateListeners((l) => l.tablesUpdated?.(notification));
+                }
+              });
+              this.connectionState = db;
+              return db;
+            } catch (e) {
+              // Allow reconnecting when the database is used again.
+              this.connectionState = null;
+              throw e;
+            }
+          })();
+        }
+
+        return await this.connectionState;
+      }
+
+      async close() {
+        if (this.connectionState != null) {
+          await (await this.connectionState).close();
+        }
+      }
+
+      handleClientClosed(client: DatabaseClient<ResolvedWebSQLOpenOptions>) {
+        if (client === this.connectionState) {
+          this.connectionState = null;
+
+          // We may have missed some table updates while the database was closed.
+          // We can poke the crud in case we missed any updates.
+          const impl = sharedSync.connectionManager.syncStreamImplementation! as WebStreamingSyncImplementation;
+          impl?.triggerCrudUpload();
+
+          // The Rust client implementation stores sync state on the connection level. Reopening the database causes a
+          // disruption of the connection state and forces us to reconnect. We want to do that as soon as possible to
+          // minimize downtime.
+          impl?.markConnectionMayHaveChanged();
+        }
+      }
+
+      async readLock<T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions): Promise<T> {
+        const db = await this.connect();
+        return db.readLock(fn, options);
+      }
+
+      async writeLock<T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions): Promise<T> {
+        const db = await this.connect();
+        return db.writeLock(fn, options);
+      }
+
+      async refreshSchema(): Promise<void> {
+        // Not used by sync client.
+      }
+    }
 
-    return wrapped;
+    const Adapter = DBAdapterDefaultMixin(ReconnectPool);
+    return new Adapter();
   }
 
   /**