@powersync/web 0.0.0-dev-20250925184532 → 0.0.0-dev-20251003085035

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@powersync/web",
-    "version": "1.26.2",
+    "version": "1.27.0",
     "description": "PowerSync web SDK. Sync Postgres, MongoDB or MySQL with SQLite in your web app",
     "main": "lib/src/index.js",
     "types": "lib/src/index.d.ts",
@@ -60,8 +60,8 @@
     "author": "JOURNEYAPPS",
     "license": "Apache-2.0",
     "peerDependencies": {
-        "@journeyapps/wa-sqlite": "^1.3.1",
-        "@powersync/common": "workspace:^1.38.1"
+        "@journeyapps/wa-sqlite": "^1.3.2",
+        "@powersync/common": "workspace:^1.39.0"
     },
     "dependencies": {
         "@powersync/common": "workspace:*",
@@ -71,7 +71,7 @@
         "commander": "^12.1.0"
     },
     "devDependencies": {
-        "@journeyapps/wa-sqlite": "^1.3.1",
+        "@journeyapps/wa-sqlite": "^1.3.2",
         "@types/uuid": "^9.0.6",
         "crypto-browserify": "^3.12.0",
         "p-defer": "^4.0.1",

package/lib/src/db/adapters/WorkerWrappedAsyncDatabaseConnection.d.ts

@@ -8,6 +8,7 @@ export type SharedConnectionWorker = {
 export type WrappedWorkerConnectionOptions<Config extends ResolvedWebSQLOpenOptions = ResolvedWebSQLOpenOptions> = {
     baseConnection: AsyncDatabaseConnection;
     identifier: string;
+    remoteCanCloseUnexpectedly: boolean;
     /**
      * Need a remote in order to keep a reference to the Proxied worker
      */
@@ -21,9 +22,19 @@ export type WrappedWorkerConnectionOptions<Config extends ResolvedWebSQLOpenOpti
 export declare class WorkerWrappedAsyncDatabaseConnection<Config extends ResolvedWebSQLOpenOptions = ResolvedWebSQLOpenOptions> implements AsyncDatabaseConnection {
     protected options: WrappedWorkerConnectionOptions<Config>;
     protected lockAbortController: AbortController;
+    protected notifyRemoteClosed: AbortController | undefined;
     constructor(options: WrappedWorkerConnectionOptions<Config>);
     protected get baseConnection(): AsyncDatabaseConnection<ResolvedWebSQLOpenOptions>;
     init(): Promise<void>;
+    /**
+     * Marks the remote as closed.
+     *
+     * This can sometimes happen outside of our control, e.g. when a shared worker requests a connection from a tab. When
+     * it happens, all methods on the {@link baseConnection} would never resolve. To avoid livelocks in this scenario, we
+     * throw on all outstanding promises and forbid new calls.
+     */
+    markRemoteClosed(): void;
+    private withRemote;
     /**
      * Get a MessagePort which can be used to share the internals of this connection.
      */

package/lib/src/db/adapters/WorkerWrappedAsyncDatabaseConnection.js

@@ -5,10 +5,13 @@ import * as Comlink from 'comlink';
  */
 export class WorkerWrappedAsyncDatabaseConnection {
     options;
-    lockAbortController;
+    lockAbortController = new AbortController();
+    notifyRemoteClosed;
     constructor(options) {
         this.options = options;
-        this.lockAbortController = new AbortController();
+        if (options.remoteCanCloseUnexpectedly) {
+            this.notifyRemoteClosed = new AbortController();
+        }
     }
     get baseConnection() {
         return this.options.baseConnection;
@@ -16,6 +19,43 @@ export class WorkerWrappedAsyncDatabaseConnection {
     init() {
         return this.baseConnection.init();
     }
+    /**
+     * Marks the remote as closed.
+     *
+     * This can sometimes happen outside of our control, e.g. when a shared worker requests a connection from a tab. When
+     * it happens, all methods on the {@link baseConnection} would never resolve. To avoid livelocks in this scenario, we
+     * throw on all outstanding promises and forbid new calls.
+     */
+    markRemoteClosed() {
+        // Can non-null assert here because this function is only supposed to be called when remoteCanCloseUnexpectedly was
+        // set.
+        this.notifyRemoteClosed.abort();
+    }
+    withRemote(workerPromise) {
+        const controller = this.notifyRemoteClosed;
+        if (controller) {
+            return new Promise((resolve, reject) => {
+                if (controller.signal.aborted) {
+                    reject(new Error('Called operation on closed remote'));
+                }
+                function handleAbort() {
+                    reject(new Error('Remote peer closed with request in flight'));
+                }
+                function completePromise(action) {
+                    controller.signal.removeEventListener('abort', handleAbort);
+                    action();
+                }
+                controller.signal.addEventListener('abort', handleAbort);
+                workerPromise()
+                    .then((data) => completePromise(() => resolve(data)))
+                    .catch((e) => completePromise(() => reject(e)));
+            });
+        }
+        else {
+            // Can't close, so just return the inner worker promise unguarded.
+            return workerPromise();
+        }
+    }
     /**
      * Get a MessagePort which can be used to share the internals of this connection.
      */
@@ -66,20 +106,24 @@ export class WorkerWrappedAsyncDatabaseConnection {
     async close() {
         // Abort any pending lock requests.
         this.lockAbortController.abort();
-        await this.baseConnection.close();
-        this.options.remote[Comlink.releaseProxy]();
-        this.options.onClose?.();
+        try {
+            await this.withRemote(() => this.baseConnection.close());
+        }
+        finally {
+            this.options.remote[Comlink.releaseProxy]();
+            this.options.onClose?.();
+        }
     }
     execute(sql, params) {
-        return this.baseConnection.execute(sql, params);
+        return this.withRemote(() => this.baseConnection.execute(sql, params));
     }
     executeRaw(sql, params) {
-        return this.baseConnection.executeRaw(sql, params);
+        return this.withRemote(() => this.baseConnection.executeRaw(sql, params));
     }
     executeBatch(sql, params) {
-        return this.baseConnection.executeBatch(sql, params);
+        return this.withRemote(() => this.baseConnection.executeBatch(sql, params));
     }
     getConfig() {
-        return this.baseConnection.getConfig();
+        return this.withRemote(() => this.baseConnection.getConfig());
     }
 }

package/lib/src/db/adapters/wa-sqlite/WASQLiteDBAdapter.js

@@ -17,6 +17,7 @@ export class WASQLiteDBAdapter extends LockedAsyncDatabaseAdapter {
                     const remote = Comlink.wrap(workerPort);
                     return new WorkerWrappedAsyncDatabaseConnection({
                         remote,
+                        remoteCanCloseUnexpectedly: false,
                         identifier: options.dbFilename,
                         baseConnection: await remote({
                             ...options,

package/lib/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.js

@@ -45,6 +45,8 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
             const workerDBOpener = Comlink.wrap(workerPort);
             return new WorkerWrappedAsyncDatabaseConnection({
                 remote: workerDBOpener,
+                // This tab owns the worker, so we're guaranteed to outlive it.
+                remoteCanCloseUnexpectedly: false,
                 baseConnection: await workerDBOpener({
                     dbFilename: this.options.dbFilename,
                     vfs,

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

@@ -44,6 +44,7 @@ export type WrappedSyncPort = {
     clientProvider: Comlink.Remote<AbstractSharedSyncClientProvider>;
     db?: DBAdapter;
     currentSubscriptions: SubscribedStream[];
+    closeListeners: (() => void)[];
 };
 /**
  * @internal
@@ -100,6 +101,7 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
         port: MessagePort;
         clientProvider: Comlink.Remote<AbstractSharedSyncClientProvider>;
         currentSubscriptions: never[];
+        closeListeners: never[];
     }>;
     /**
      * Removes a message port client from this manager's managed

package/lib/src/worker/sync/SharedSyncImplementation.js

@@ -179,7 +179,8 @@ export class SharedSyncImplementation extends BaseObserver {
             const portProvider = {
                 port,
                 clientProvider: Comlink.wrap(port),
-                currentSubscriptions: []
+                currentSubscriptions: [],
+                closeListeners: []
             };
             this.ports.push(portProvider);
             // Give the newly connected client the latest status
@@ -226,19 +227,18 @@ export class SharedSyncImplementation extends BaseObserver {
             // We could not find the port to remove
             return () => { };
         }
+        for (const closeListener of trackedPort.closeListeners) {
+            closeListener();
+        }
         if (this.dbAdapter && this.dbAdapter == trackedPort.db) {
-            if (shouldReconnect) {
-                await this.connectionManager.disconnect();
-            }
+            // Unconditionally close the connection because the database it's writing to has just been closed.
+            await this.connectionManager.disconnect();
             // Clearing the adapter will result in a new one being opened in connect
             this.dbAdapter = null;
             if (shouldReconnect) {
                 await this.connectionManager.connect(CONNECTOR_PLACEHOLDER, this.lastConnectOptions ?? {});
             }
         }
-        if (trackedPort.db) {
-            await trackedPort.db.close();
-        }
         // Re-index subscriptions, the subscriptions of the removed port would no longer be considered.
         this.collectActiveSubscriptions();
         // Release proxy
@@ -353,11 +353,20 @@ export class SharedSyncImplementation extends BaseObserver {
         const locked = new LockedAsyncDatabaseAdapter({
             name: identifier,
             openConnection: async () => {
-                return new WorkerWrappedAsyncDatabaseConnection({
+                const wrapped = new WorkerWrappedAsyncDatabaseConnection({
                     remote,
                     baseConnection: db,
-                    identifier
+                    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
+                });
+                lastClient.closeListeners.push(() => {
+                    this.logger.info('Aborting open connection because associated tab closed.');
+                    wrapped.close();
+                    wrapped.markRemoteClosed();
                 });
+                return wrapped;
             },
             logger: this.logger
         });

package/lib/src/worker/sync/WorkerClient.js

@@ -31,7 +31,9 @@ export class WorkerClient {
     }
     async removePort() {
         if (this.resolvedPort) {
-            const release = await this.sync.removePort(this.resolvedPort);
+            const resolved = this.resolvedPort;
+            this.resolvedPort = null;
+            const release = await this.sync.removePort(resolved);
             this.resolvedPort = null;
             this.port.postMessage({
                 event: SharedSyncClientEvent.CLOSE_ACK,