@powersync/web 0.0.0-dev-20250210155038 → 0.0.0-dev-20250220093908

package/dist/index.umd.js

@@ -34086,12 +34086,8 @@ __webpack_require__.r(__webpack_exports__);
  */
 class WorkerWrappedAsyncDatabaseConnection {
     options;
-    releaseSharedConnectionLock;
-    lockAbortController;
     constructor(options) {
         this.options = options;
-        this.releaseSharedConnectionLock = null;
-        this.lockAbortController = new AbortController();
     }
     get baseConnection() {
         return this.options.baseConnection;
@@ -34104,30 +34100,6 @@ class WorkerWrappedAsyncDatabaseConnection {
      */
     async shareConnection() {
         const { identifier, remote } = this.options;
-        /**
-         * Hold a navigator lock in order to avoid features such as Chrome's frozen tabs,
-         * or Edge's sleeping tabs from pausing the thread for this connection.
-         * This promise resolves once a lock is obtained.
-         * This lock will be held as long as this connection is open.
-         * The `shareConnection` method should not be called on multiple tabs concurrently.
-         */
-        await new Promise((lockObtained) => navigator.locks
-            .request(`shared-connection-${this.options.identifier}`, {
-            signal: this.lockAbortController.signal
-        }, async () => {
-            lockObtained();
-            // Free the lock when the connection is already closed.
-            if (this.lockAbortController.signal.aborted) {
-                return;
-            }
-            // Hold the lock while the shared connection is in use.
-            await new Promise((releaseLock) => {
-                // We can use the resolver to free the lock
-                this.releaseSharedConnectionLock = releaseLock;
-            });
-        })
-            // We aren't concerned with errors here
-            .catch(() => { }));
         const newPort = await remote[comlink__WEBPACK_IMPORTED_MODULE_0__.createEndpoint]();
         return { port: newPort, identifier };
     }
@@ -34139,9 +34111,6 @@ class WorkerWrappedAsyncDatabaseConnection {
         return this.baseConnection.registerOnTableChange(comlink__WEBPACK_IMPORTED_MODULE_0__.proxy(callback));
     }
     async close() {
-        // Abort any pending lock requests.
-        this.lockAbortController.abort();
-        this.releaseSharedConnectionLock?.();
         await this.baseConnection.close();
         this.options.remote[comlink__WEBPACK_IMPORTED_MODULE_0__.releaseProxy]();
         this.options.onClose?.();
@@ -35636,6 +35605,9 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
         await this.waitForReady();
         // This effectively queues connect and disconnect calls. Ensuring multiple tabs' requests are synchronized
         return (0,_shared_navigator__WEBPACK_IMPORTED_MODULE_8__.getNavigatorLocks)().request('shared-sync-connect', async () => {
+            if (!this.dbAdapter) {
+                await this.openInternalDB();
+            }
             this.syncStreamClient = this.generateStreamingImplementation();
             this.lastConnectOptions = options;
             this.syncStreamClient.registerListener({
@@ -35659,10 +35631,7 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
      * 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)
-        };
+        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;
@@ -35681,11 +35650,7 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
             return;
         }
         const trackedPort = this.ports[index];
-        if (trackedPort.db) {
-            trackedPort.db.close();
-        }
-        // Release proxy
-        trackedPort.clientProvider[comlink__WEBPACK_IMPORTED_MODULE_2__.releaseProxy]();
+        // Remove from the list of active ports
         this.ports.splice(index, 1);
         /**
          * The port might currently be in use. Any active functions might
@@ -35696,12 +35661,22 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
                 abortController.controller.abort(new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.AbortOperation('Closing pending requests after client port is removed'));
             }
         });
-        if (this.dbAdapter == trackedPort.db && this.syncStreamClient) {
-            await this.disconnect();
-            // Ask for a new DB worker port handler
-            await this.openInternalDB();
-            await this.connect(this.lastConnectOptions);
+        const shouldReconnect = !!this.syncStreamClient;
+        if (this.dbAdapter && this.dbAdapter == trackedPort.db) {
+            if (shouldReconnect) {
+                await this.disconnect();
+            }
+            // Clearing the adapter will result in a new one being opened in connect
+            this.dbAdapter = null;
+            if (shouldReconnect) {
+                await this.connect(this.lastConnectOptions);
+            }
+        }
+        if (trackedPort.db) {
+            trackedPort.db.close();
         }
+        // Release proxy
+        trackedPort.clientProvider[comlink__WEBPACK_IMPORTED_MODULE_2__.releaseProxy]();
     }
     triggerCrudUpload() {
         this.waitForReady().then(() => this.syncStreamClient?.triggerCrudUpload());
@@ -35729,10 +35704,7 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
                     const lastPort = this.ports[this.ports.length - 1];
                     return new Promise(async (resolve, reject) => {
                         const abortController = new AbortController();
-                        this.fetchCredentialsController = {
-                            controller: abortController,
-                            activePort: lastPort
-                        };
+                        this.fetchCredentialsController = { controller: abortController, activePort: lastPort };
                         abortController.signal.onabort = reject;
                         try {
                             console.log('calling the last port client provider for credentials');
@@ -35751,10 +35723,7 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
                 const lastPort = this.ports[this.ports.length - 1];
                 return new Promise(async (resolve, reject) => {
                     const abortController = new AbortController();
-                    this.uploadDataController = {
-                        controller: abortController,
-                        activePort: lastPort
-                    };
+                    this.uploadDataController = { controller: abortController, activePort: lastPort };
                     // Resolving will make it retry
                     abortController.signal.onabort = () => resolve();
                     try {
@@ -35775,6 +35744,10 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
     }
     async openInternalDB() {
         const lastClient = this.ports[this.ports.length - 1];
+        if (!lastClient) {
+            // Should not really happen in practice
+            throw new Error(`Could not open DB connection since no client is connected.`);
+        }
         const workerPort = await lastClient.clientProvider.getDBWorkerPort();
         const remote = comlink__WEBPACK_IMPORTED_MODULE_2__.wrap(workerPort);
         const identifier = this.syncParams.dbParams.dbFilename;
@@ -35782,11 +35755,7 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
         const locked = new _db_adapters_LockedAsyncDatabaseAdapter__WEBPACK_IMPORTED_MODULE_6__.LockedAsyncDatabaseAdapter({
             name: identifier,
             openConnection: async () => {
-                return new _db_adapters_WorkerWrappedAsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_7__.WorkerWrappedAsyncDatabaseConnection({
-                    remote,
-                    baseConnection: db,
-                    identifier
-                });
+                return new _db_adapters_WorkerWrappedAsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_7__.WorkerWrappedAsyncDatabaseConnection({ remote, baseConnection: db, identifier });
             },
             logger: this.logger
         });