@powersync/web 0.0.0-dev-20250526133243 → 0.0.0-dev-20250529141956

package/dist/index.umd.js

@@ -38223,9 +38223,6 @@ class PowerSyncDatabase extends _powersync_common__WEBPACK_IMPORTED_MODULE_0__.A
             disconnect: options.disconnect ?? !this.resolvedFlags.enableMultiTabs
         });
     }
-    async connectExclusive(callback) {
-        await this.runExclusive(callback);
-    }
     generateBucketStorageAdapter() {
         return new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.SqliteBucketStorage(this.database, _powersync_common__WEBPACK_IMPORTED_MODULE_0__.AbstractPowerSyncDatabase.transactionMutex);
     }
@@ -39749,9 +39746,6 @@ class SharedWebStreamingSyncImplementation extends _WebStreamingSyncImplementati
      */
     async connect(options) {
         await this.waitForReady();
-        // This is needed since a new tab won't have any reference to the
-        // shared worker sync implementation since that is only created on the first call to `connect`.
-        await this.disconnect();
         return this.syncManager.connect(options);
     }
     async disconnect() {
@@ -39767,12 +39761,21 @@ class SharedWebStreamingSyncImplementation extends _WebStreamingSyncImplementati
     }
     async dispose() {
         await this.waitForReady();
-        // Signal the shared worker that this client is closing its connection to the worker
-        const closeMessagePayload = {
-            event: _worker_sync_SharedSyncImplementation__WEBPACK_IMPORTED_MODULE_2__.SharedSyncClientEvent.CLOSE_CLIENT,
-            data: {}
-        };
-        this.messagePort.postMessage(closeMessagePayload);
+        await new Promise((resolve) => {
+            // Listen for the close acknowledgment from the worker
+            this.messagePort.addEventListener('message', (event) => {
+                const payload = event.data;
+                if (payload?.event === _worker_sync_SharedSyncImplementation__WEBPACK_IMPORTED_MODULE_2__.SharedSyncClientEvent.CLOSE_ACK) {
+                    resolve();
+                }
+            });
+            // Signal the shared worker that this client is closing its connection to the worker
+            const closeMessagePayload = {
+                event: _worker_sync_SharedSyncImplementation__WEBPACK_IMPORTED_MODULE_2__.SharedSyncClientEvent.CLOSE_CLIENT,
+                data: {}
+            };
+            this.messagePort.postMessage(closeMessagePayload);
+        });
         // Release the proxy
         this.syncManager[comlink__WEBPACK_IMPORTED_MODULE_0__.releaseProxy]();
         this.messagePort.close();
@@ -40250,9 +40253,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _db_sync_WebStreamingSyncImplementation__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../../db/sync/WebStreamingSyncImplementation */ "./lib/src/db/sync/WebStreamingSyncImplementation.js");
 /* harmony import */ var _db_adapters_LockedAsyncDatabaseAdapter__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../../db/adapters/LockedAsyncDatabaseAdapter */ "./lib/src/db/adapters/LockedAsyncDatabaseAdapter.js");
 /* harmony import */ var _db_adapters_WorkerWrappedAsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../../db/adapters/WorkerWrappedAsyncDatabaseConnection */ "./lib/src/db/adapters/WorkerWrappedAsyncDatabaseConnection.js");
-/* harmony import */ var _shared_navigator__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../../shared/navigator */ "./lib/src/shared/navigator.js");
-/* harmony import */ var _BroadcastLogger__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./BroadcastLogger */ "./lib/src/worker/sync/BroadcastLogger.js");
-
+/* harmony import */ var _BroadcastLogger__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./BroadcastLogger */ "./lib/src/worker/sync/BroadcastLogger.js");
 
 
 
@@ -40262,6 +40263,7 @@ __webpack_require__.r(__webpack_exports__);
 
 
 /**
+ * @internal
  * Manual message events for shared sync clients
  */
 var SharedSyncClientEvent;
@@ -40271,14 +40273,20 @@ var SharedSyncClientEvent;
      * close it's connection to the client.
      */
     SharedSyncClientEvent["CLOSE_CLIENT"] = "close-client";
+    SharedSyncClientEvent["CLOSE_ACK"] = "close-ack";
 })(SharedSyncClientEvent || (SharedSyncClientEvent = {}));
+/**
+ * HACK: The shared implementation wraps and provides its own
+ * PowerSyncBackendConnector when generating the streaming sync implementation.
+ * We provide this unused placeholder when connecting with the ConnectionManager.
+ */
+const CONNECTOR_PLACEHOLDER = {};
 /**
  * @internal
  * Shared sync implementation which runs inside a shared webworker
  */
 class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODULE_0__.BaseObserver {
     ports;
-    syncStreamClient;
     isInitialized;
     statusListener;
     fetchCredentialsController;
@@ -40287,6 +40295,8 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
     syncParams;
     logger;
     lastConnectOptions;
+    portMutex;
+    connectionManager;
     syncStatus;
     broadCastLogger;
     constructor() {
@@ -40294,9 +40304,9 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
         this.ports = [];
         this.dbAdapter = null;
         this.syncParams = null;
-        this.syncStreamClient = null;
         this.logger = (0,_powersync_common__WEBPACK_IMPORTED_MODULE_0__.createLogger)('shared-sync');
         this.lastConnectOptions = undefined;
+        this.portMutex = new async_mutex__WEBPACK_IMPORTED_MODULE_1__.Mutex();
         this.isInitialized = new Promise((resolve) => {
             const callback = this.registerListener({
                 initialized: () => {
@@ -40306,21 +40316,44 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
             });
         });
         this.syncStatus = new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.SyncStatus({});
-        this.broadCastLogger = new _BroadcastLogger__WEBPACK_IMPORTED_MODULE_8__.BroadcastLogger(this.ports);
-    }
-    async waitForStatus(status) {
-        await this.waitForReady();
-        return this.syncStreamClient.waitForStatus(status);
-    }
-    async waitUntilStatusMatches(predicate) {
-        await this.waitForReady();
-        return this.syncStreamClient.waitUntilStatusMatches(predicate);
+        this.broadCastLogger = new _BroadcastLogger__WEBPACK_IMPORTED_MODULE_7__.BroadcastLogger(this.ports);
+        this.connectionManager = new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.ConnectionManager({
+            createSyncImplementation: async () => {
+                return this.portMutex.runExclusive(async () => {
+                    await this.waitForReady();
+                    if (!this.dbAdapter) {
+                        await this.openInternalDB();
+                    }
+                    const sync = this.generateStreamingImplementation();
+                    const onDispose = sync.registerListener({
+                        statusChanged: (status) => {
+                            this.updateAllStatuses(status.toJSON());
+                        }
+                    });
+                    return {
+                        sync,
+                        onDispose
+                    };
+                });
+            },
+            logger: this.logger
+        });
     }
     get lastSyncedAt() {
-        return this.syncStreamClient?.lastSyncedAt;
+        return this.connectionManager.syncStreamImplementation?.lastSyncedAt;
     }
     get isConnected() {
-        return this.syncStreamClient?.isConnected ?? false;
+        return this.connectionManager.syncStreamImplementation?.isConnected ?? false;
+    }
+    async waitForStatus(status) {
+        return this.withSyncImplementation(async (sync) => {
+            return sync.waitForStatus(status);
+        });
+    }
+    async waitUntilStatusMatches(predicate) {
+        return this.withSyncImplementation(async (sync) => {
+            return sync.waitUntilStatusMatches(predicate);
+        });
     }
     async waitForReady() {
         return this.isInitialized;
@@ -40333,25 +40366,34 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
      * Configures the DBAdapter connection and a streaming sync client.
      */
     async setParams(params) {
-        if (this.syncParams) {
-            // Cannot modify already existing sync implementation
-            return;
-        }
-        this.syncParams = params;
-        if (params.streamOptions?.flags?.broadcastLogs) {
-            this.logger = this.broadCastLogger;
-        }
-        self.onerror = (event) => {
-            // Share any uncaught events on the broadcast logger
-            this.logger.error('Uncaught exception in PowerSync shared sync worker', event);
-        };
-        await this.openInternalDB();
-        this.iterateListeners((l) => l.initialized?.());
+        await this.portMutex.runExclusive(async () => {
+            if (this.syncParams) {
+                // Cannot modify already existing sync implementation params
+                // But we can ask for a DB adapter, if required, at this point.
+                if (!this.dbAdapter) {
+                    await this.openInternalDB();
+                }
+                return;
+            }
+            // First time setting params
+            this.syncParams = params;
+            if (params.streamOptions?.flags?.broadcastLogs) {
+                this.logger = this.broadCastLogger;
+            }
+            self.onerror = (event) => {
+                // Share any uncaught events on the broadcast logger
+                this.logger.error('Uncaught exception in PowerSync shared sync worker', event);
+            };
+            if (!this.dbAdapter) {
+                await this.openInternalDB();
+            }
+            this.iterateListeners((l) => l.initialized?.());
+        });
     }
     async dispose() {
         await this.waitForReady();
         this.statusListener?.();
-        return this.syncStreamClient?.dispose();
+        return this.connectionManager.close();
     }
     /**
      * Connects to the PowerSync backend instance.
@@ -40360,99 +40402,110 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
      * connects.
      */
     async connect(options) {
-        await this.waitForReady();
-        // This effectively queues connect and disconnect calls. Ensuring multiple tabs' requests are synchronized
-        return (0,_shared_navigator__WEBPACK_IMPORTED_MODULE_7__.getNavigatorLocks)().request('shared-sync-connect', async () => {
-            if (!this.dbAdapter) {
-                await this.openInternalDB();
-            }
-            this.syncStreamClient = this.generateStreamingImplementation();
-            this.lastConnectOptions = options;
-            this.syncStreamClient.registerListener({
-                statusChanged: (status) => {
-                    this.updateAllStatuses(status.toJSON());
-                }
-            });
-            await this.syncStreamClient.connect(options);
-        });
+        this.lastConnectOptions = options;
+        return this.connectionManager.connect(CONNECTOR_PLACEHOLDER, options);
     }
     async disconnect() {
-        await this.waitForReady();
-        // This effectively queues connect and disconnect calls. Ensuring multiple tabs' requests are synchronized
-        return (0,_shared_navigator__WEBPACK_IMPORTED_MODULE_7__.getNavigatorLocks)().request('shared-sync-connect', async () => {
-            await this.syncStreamClient?.disconnect();
-            await this.syncStreamClient?.dispose();
-            this.syncStreamClient = null;
-        });
+        return this.connectionManager.disconnect();
     }
     /**
      * Adds a new client tab's message port to the list of connected ports
      */
-    addPort(port) {
-        const portProvider = {
-            port,
-            clientProvider: comlink__WEBPACK_IMPORTED_MODULE_2__.wrap(port)
-        };
-        this.ports.push(portProvider);
-        // Give the newly connected client the latest status
-        const status = this.syncStreamClient?.syncStatus;
-        if (status) {
-            portProvider.clientProvider.statusChanged(status.toJSON());
-        }
+    async addPort(port) {
+        await this.portMutex.runExclusive(() => {
+            const portProvider = {
+                port,
+                clientProvider: comlink__WEBPACK_IMPORTED_MODULE_2__.wrap(port)
+            };
+            this.ports.push(portProvider);
+            // Give the newly connected client the latest status
+            const status = this.connectionManager.syncStreamImplementation?.syncStatus;
+            if (status) {
+                portProvider.clientProvider.statusChanged(status.toJSON());
+            }
+        });
     }
     /**
      * Removes a message port client from this manager's managed
      * clients.
      */
     async removePort(port) {
-        const index = this.ports.findIndex((p) => p.port == port);
-        if (index < 0) {
-            this.logger.warn(`Could not remove port ${port} since it is not present in active ports.`);
-            return;
-        }
-        const trackedPort = this.ports[index];
-        // Remove from the list of active ports
-        this.ports.splice(index, 1);
-        /**
-         * The port might currently be in use. Any active functions might
-         * not resolve. Abort them here.
-         */
-        [this.fetchCredentialsController, this.uploadDataController].forEach((abortController) => {
-            if (abortController?.activePort.port == port) {
-                abortController.controller.abort(new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.AbortOperation('Closing pending requests after client port is removed'));
+        // Remove the port within a mutex context.
+        // Warns if the port is not found. This should not happen in practice.
+        // We return early if the port is not found.
+        const { trackedPort, shouldReconnect } = await this.portMutex.runExclusive(async () => {
+            const index = this.ports.findIndex((p) => p.port == port);
+            if (index < 0) {
+                this.logger.warn(`Could not remove port ${port} since it is not present in active ports.`);
+                return {};
             }
+            const trackedPort = this.ports[index];
+            // Remove from the list of active ports
+            this.ports.splice(index, 1);
+            /**
+             * The port might currently be in use. Any active functions might
+             * not resolve. Abort them here.
+             */
+            [this.fetchCredentialsController, this.uploadDataController].forEach((abortController) => {
+                if (abortController?.activePort.port == port) {
+                    abortController.controller.abort(new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.AbortOperation('Closing pending requests after client port is removed'));
+                }
+            });
+            const shouldReconnect = !!this.connectionManager.syncStreamImplementation && this.ports.length > 0;
+            return {
+                shouldReconnect,
+                trackedPort
+            };
         });
-        const shouldReconnect = !!this.syncStreamClient;
+        if (!trackedPort) {
+            // We could not find the port to remove
+            return () => { };
+        }
         if (this.dbAdapter && this.dbAdapter == trackedPort.db) {
             if (shouldReconnect) {
-                await this.disconnect();
+                await this.connectionManager.disconnect();
             }
             // Clearing the adapter will result in a new one being opened in connect
             this.dbAdapter = null;
             if (shouldReconnect) {
-                await this.connect(this.lastConnectOptions);
+                await this.connectionManager.connect(CONNECTOR_PLACEHOLDER, this.lastConnectOptions);
             }
         }
         if (trackedPort.db) {
-            trackedPort.db.close();
+            await trackedPort.db.close();
         }
         // Release proxy
-        trackedPort.clientProvider[comlink__WEBPACK_IMPORTED_MODULE_2__.releaseProxy]();
+        return () => trackedPort.clientProvider[comlink__WEBPACK_IMPORTED_MODULE_2__.releaseProxy]();
     }
     triggerCrudUpload() {
-        this.waitForReady().then(() => this.syncStreamClient?.triggerCrudUpload());
-    }
-    async obtainLock(lockOptions) {
-        await this.waitForReady();
-        return this.syncStreamClient.obtainLock(lockOptions);
+        this.withSyncImplementation(async (sync) => {
+            sync.triggerCrudUpload();
+        });
     }
     async hasCompletedSync() {
-        await this.waitForReady();
-        return this.syncStreamClient.hasCompletedSync();
+        return this.withSyncImplementation(async (sync) => {
+            return sync.hasCompletedSync();
+        });
     }
     async getWriteCheckpoint() {
+        return this.withSyncImplementation(async (sync) => {
+            return sync.getWriteCheckpoint();
+        });
+    }
+    async withSyncImplementation(callback) {
         await this.waitForReady();
-        return this.syncStreamClient.getWriteCheckpoint();
+        if (this.connectionManager.syncStreamImplementation) {
+            return callback(this.connectionManager.syncStreamImplementation);
+        }
+        const sync = await new Promise((resolve) => {
+            const dispose = this.connectionManager.registerListener({
+                syncStreamCreated: (sync) => {
+                    resolve(sync);
+                    dispose?.();
+                }
+            });
+        });
+        return callback(sync);
     }
     generateStreamingImplementation() {
         // This should only be called after initialization has completed
@@ -40555,13 +40608,13 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
      * A function only used for unit tests which updates the internal
      * sync stream client and all tab client's sync status
      */
-    _testUpdateAllStatuses(status) {
-        if (!this.syncStreamClient) {
+    async _testUpdateAllStatuses(status) {
+        if (!this.connectionManager.syncStreamImplementation) {
             // This is just for testing purposes
-            this.syncStreamClient = this.generateStreamingImplementation();
+            this.connectionManager.syncStreamImplementation = this.generateStreamingImplementation();
         }
         // Only assigning, don't call listeners for this test
-        this.syncStreamClient.syncStatus = new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.SyncStatus(status);
+        this.connectionManager.syncStreamImplementation.syncStatus = new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.SyncStatus(status);
         this.updateAllStatuses(status);
     }
 }