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

package/dist/worker/SharedSyncImplementation.umd.js

@@ -1147,8 +1147,11 @@ function Factory(Module) {
       // Wait for all pending retry operations to complete. This is
       // normally empty on the first loop iteration.
       if (Module.retryOps.length) {
-        await Promise.all(Module.retryOps);
-        Module.retryOps = [];
+        try {
+          await Promise.all(Module.retryOps);
+        } finally {
+          Module.retryOps = [];
+        }
       }
       
       rc = await f();
@@ -14673,7 +14676,7 @@ The next upload iteration will be delayed.`);
                                 uploadError: ex
                             }
                         });
-                        await this.delayRetry(controller.signal, this.options.crudUploadThrottleMs);
+                        await this.delayRetry(controller.signal);
                         if (!this.isConnected) {
                             // Exit the upload loop if the sync stream is no longer connected
                             break;
@@ -15384,14 +15387,14 @@ The next upload iteration will be delayed.`);
         // trigger this for all updates
         this.iterateListeners((cb) => cb.statusUpdated?.(options));
     }
-    async delayRetry(signal, delayMs) {
+    async delayRetry(signal) {
         return new Promise((resolve) => {
             if (signal?.aborted) {
                 // If the signal is already aborted, resolve immediately
                 resolve();
                 return;
             }
-            const delay = delayMs ?? this.options.retryDelayMs;
+            const { retryDelayMs } = this.options;
             let timeoutId;
             const endDelay = () => {
                 resolve();
@@ -15402,7 +15405,7 @@ The next upload iteration will be delayed.`);
                 signal?.removeEventListener('abort', endDelay);
             };
             signal?.addEventListener('abort', endDelay, { once: true });
-            timeoutId = setTimeout(endDelay, delay);
+            timeoutId = setTimeout(endDelay, retryDelayMs);
         });
     }
     updateSubscriptions(subscriptions) {
@@ -15932,11 +15935,11 @@ class AbstractPowerSyncDatabase extends BaseObserver {
                 .map((n) => parseInt(n));
         }
         catch (e) {
-            throw new Error(`Unsupported powersync extension version. Need >=0.4.5 <1.0.0, got: ${this.sdkVersion}. Details: ${e.message}`);
+            throw new Error(`Unsupported powersync extension version. Need >=0.4.10 <1.0.0, got: ${this.sdkVersion}. Details: ${e.message}`);
         }
-        // Validate >=0.4.5 <1.0.0
-        if (versionInts[0] != 0 || versionInts[1] < 4 || (versionInts[1] == 4 && versionInts[2] < 5)) {
-            throw new Error(`Unsupported powersync extension version. Need >=0.4.5 <1.0.0, got: ${this.sdkVersion}`);
+        // Validate >=0.4.10 <1.0.0
+        if (versionInts[0] != 0 || versionInts[1] < 4 || (versionInts[1] == 4 && versionInts[2] < 10)) {
+            throw new Error(`Unsupported powersync extension version. Need >=0.4.10 <1.0.0, got: ${this.sdkVersion}`);
         }
     }
     async resolveOfflineSyncStatus() {
@@ -17652,7 +17655,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   LockedAsyncDatabaseAdapter: () => (/* binding */ LockedAsyncDatabaseAdapter)
 /* harmony export */ });
 /* harmony import */ var _powersync_common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @powersync/common */ "../common/dist/bundle.mjs");
-/* harmony import */ var _shared_navigator__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../..//shared/navigator */ "./lib/src/shared/navigator.js");
+/* harmony import */ var _shared_navigator__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../shared/navigator */ "./lib/src/shared/navigator.js");
 /* harmony import */ var _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./AsyncDatabaseConnection */ "./lib/src/db/adapters/AsyncDatabaseConnection.js");
 /* harmony import */ var _WorkerWrappedAsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./WorkerWrappedAsyncDatabaseConnection */ "./lib/src/db/adapters/WorkerWrappedAsyncDatabaseConnection.js");
 /* harmony import */ var _wa_sqlite_WASQLiteConnection__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./wa-sqlite/WASQLiteConnection */ "./lib/src/db/adapters/wa-sqlite/WASQLiteConnection.js");
@@ -17729,21 +17732,28 @@ class LockedAsyncDatabaseAdapter extends _powersync_common__WEBPACK_IMPORTED_MOD
         return this.initPromise;
     }
     async openInternalDB() {
-        // Dispose any previous table change listener.
-        this._disposeTableChangeListener?.();
-        this._disposeTableChangeListener = null;
-        const isReOpen = !!this._db;
-        this._db = await this.options.openConnection();
-        await this._db.init();
-        this._config = await this._db.getConfig();
-        await this.registerOnChangeListener(this._db);
-        if (isReOpen) {
-            this.iterateListeners((cb) => cb.databaseReOpened?.());
-        }
         /**
-         * This is only required for the long-lived shared IndexedDB connections.
+         * Execute opening of the db in a lock in order not to interfere with other operations.
          */
-        this.requiresHolds = this._config.vfs == _wa_sqlite_WASQLiteConnection__WEBPACK_IMPORTED_MODULE_4__.WASQLiteVFS.IDBBatchAtomicVFS;
+        return this._acquireLock(async () => {
+            // Dispose any previous table change listener.
+            this._disposeTableChangeListener?.();
+            this._disposeTableChangeListener = null;
+            this._db?.close().catch((ex) => this.logger.warn(`Error closing database before opening new instance`, ex));
+            const isReOpen = !!this._db;
+            this._db = null;
+            this._db = await this.options.openConnection();
+            await this._db.init();
+            this._config = await this._db.getConfig();
+            await this.registerOnChangeListener(this._db);
+            if (isReOpen) {
+                this.iterateListeners((cb) => cb.databaseReOpened?.());
+            }
+            /**
+             * This is only required for the long-lived shared IndexedDB connections.
+             */
+            this.requiresHolds = this._config.vfs == _wa_sqlite_WASQLiteConnection__WEBPACK_IMPORTED_MODULE_4__.WASQLiteVFS.IDBBatchAtomicVFS;
+        });
     }
     _reOpen() {
         this.databaseOpenPromise = this.openInternalDB().finally(() => {
@@ -17765,7 +17775,24 @@ class LockedAsyncDatabaseAdapter extends _powersync_common__WEBPACK_IMPORTED_MOD
         return this._reOpen();
     }
     async _init() {
-        await this.openInternalDB();
+        /**
+         * For OPFS, we can see this open call sometimes fail due to NoModificationAllowedError.
+         * We should be able to recover from this by re-opening the database.
+         */
+        const maxAttempts = 3;
+        for (let count = 0; count < maxAttempts; count++) {
+            try {
+                await this.openInternalDB();
+                break;
+            }
+            catch (ex) {
+                if (count == maxAttempts - 1) {
+                    throw 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));
+            }
+        }
         this.iterateListeners((cb) => cb.initialized?.());
     }
     getConfiguration() {
@@ -17842,8 +17869,7 @@ class LockedAsyncDatabaseAdapter extends _powersync_common__WEBPACK_IMPORTED_MOD
             timeoutMs: options?.timeoutMs ?? this.options.defaultLockTimeoutMs
         });
     }
-    async acquireLock(callback, options) {
-        await this.waitForInitialized();
+    async _acquireLock(callback, options) {
         if (this.closing) {
             throw new Error(`Cannot acquire lock, the database is closing`);
         }
@@ -17861,19 +17887,26 @@ class LockedAsyncDatabaseAdapter extends _powersync_common__WEBPACK_IMPORTED_MOD
             if (timeoutId) {
                 clearTimeout(timeoutId);
             }
+            return await callback();
+        });
+    }
+    async acquireLock(callback, options) {
+        await this.waitForInitialized();
+        // The database is being opened in the background. Wait for it here.
+        if (this.databaseOpenPromise) {
+            await this.databaseOpenPromise;
+        }
+        return this._acquireLock(async () => {
             let holdId = null;
             try {
-                // The database is being opened in the background. Wait for it here.
-                if (this.databaseOpenPromise) {
-                    try {
-                        await this.databaseOpenPromise;
-                    }
-                    catch (ex) {
-                        // This will cause a retry of opening the database.
-                        const wrappedError = new _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_2__.ConnectionClosedError('Could not open database');
-                        wrappedError.cause = ex;
-                        throw wrappedError;
-                    }
+                /**
+                 * We can't await this since it uses the same lock as we're in now.
+                 * If there is a pending open, this call will throw.
+                 * If there is no pending open, but there is also no database - the open
+                 * might have failed. We need to re-open the database.
+                 */
+                if (this.databaseOpenPromise || !this._db) {
+                    throw new _AsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_2__.ConnectionClosedError('Connection is busy re-opening');
                 }
                 holdId = this.requiresHolds ? await this.baseDB.markHold() : null;
                 return await callback();
@@ -17882,6 +17915,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.
+                        // Note, don't await this since it uses the same lock as we're in now.
                         this.reOpenInternalDB();
                     }
                 }
@@ -17892,7 +17926,7 @@ class LockedAsyncDatabaseAdapter extends _powersync_common__WEBPACK_IMPORTED_MOD
                     await this.baseDB.releaseHold(holdId);
                 }
             }
-        });
+        }, options);
     }
     async readTransaction(fn, options) {
         return this.readLock(this.wrapTransaction(fn));
@@ -18277,9 +18311,10 @@ const DEFAULT_MODULE_FACTORIES = {
         }
         // @ts-expect-error The types for this static method are missing upstream
         const { OPFSCoopSyncVFS } = await __webpack_require__.e(/*! import() */ "node_modules_journeyapps_wa-sqlite_src_examples_OPFSCoopSyncVFS_js").then(__webpack_require__.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js */ "../../node_modules/@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js"));
+        const vfs = await OPFSCoopSyncVFS.create(options.dbFileName, module);
         return {
             module,
-            vfs: await OPFSCoopSyncVFS.create(options.dbFileName, module)
+            vfs
         };
     }
 };
@@ -18505,7 +18540,15 @@ class WASqliteConnection extends _powersync_common__WEBPACK_IMPORTED_MODULE_1__.
     }
     async close() {
         this.broadcastChannel?.close();
-        await this.sqliteAPI.close(this.dbP);
+        await this.acquireExecuteLock(async () => {
+            /**
+             * Running the close operation inside the same execute mutex prevents errors like:
+             * ```
+             * unable to close due to unfinalized statements or unfinished backups
+             * ```
+             */
+            await this.sqliteAPI.close(this.dbP);
+        });
     }
     async registerOnTableChange(callback) {
         return this.registerListener({
@@ -19051,7 +19094,8 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
      */
     async getRandomWrappedPort() {
         return await this.portMutex.runExclusive(() => {
-            return this.ports[Math.floor(Math.random() * this.ports.length)];
+            const nonClosingPorts = this.ports.filter((p) => !p.isClosing);
+            return nonClosingPorts[Math.floor(Math.random() * nonClosingPorts.length)];
         });
     }
     async waitForStatus(status) {
@@ -19318,73 +19362,77 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
      * Opens a worker wrapped database connection. Using the last connected client port.
      */
     async openInternalDB() {
-        while (true) {
-            try {
-                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.
-                 */
-                const abortController = new AbortController();
-                const closeListener = () => {
-                    abortController.abort();
-                };
-                const removeCloseListener = () => {
-                    const index = client.closeListeners.indexOf(closeListener);
-                    if (index >= 0) {
-                        client.closeListeners.splice(index, 1);
-                    }
-                };
-                client.closeListeners.push(closeListener);
-                const workerPort = await withAbort(() => client.clientProvider.getDBWorkerPort(), abortController.signal).catch((ex) => {
-                    removeCloseListener();
-                    throw ex;
-                });
-                const remote = comlink__WEBPACK_IMPORTED_MODULE_7__.wrap(workerPort);
-                const identifier = this.syncParams.dbParams.dbFilename;
-                /**
-                 * 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.
-                 * 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(() => {
-                    // 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,
-                    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.');
-                    /**
-                     * 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));
-                });
-                return wrapped;
+        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.
+         */
+        const abortController = new AbortController();
+        const closeListener = () => {
+            abortController.abort();
+        };
+        const removeCloseListener = () => {
+            const index = client.closeListeners.indexOf(closeListener);
+            if (index >= 0) {
+                client.closeListeners.splice(index, 1);
             }
-            catch (ex) {
-                this.logger.warn('Error opening internal DB', ex);
-                await new Promise((resolve) => setTimeout(resolve, 1000));
+        };
+        client.closeListeners.push(closeListener);
+        const workerPort = await withAbort({
+            action: () => client.clientProvider.getDBWorkerPort(),
+            signal: abortController.signal,
+            cleanupOnAbort: (port) => {
+                port.close();
             }
-        }
+        }).catch((ex) => {
+            removeCloseListener();
+            throw ex;
+        });
+        const remote = comlink__WEBPACK_IMPORTED_MODULE_7__.wrap(workerPort);
+        const identifier = this.syncParams.dbParams.dbFilename;
+        /**
+         * 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.
+         * 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({
+            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 _db_adapters_WorkerWrappedAsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_5__.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.');
+            /**
+             * 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));
+        });
+        return wrapped;
     }
     /**
      * A method to update the all shared statuses for each
@@ -19398,7 +19446,8 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
 /**
  * Runs the action with an abort controller.
  */
-function withAbort(action, signal) {
+function withAbort(options) {
+    const { action, signal, cleanupOnAbort } = options;
     return new Promise((resolve, reject) => {
         if (signal.aborted) {
             reject(new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.AbortOperation('Operation aborted by abort controller'));
@@ -19414,7 +19463,13 @@ function withAbort(action, signal) {
             action();
         }
         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)));
     });
 }