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

package/dist/worker/SharedSyncImplementation.umd.js

@@ -3228,12 +3228,26 @@ class SyncStatus {
         return {
             connected: this.connected,
             connecting: this.connecting,
-            dataFlow: this.dataFlowStatus,
+            dataFlow: {
+                ...this.dataFlowStatus,
+                uploadError: this.serializeError(this.dataFlowStatus.uploadError),
+                downloadError: this.serializeError(this.dataFlowStatus.downloadError)
+            },
             lastSyncedAt: this.lastSyncedAt,
             hasSynced: this.hasSynced,
             priorityStatusEntries: this.priorityStatusEntries
         };
     }
+    serializeError(error) {
+        if (typeof error == 'undefined') {
+            return undefined;
+        }
+        return {
+            name: error.name,
+            message: error.message,
+            stack: error.stack
+        };
+    }
     static comparePriorities(a, b) {
         return b.priority - a.priority; // Reverse because higher priorities have lower numbers
     }
@@ -17612,6 +17626,11 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   ConnectionClosedError: () => (/* binding */ ConnectionClosedError)
 /* harmony export */ });
+/**
+ * Thrown when an underlying database connection is closed.
+ * This is particularly relevant when worker connections are marked as closed while
+ * operations are still in progress.
+ */
 class ConnectionClosedError extends Error {
     constructor(message) {
         super(message);
@@ -17659,7 +17678,6 @@ class LockedAsyncDatabaseAdapter extends _powersync_common__WEBPACK_IMPORTED_MOD
     _config = null;
     pendingAbortControllers;
     requiresHolds;
-    requiresReOpen;
     databaseOpenPromise = null;
     closing;
     closed;
@@ -17672,7 +17690,6 @@ class LockedAsyncDatabaseAdapter extends _powersync_common__WEBPACK_IMPORTED_MOD
         this.closed = false;
         this.closing = false;
         this.requiresHolds = null;
-        this.requiresReOpen = false;
         // Set the name if provided. We can query for the name if not available yet
         this.debugMode = options.debugMode ?? false;
         if (this.debugMode) {
@@ -17728,6 +17745,25 @@ class LockedAsyncDatabaseAdapter extends _powersync_common__WEBPACK_IMPORTED_MOD
          */
         this.requiresHolds = this._config.vfs == _wa_sqlite_WASQLiteConnection__WEBPACK_IMPORTED_MODULE_4__.WASQLiteVFS.IDBBatchAtomicVFS;
     }
+    _reOpen() {
+        this.databaseOpenPromise = this.openInternalDB().finally(() => {
+            this.databaseOpenPromise = null;
+        });
+        return this.databaseOpenPromise;
+    }
+    /**
+     * Re-opens the underlying database.
+     * Returns a pending operation if one is already in progress.
+     */
+    async reOpenInternalDB() {
+        if (!this.options.reOpenOnConnectionClosed) {
+            throw new Error(`Cannot re-open underlying database, reOpenOnConnectionClosed is not enabled`);
+        }
+        if (this.databaseOpenPromise) {
+            return this.databaseOpenPromise;
+        }
+        return this._reOpen();
+    }
     async _init() {
         await this.openInternalDB();
         this.iterateListeners((cb) => cb.initialized?.());
@@ -17846,9 +17882,7 @@ class LockedAsyncDatabaseAdapter extends _powersync_common__WEBPACK_IMPORTED_MOD
                 if (ex instanceof _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_2__.ConnectionClosedError) {
                     if (this.options.reOpenOnConnectionClosed && !this.databaseOpenPromise && !this.closing) {
                         // Immediately re-open the database. We need to miss as little table updates as possible.
-                        this.databaseOpenPromise = this.openInternalDB().finally(() => {
-                            this.databaseOpenPromise = null;
-                        });
+                        this.reOpenInternalDB();
                     }
                 }
                 throw ex;
@@ -17985,19 +18019,22 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   WorkerWrappedAsyncDatabaseConnection: () => (/* binding */ WorkerWrappedAsyncDatabaseConnection)
 /* harmony export */ });
-/* harmony import */ var comlink__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! comlink */ "../../node_modules/comlink/dist/esm/comlink.mjs");
-/* harmony import */ var _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AsyncDatabaseConnection */ "./lib/src/db/adapters/AsyncDatabaseConnection.js");
+/* harmony import */ var _powersync_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @powersync/common */ "../common/dist/bundle.mjs");
+/* harmony import */ var comlink__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! comlink */ "../../node_modules/comlink/dist/esm/comlink.mjs");
+/* harmony import */ var _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./AsyncDatabaseConnection */ "./lib/src/db/adapters/AsyncDatabaseConnection.js");
+
 
 
 /**
  * Wraps a provided instance of {@link AsyncDatabaseConnection}, providing necessary proxy
  * functions for worker listeners.
  */
-class WorkerWrappedAsyncDatabaseConnection {
+class WorkerWrappedAsyncDatabaseConnection extends _powersync_common__WEBPACK_IMPORTED_MODULE_0__.BaseObserver {
     options;
     lockAbortController = new AbortController();
     notifyRemoteClosed;
     constructor(options) {
+        super();
         this.options = options;
         if (options.remoteCanCloseUnexpectedly) {
             this.notifyRemoteClosed = new AbortController();
@@ -18030,17 +18067,20 @@ class WorkerWrappedAsyncDatabaseConnection {
     isAutoCommit() {
         return this.withRemote(() => this.baseConnection.isAutoCommit());
     }
-    withRemote(workerPromise) {
+    withRemote(workerPromise, fireActionOnAbort = false) {
         const controller = this.notifyRemoteClosed;
         if (controller) {
             return new Promise((resolve, reject) => {
                 if (controller.signal.aborted) {
-                    reject(new _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_0__.ConnectionClosedError('Called operation on closed remote'));
-                    // Don't run the operation if we're going to reject
-                    return;
+                    reject(new _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_1__.ConnectionClosedError('Called operation on closed remote'));
+                    if (!fireActionOnAbort) {
+                        // Don't run the operation if we're going to reject
+                        // We might want to fire-and-forget the operation in some cases (like a close operation)
+                        return;
+                    }
                 }
                 function handleAbort() {
-                    reject(new _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_0__.ConnectionClosedError('Remote peer closed with request in flight'));
+                    reject(new _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_1__.ConnectionClosedError('Remote peer closed with request in flight'));
                 }
                 function completePromise(action) {
                     controller.signal.removeEventListener('abort', handleAbort);
@@ -18094,7 +18134,7 @@ class WorkerWrappedAsyncDatabaseConnection {
                 reject(ex);
             }
         }));
-        const newPort = await remote[comlink__WEBPACK_IMPORTED_MODULE_1__.createEndpoint]();
+        const newPort = await remote[comlink__WEBPACK_IMPORTED_MODULE_2__.createEndpoint]();
         return { port: newPort, identifier };
     }
     /**
@@ -18102,17 +18142,19 @@ class WorkerWrappedAsyncDatabaseConnection {
      * This can be extended by custom implementations in order to handle proxy events.
      */
     async registerOnTableChange(callback) {
-        return this.baseConnection.registerOnTableChange(comlink__WEBPACK_IMPORTED_MODULE_1__.proxy(callback));
+        return this.baseConnection.registerOnTableChange(comlink__WEBPACK_IMPORTED_MODULE_2__.proxy(callback));
     }
     async close() {
         // Abort any pending lock requests.
         this.lockAbortController.abort();
         try {
-            await this.withRemote(() => this.baseConnection.close());
+            // fire and forget the close operation
+            await this.withRemote(() => this.baseConnection.close(), true);
         }
         finally {
-            this.options.remote[comlink__WEBPACK_IMPORTED_MODULE_1__.releaseProxy]();
+            this.options.remote[comlink__WEBPACK_IMPORTED_MODULE_2__.releaseProxy]();
             this.options.onClose?.();
+            this.iterateListeners((l) => l.closing?.());
         }
     }
     execute(sql, params) {
@@ -18992,14 +19034,25 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
     /**
      * Gets the last client port which we know is safe from unexpected closes.
      */
-    get lastWrappedPort() {
-        // 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];
+    async getLastWrappedPort() {
+        // 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.
+     */
+    async getRandomWrappedPort() {
+        return await this.portMutex.runExclusive(() => {
+            return this.ports[Math.floor(Math.random() * this.ports.length)];
+        });
     }
     async waitForStatus(status) {
         return this.withSyncImplementation(async (sync) => {
@@ -19041,39 +19094,45 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
     async setParams(params) {
         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;
+        });
+        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 _db_adapters_LockedAsyncDatabaseAdapter__WEBPACK_IMPORTED_MODULE_4__.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();
             }
-            const lockedAdapter = new _db_adapters_LockedAsyncDatabaseAdapter__WEBPACK_IMPORTED_MODULE_4__.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();
-                }
-            });
-            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?.());
         });
+        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() {
         await this.waitForReady();
@@ -19103,7 +19162,6 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
                 clientProvider: comlink__WEBPACK_IMPORTED_MODULE_7__.wrap(port),
                 currentSubscriptions: [],
                 closeListeners: [],
-                isProtectedFromClose: false,
                 isClosing: false
             };
             this.ports.push(portProvider);
@@ -19189,7 +19247,7 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
             adapter: new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.SqliteBucketStorage(this.distributedDB, this.logger),
             remote: new _db_sync_WebRemote__WEBPACK_IMPORTED_MODULE_2__.WebRemote({
                 invalidateCredentials: async () => {
-                    const lastPort = this.lastWrappedPort;
+                    const lastPort = await this.getLastWrappedPort();
                     if (!lastPort) {
                         throw new Error('No client port found to invalidate credentials');
                     }
@@ -19202,7 +19260,7 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
                     }
                 },
                 fetchCredentials: async () => {
-                    const lastPort = this.lastWrappedPort;
+                    const lastPort = await this.getLastWrappedPort();
                     if (!lastPort) {
                         throw new Error('No client port found to fetch credentials');
                     }
@@ -19227,7 +19285,7 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
                 }
             }, 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');
                 }
@@ -19262,11 +19320,15 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
     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.
                  */
@@ -19275,13 +19337,13 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
                     abortController.abort();
                 };
                 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);
-                const workerPort = await withAbort(() => lastClient.clientProvider.getDBWorkerPort(), abortController.signal).catch((ex) => {
+                client.closeListeners.push(closeListener);
+                const workerPort = await withAbort(() => client.clientProvider.getDBWorkerPort(), abortController.signal).catch((ex) => {
                     removeCloseListener();
                     throw ex;
                 });
@@ -19297,6 +19359,7 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
                     // We can remove the close listener here since we no longer need it past this point.
                     removeCloseListener();
                 });
+                clearTimeout(timeout);
                 const wrapped = new _db_adapters_WorkerWrappedAsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_5__.WorkerWrappedAsyncDatabaseConnection({
                     remote,
                     baseConnection: db,
@@ -19305,15 +19368,15 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
                     // 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;
             }
@@ -19331,18 +19394,6 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
         this.syncStatus = new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.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) {
-        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 _powersync_common__WEBPACK_IMPORTED_MODULE_0__.SyncStatus(status);
-        this.updateAllStatuses(status);
-    }
 }
 /**
  * Runs the action with an abort controller.
@@ -19402,8 +19453,6 @@ class WorkerClient {
         this.sync = sync;
         this.port = port;
         comlink__WEBPACK_IMPORTED_MODULE_2__.expose(this, this.port);
-    }
-    async initialize() {
         /**
          * Adds an extra listener which can remove this port
          * from the list of monitored ports.
@@ -19414,15 +19463,6 @@ 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;
     }
     async removePort() {
         if (this.resolvedPort) {
@@ -19444,19 +19484,9 @@ class WorkerClient {
      * it can consider the connection to be closed.
      */
     async addLockBasedCloseSignal(name) {
-        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
         (0,_shared_navigator__WEBPACK_IMPORTED_MODULE_0__.getNavigatorLocks)().request(name, async () => {
             await this.removePort();
         });
@@ -19488,9 +19518,6 @@ class WorkerClient {
     disconnect() {
         return this.sync.disconnect();
     }
-    async _testUpdateAllStatuses(status) {
-        return this.sync._testUpdateAllStatuses(status);
-    }
 }
 
 
@@ -19672,7 +19699,7 @@ logger.useDefaults();
 const sharedSyncImplementation = new _SharedSyncImplementation__WEBPACK_IMPORTED_MODULE_1__.SharedSyncImplementation();
 _self.onconnect = async function (event) {
     const port = event.ports[0];
-    await new _WorkerClient__WEBPACK_IMPORTED_MODULE_2__.WorkerClient(sharedSyncImplementation, port).initialize();
+    new _WorkerClient__WEBPACK_IMPORTED_MODULE_2__.WorkerClient(sharedSyncImplementation, port);
 };
 
 })();