@powersync/web 0.0.0-dev-20251129133952 → 0.0.0-dev-20251203144301

package/src/worker/sync/SharedSyncImplementation.ts

@@ -76,10 +76,6 @@ export type WrappedSyncPort = {
   db?: DBAdapter;
   currentSubscriptions: SubscribedStream[];
   closeListeners: (() => void | Promise<void>)[];
-  /**
-   * If we can use Navigator locks to detect if the client has closed.
-   */
-  isProtectedFromClose: boolean;
   isClosing: boolean;
 };
 
@@ -176,14 +172,26 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
   /**
    * Gets the last client port which we know is safe from unexpected closes.
    */
-  protected get lastWrappedPort(): WrappedSyncPort | undefined {
-    // Find the last port which is protected from close
-    for (let i = this.ports.length - 1; i >= 0; i--) {
-      if (this.ports[i].isProtectedFromClose && !this.ports[i].isClosing) {
-        return this.ports[i];
+  protected async getLastWrappedPort(): Promise<WrappedSyncPort | undefined> {
+    // Find the last port which is not closing
+    return await this.portMutex.runExclusive(() => {
+      for (let i = this.ports.length - 1; i >= 0; i--) {
+        if (!this.ports[i].isClosing) {
+          return this.ports[i];
+        }
       }
-    }
-    return;
+      return;
+    });
+  }
+
+  /**
+   * In some very rare cases a specific tab might not respond to requests.
+   * This returns a random port which is not closing.
+   */
+  protected async getRandomWrappedPort(): Promise<WrappedSyncPort | undefined> {
+    return await this.portMutex.runExclusive(() => {
+      return this.ports[Math.floor(Math.random() * this.ports.length)];
+    });
   }
 
   async waitForStatus(status: SyncStatusOptions): Promise<void> {
@@ -232,44 +240,51 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
   async setParams(params: SharedSyncInitOptions) {
     await this.portMutex.runExclusive(async () => {
       this.collectActiveSubscriptions();
-      if (this.syncParams) {
-        // Cannot modify already existing sync implementation params
-        return;
-      }
-
-      // First time setting params
-      this.syncParams = params;
-      if (params.streamOptions?.flags?.broadcastLogs) {
-        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.
-          return await this.openInternalDB();
-        },
-        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();
-        }
-      });
+    if (this.syncParams) {
+      // Cannot modify already existing sync implementation params
+      return;
+    }
 
-      self.onerror = (event) => {
-        // Share any uncaught events on the broadcast logger
-        this.logger.error('Uncaught exception in PowerSync shared sync worker', event);
-      };
+    // First time setting params
+    this.syncParams = params;
+    if (params.streamOptions?.flags?.broadcastLogs) {
+      this.logger = this.broadCastLogger;
+    }
 
-      this.iterateListeners((l) => l.initialized?.());
+    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();
+      }
+    });
+
+    self.onerror = (event) => {
+      // Share any uncaught events on the broadcast logger
+      this.logger.error('Uncaught exception in PowerSync shared sync worker', event);
+    };
+
+    this.iterateListeners((l) => l.initialized?.());
   }
 
   async dispose() {
@@ -303,7 +318,6 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
         clientProvider: Comlink.wrap<AbstractSharedSyncClientProvider>(port),
         currentSubscriptions: [],
         closeListeners: [],
-        isProtectedFromClose: false,
         isClosing: false
       } satisfies WrappedSyncPort;
       this.ports.push(portProvider);
@@ -409,7 +423,7 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
       remote: new WebRemote(
         {
           invalidateCredentials: async () => {
-            const lastPort = this.lastWrappedPort;
+            const lastPort = await this.getLastWrappedPort();
             if (!lastPort) {
               throw new Error('No client port found to invalidate credentials');
             }
@@ -421,7 +435,7 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
             }
           },
           fetchCredentials: async () => {
-            const lastPort = this.lastWrappedPort;
+            const lastPort = await this.getLastWrappedPort();
             if (!lastPort) {
               throw new Error('No client port found to fetch credentials');
             }
@@ -447,7 +461,7 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
         this.logger
       ),
       uploadCrud: async () => {
-        const lastPort = this.lastWrappedPort;
+        const lastPort = await this.getLastWrappedPort();
         if (!lastPort) {
           throw new Error('No client port found to upload crud');
         }
@@ -483,12 +497,17 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
   protected async openInternalDB() {
     while (true) {
       try {
-        const lastClient = this.lastWrappedPort;
-        if (!lastClient) {
+        const client = await this.getRandomWrappedPort();
+        if (!client) {
           // Should not really happen in practice
           throw new Error(`Could not open DB connection since no client is connected.`);
         }
 
+        // Fail-safe timeout for opening a database connection.
+        const timeout = setTimeout(() => {
+          abortController.abort();
+        }, 10_000);
+
         /**
          * Handle cases where the client might close while opening a connection.
          */
@@ -498,18 +517,21 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
         };
 
         const removeCloseListener = () => {
-          const index = lastClient.closeListeners.indexOf(closeListener);
+          const index = client.closeListeners.indexOf(closeListener);
           if (index >= 0) {
-            lastClient.closeListeners.splice(index, 1);
+            client.closeListeners.splice(index, 1);
           }
         };
 
-        lastClient.closeListeners.push(closeListener);
+        client.closeListeners.push(closeListener);
 
-        const workerPort = await withAbort(
-          () => lastClient.clientProvider.getDBWorkerPort(),
-          abortController.signal
-        ).catch((ex) => {
+        const workerPort = await withAbort({
+          action: () => client.clientProvider.getDBWorkerPort(),
+          signal: abortController.signal,
+          cleanupOnAbort: (port) => {
+            port.close();
+          }
+        }).catch((ex) => {
           removeCloseListener();
           throw ex;
         });
@@ -523,11 +545,19 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
          * We typically execute the closeListeners using the portMutex in a different context.
          * We can't rely on the closeListeners to abort the operation if the tab is closed.
          */
-        const db = await withAbort(() => remote(this.syncParams!.dbParams), abortController.signal).finally(() => {
+        const db = await withAbort({
+          action: () => remote(this.syncParams!.dbParams),
+          signal: abortController.signal,
+          cleanupOnAbort: (db) => {
+            db.close();
+          }
+        }).finally(() => {
           // We can remove the close listener here since we no longer need it past this point.
           removeCloseListener();
         });
 
+        clearTimeout(timeout);
+
         const wrapped = new WorkerWrappedAsyncDatabaseConnection({
           remote,
           baseConnection: db,
@@ -536,15 +566,15 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
           // that and ensure pending requests are aborted when the tab is closed.
           remoteCanCloseUnexpectedly: true
         });
-        lastClient.closeListeners.push(async () => {
+        client.closeListeners.push(async () => {
           this.logger.info('Aborting open connection because associated tab closed.');
           /**
            * Don't await this close operation. It might never resolve if the tab is closed.
-           * We run the close operation first, before marking the remote as closed. This gives the database some chance
-           * to close the connection.
+           * 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.close().catch((ex) => this.logger.warn('error closing database connection', ex));
           wrapped.markRemoteClosed();
+          wrapped.close().catch((ex) => this.logger.warn('error closing database connection', ex));
         });
 
         return wrapped;
@@ -563,25 +593,17 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
     this.syncStatus = new SyncStatus(status);
     this.ports.forEach((p) => p.clientProvider.statusChanged(status));
   }
-
-  /**
-   * A function only used for unit tests which updates the internal
-   * sync stream client and all tab client's sync status
-   */
-  async _testUpdateAllStatuses(status: SyncStatusOptions) {
-    if (!this.connectionManager.syncStreamImplementation) {
-      throw new Error('Cannot update status without a sync stream implementation');
-    }
-    // Only assigning, don't call listeners for this test
-    this.connectionManager.syncStreamImplementation!.syncStatus = new SyncStatus(status);
-    this.updateAllStatuses(status);
-  }
 }
 
 /**
  * Runs the action with an abort controller.
  */
-function withAbort<T>(action: () => Promise<T>, signal: AbortSignal): Promise<T> {
+function withAbort<T>(options: {
+  action: () => Promise<T>;
+  signal: AbortSignal;
+  cleanupOnAbort?: (result: T) => void;
+}): Promise<T> {
+  const { action, signal, cleanupOnAbort } = options;
   return new Promise((resolve, reject) => {
     if (signal.aborted) {
       reject(new AbortOperation('Operation aborted by abort controller'));
@@ -601,7 +623,13 @@ function withAbort<T>(action: () => Promise<T>, signal: AbortSignal): Promise<T>
     }
 
     action()
-      .then((data) => completePromise(() => resolve(data)))
+      .then((data) => {
+        // We already rejected due to the abort, allow for cleanup
+        if (signal.aborted) {
+          return completePromise(() => cleanupOnAbort?.(data));
+        }
+        completePromise(() => resolve(data));
+      })
       .catch((e) => completePromise(() => reject(e)));
   });
 }

package/src/worker/sync/SharedSyncImplementation.worker.ts

@@ -10,5 +10,5 @@ const sharedSyncImplementation = new SharedSyncImplementation();
 
 _self.onconnect = async function (event: MessageEvent<string>) {
   const port = event.ports[0];
-  await new WorkerClient(sharedSyncImplementation, port).initialize();
+  new WorkerClient(sharedSyncImplementation, port);
 };

package/src/worker/sync/WorkerClient.ts

@@ -1,4 +1,4 @@
-import { ILogLevel, PowerSyncConnectionOptions, SubscribedStream, SyncStatusOptions } from '@powersync/common';
+import { ILogLevel, PowerSyncConnectionOptions, SubscribedStream } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { getNavigatorLocks } from '../../shared/navigator';
 import {
@@ -24,9 +24,6 @@ export class WorkerClient {
     private readonly port: MessagePort
   ) {
     Comlink.expose(this, this.port);
-  }
-
-  async initialize() {
     /**
      * Adds an extra listener which can remove this port
      * from the list of monitored ports.
@@ -37,16 +34,6 @@ export class WorkerClient {
         await this.removePort();
       }
     });
-
-    /**
-     * Keep a reference to the resolved port promise.
-     * The init timing is difficult to predict due to the async message passing.
-     * We only want to use a port if we are know it's been protected from being closed.
-     * The lock based close signal will be added asynchronously. We need to use the
-     * added port once the lock is configured.
-     */
-    this.resolvedPortPromise = this.sync.addPort(this.port);
-    this.resolvedPort = await this.resolvedPortPromise;
   }
 
   private async removePort() {
@@ -70,18 +57,9 @@ export class WorkerClient {
    * it can consider the connection to be closed.
    */
   async addLockBasedCloseSignal(name: string) {
-    if (!this.resolvedPortPromise) {
-      // The init logic above is actually synchronous, so this should not happen.
-      this.sync.broadCastLogger.warn('addLockBasedCloseSignal called before port promise registered');
-    } else {
-      const wrappedPort = await this.resolvedPortPromise;
-      /**
-       * The client registered a navigator lock. We now can guarantee detecting if the client has closed.
-       * E.g. before this point: It's possible some ports might have been created and closed before the
-       * lock based close signal is added. We should not trust those ports.
-       */
-      wrappedPort.isProtectedFromClose = true;
-    }
+    // Only add the port once the lock has been obtained on the client.
+    this.resolvedPort = await this.sync.addPort(this.port);
+    // Don't await this lock request
     getNavigatorLocks().request(name, async () => {
       await this.removePort();
     });
@@ -121,8 +99,4 @@ export class WorkerClient {
   disconnect() {
     return this.sync.disconnect();
   }
-
-  async _testUpdateAllStatuses(status: SyncStatusOptions) {
-    return this.sync._testUpdateAllStatuses(status);
-  }
 }