@powersync/web 0.0.0-dev-20250915110424 → 0.0.0-dev-20250922104723

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@powersync/web",
-    "version": "1.26.1",
+    "version": "1.26.2",
     "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",
@@ -61,7 +61,7 @@
     "license": "Apache-2.0",
     "peerDependencies": {
         "@journeyapps/wa-sqlite": "^1.3.1",
-        "@powersync/common": "workspace:^1.38.0"
+        "@powersync/common": "workspace:^1.38.1"
     },
     "dependencies": {
         "@powersync/common": "workspace:*",

package/lib/src/db/PowerSyncDatabase.js

@@ -94,8 +94,7 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
         const remote = new WebRemote(connector, this.logger);
         const syncOptions = {
             ...this.options,
-            retryDelayMs: options.retryDelayMs,
-            crudUploadThrottleMs: options.crudUploadThrottleMs,
+            ...options,
             flags: this.resolvedFlags,
             adapter: this.bucketStorageAdapter,
             remote,

package/lib/src/db/sync/SSRWebStreamingSyncImplementation.d.ts

@@ -41,4 +41,8 @@ export declare class SSRStreamingSyncImplementation extends BaseObserver impleme
      * This is a no-op in SSR mode.
      */
     triggerCrudUpload(): void;
+    /**
+     * No-op in SSR mode.
+     */
+    updateSubscriptions(): void;
 }

package/lib/src/db/sync/SSRWebStreamingSyncImplementation.js

@@ -58,4 +58,8 @@ export class SSRStreamingSyncImplementation extends BaseObserver {
      * This is a no-op in SSR mode.
      */
     triggerCrudUpload() { }
+    /**
+     * No-op in SSR mode.
+     */
+    updateSubscriptions() { }
 }

package/lib/src/db/sync/SharedWebStreamingSyncImplementation.d.ts

@@ -1,9 +1,9 @@
-import { PowerSyncConnectionOptions, PowerSyncCredentials, SyncStatusOptions } from '@powersync/common';
+import { PowerSyncConnectionOptions, PowerSyncCredentials, SubscribedStream, SyncStatusOptions } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider';
-import { SharedSyncImplementation } from '../../worker/sync/SharedSyncImplementation';
 import { WebDBAdapter } from '../adapters/WebDBAdapter';
 import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions } from './WebStreamingSyncImplementation';
+import { WorkerClient } from '../../worker/sync/WorkerClient';
 /**
  * The shared worker will trigger methods on this side of the message port
  * via this client provider.
@@ -30,12 +30,16 @@ declare class SharedSyncClientProvider extends AbstractSharedSyncClientProvider
 export interface SharedWebStreamingSyncImplementationOptions extends WebStreamingSyncImplementationOptions {
     db: WebDBAdapter;
 }
+/**
+ * The local part of the sync implementation on the web, which talks to a sync implementation hosted in a shared worker.
+ */
 export declare class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplementation {
-    protected syncManager: Comlink.Remote<SharedSyncImplementation>;
+    protected syncManager: Comlink.Remote<WorkerClient>;
     protected clientProvider: SharedSyncClientProvider;
     protected messagePort: MessagePort;
     protected isInitialized: Promise<void>;
     protected dbAdapter: WebDBAdapter;
+    private abortOnClose;
     constructor(options: SharedWebStreamingSyncImplementationOptions);
     /**
      * Starts the sync process, this effectively acts as a call to
@@ -47,6 +51,7 @@ export declare class SharedWebStreamingSyncImplementation extends WebStreamingSy
     hasCompletedSync(): Promise<boolean>;
     dispose(): Promise<void>;
     waitForReady(): Promise<void>;
+    updateSubscriptions(subscriptions: SubscribedStream[]): void;
     /**
      * Used in tests to force a connection states
      */

package/lib/src/db/sync/SharedWebStreamingSyncImplementation.js

@@ -3,6 +3,7 @@ import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractShar
 import { SharedSyncClientEvent } from '../../worker/sync/SharedSyncImplementation';
 import { DEFAULT_CACHE_SIZE_KB, resolveWebSQLFlags, TemporaryStorageOption } from '../adapters/web-sql-flags';
 import { WebStreamingSyncImplementation } from './WebStreamingSyncImplementation';
+import { getNavigatorLocks } from '../../shared/navigator';
 /**
  * The shared worker will trigger methods on this side of the message port
  * via this client provider.
@@ -75,12 +76,16 @@ class SharedSyncClientProvider extends AbstractSharedSyncClientProvider {
         this.logger?.timeEnd(label);
     }
 }
+/**
+ * The local part of the sync implementation on the web, which talks to a sync implementation hosted in a shared worker.
+ */
 export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplementation {
     syncManager;
     clientProvider;
     messagePort;
     isInitialized;
     dbAdapter;
+    abortOnClose = new AbortController();
     constructor(options) {
         super(options);
         this.dbAdapter = options.db;
@@ -133,7 +138,7 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
                 retryDelayMs,
                 flags: flags
             }
-        });
+        }, options.subscriptions);
         /**
          * Pass along any sync status updates to this listener
          */
@@ -146,6 +151,17 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
          * This performs bi-directional method calling.
          */
         Comlink.expose(this.clientProvider, this.messagePort);
+        // Request a random lock until this client is disposed. The name of the lock is sent to the shared worker, which
+        // will also attempt to acquire it. Since the lock is returned when the tab is closed, this allows the share worker
+        // to free resources associated with this tab.
+        getNavigatorLocks().request(`tab-close-signal-${crypto.randomUUID()}`, async (lock) => {
+            if (!this.abortOnClose.signal.aborted) {
+                this.syncManager.addLockBasedCloseSignal(lock.name);
+                await new Promise((r) => {
+                    this.abortOnClose.signal.onabort = () => r();
+                });
+            }
+        });
     }
     /**
      * Starts the sync process, this effectively acts as a call to
@@ -184,6 +200,7 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
             };
             this.messagePort.postMessage(closeMessagePayload);
         });
+        this.abortOnClose.abort();
         // Release the proxy
         this.syncManager[Comlink.releaseProxy]();
         this.messagePort.close();
@@ -191,11 +208,14 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
     async waitForReady() {
         return this.isInitialized;
     }
+    updateSubscriptions(subscriptions) {
+        this.syncManager.updateSubscriptions(subscriptions);
+    }
     /**
      * Used in tests to force a connection states
      */
     async _testUpdateStatus(status) {
         await this.isInitialized;
-        return this.syncManager['_testUpdateAllStatuses'](status.toJSON());
+        return this.syncManager._testUpdateAllStatuses(status.toJSON());
     }
 }

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

@@ -1,4 +1,4 @@
-import { type ILogger, type ILogLevel, type PowerSyncConnectionOptions, type StreamingSyncImplementation, type StreamingSyncImplementationListener, type SyncStatusOptions, BaseObserver, ConnectionManager, DBAdapter, SyncStatus } from '@powersync/common';
+import { type ILogger, type ILogLevel, type PowerSyncConnectionOptions, type StreamingSyncImplementation, type StreamingSyncImplementationListener, type SyncStatusOptions, BaseObserver, ConnectionManager, DBAdapter, SubscribedStream, SyncStatus } from '@powersync/common';
 import { Mutex } from 'async-mutex';
 import * as Comlink from 'comlink';
 import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions } from '../../db/sync/WebStreamingSyncImplementation';
@@ -27,7 +27,7 @@ export type ManualSharedSyncPayload = {
  * @internal
  */
 export type SharedSyncInitOptions = {
-    streamOptions: Omit<WebStreamingSyncImplementationOptions, 'adapter' | 'uploadCrud' | 'remote'>;
+    streamOptions: Omit<WebStreamingSyncImplementationOptions, 'adapter' | 'uploadCrud' | 'remote' | 'subscriptions'>;
     dbParams: ResolvedWebSQLOpenOptions;
 };
 /**
@@ -43,6 +43,7 @@ export type WrappedSyncPort = {
     port: MessagePort;
     clientProvider: Comlink.Remote<AbstractSharedSyncClientProvider>;
     db?: DBAdapter;
+    currentSubscriptions: SubscribedStream[];
 };
 /**
  * @internal
@@ -55,7 +56,7 @@ export type RemoteOperationAbortController = {
  * @internal
  * Shared sync implementation which runs inside a shared webworker
  */
-export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImplementationListener> implements StreamingSyncImplementation {
+export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImplementationListener> {
     protected ports: WrappedSyncPort[];
     protected isInitialized: Promise<void>;
     protected statusListener?: () => void;
@@ -66,6 +67,7 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
     protected logger: ILogger;
     protected lastConnectOptions: PowerSyncConnectionOptions | undefined;
     protected portMutex: Mutex;
+    private subscriptions;
     protected connectionManager: ConnectionManager;
     syncStatus: SyncStatus;
     broadCastLogger: ILogger;
@@ -75,6 +77,8 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
     waitForStatus(status: SyncStatusOptions): Promise<void>;
     waitUntilStatusMatches(predicate: (status: SyncStatus) => boolean): Promise<void>;
     waitForReady(): Promise<void>;
+    private collectActiveSubscriptions;
+    updateSubscriptions(port: WrappedSyncPort, subscriptions: SubscribedStream[]): void;
     setLogLevel(level: ILogLevel): void;
     /**
      * Configures the DBAdapter connection and a streaming sync client.
@@ -92,12 +96,16 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
     /**
      * Adds a new client tab's message port to the list of connected ports
      */
-    addPort(port: MessagePort): Promise<void>;
+    addPort(port: MessagePort): Promise<{
+        port: MessagePort;
+        clientProvider: Comlink.Remote<AbstractSharedSyncClientProvider>;
+        currentSubscriptions: never[];
+    }>;
     /**
      * Removes a message port client from this manager's managed
      * clients.
      */
-    removePort(port: MessagePort): Promise<() => void>;
+    removePort(port: WrappedSyncPort): Promise<() => void>;
     triggerCrudUpload(): void;
     hasCompletedSync(): Promise<boolean>;
     getWriteCheckpoint(): Promise<string>;
@@ -113,5 +121,5 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
      * A function only used for unit tests which updates the internal
      * sync stream client and all tab client's sync status
      */
-    private _testUpdateAllStatuses;
+    _testUpdateAllStatuses(status: SyncStatusOptions): Promise<void>;
 }

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

@@ -40,6 +40,7 @@ export class SharedSyncImplementation extends BaseObserver {
     logger;
     lastConnectOptions;
     portMutex;
+    subscriptions = [];
     connectionManager;
     syncStatus;
     broadCastLogger;
@@ -102,6 +103,23 @@ export class SharedSyncImplementation extends BaseObserver {
     async waitForReady() {
         return this.isInitialized;
     }
+    collectActiveSubscriptions() {
+        this.logger.debug('Collecting active stream subscriptions across tabs');
+        const active = new Map();
+        for (const port of this.ports) {
+            for (const stream of port.currentSubscriptions) {
+                const serializedKey = JSON.stringify(stream);
+                active.set(serializedKey, stream);
+            }
+        }
+        this.subscriptions = [...active.values()];
+        this.logger.debug('Collected stream subscriptions', this.subscriptions);
+        this.connectionManager.syncStreamImplementation?.updateSubscriptions(this.subscriptions);
+    }
+    updateSubscriptions(port, subscriptions) {
+        port.currentSubscriptions = subscriptions;
+        this.collectActiveSubscriptions();
+    }
     setLogLevel(level) {
         this.logger.setLevel(level);
         this.broadCastLogger.setLevel(level);
@@ -111,6 +129,7 @@ export class SharedSyncImplementation extends BaseObserver {
      */
     async setParams(params) {
         await this.portMutex.runExclusive(async () => {
+            this.collectActiveSubscriptions();
             if (this.syncParams) {
                 // Cannot modify already existing sync implementation params
                 // But we can ask for a DB adapter, if required, at this point.
@@ -156,10 +175,11 @@ export class SharedSyncImplementation extends BaseObserver {
      * Adds a new client tab's message port to the list of connected ports
      */
     async addPort(port) {
-        await this.portMutex.runExclusive(() => {
+        return await this.portMutex.runExclusive(() => {
             const portProvider = {
                 port,
-                clientProvider: Comlink.wrap(port)
+                clientProvider: Comlink.wrap(port),
+                currentSubscriptions: []
             };
             this.ports.push(portProvider);
             // Give the newly connected client the latest status
@@ -167,6 +187,7 @@ export class SharedSyncImplementation extends BaseObserver {
             if (status) {
                 portProvider.clientProvider.statusChanged(status.toJSON());
             }
+            return portProvider;
         });
     }
     /**
@@ -178,7 +199,7 @@ export class SharedSyncImplementation extends BaseObserver {
         // 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);
+            const index = this.ports.findIndex((p) => p == port);
             if (index < 0) {
                 this.logger.warn(`Could not remove port ${port} since it is not present in active ports.`);
                 return {};
@@ -191,7 +212,7 @@ export class SharedSyncImplementation extends BaseObserver {
              * not resolve. Abort them here.
              */
             [this.fetchCredentialsController, this.uploadDataController].forEach((abortController) => {
-                if (abortController?.activePort.port == port) {
+                if (abortController?.activePort == port) {
                     abortController.controller.abort(new AbortOperation('Closing pending requests after client port is removed'));
                 }
             });
@@ -218,6 +239,8 @@ export class SharedSyncImplementation extends BaseObserver {
         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
         return () => trackedPort.clientProvider[Comlink.releaseProxy]();
     }
@@ -312,6 +335,7 @@ export class SharedSyncImplementation extends BaseObserver {
                 });
             },
             ...syncParams.streamOptions,
+            subscriptions: this.subscriptions,
             // Logger cannot be transferred just yet
             logger: this.logger
         });

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

@@ -1,27 +1,11 @@
 import { createBaseLogger } from '@powersync/common';
-import * as Comlink from 'comlink';
-import { SharedSyncClientEvent, SharedSyncImplementation } from './SharedSyncImplementation';
+import { SharedSyncImplementation } from './SharedSyncImplementation';
+import { WorkerClient } from './WorkerClient';
 const _self = self;
 const logger = createBaseLogger();
 logger.useDefaults();
 const sharedSyncImplementation = new SharedSyncImplementation();
 _self.onconnect = async function (event) {
     const port = event.ports[0];
-    /**
-     * Adds an extra listener which can remove this port
-     * from the list of monitored ports.
-     */
-    port.addEventListener('message', async (event) => {
-        const payload = event.data;
-        if (payload?.event == SharedSyncClientEvent.CLOSE_CLIENT) {
-            const release = await sharedSyncImplementation.removePort(port);
-            port.postMessage({
-                event: SharedSyncClientEvent.CLOSE_ACK,
-                data: {}
-            });
-            release?.();
-        }
-    });
-    await sharedSyncImplementation.addPort(port);
-    Comlink.expose(sharedSyncImplementation, port);
+    await new WorkerClient(sharedSyncImplementation, port).initialize();
 };

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

@@ -0,0 +1,32 @@
+import { SharedSyncImplementation, SharedSyncInitOptions } from './SharedSyncImplementation';
+import { ILogLevel, PowerSyncConnectionOptions, SubscribedStream, SyncStatusOptions } from '@powersync/common';
+/**
+ * A client to the shared sync worker.
+ *
+ * The shared sync implementation needs a per-client view of subscriptions so that subscriptions of closed tabs can
+ * automatically be evicted later.
+ */
+export declare class WorkerClient {
+    private readonly sync;
+    private readonly port;
+    private resolvedPort;
+    constructor(sync: SharedSyncImplementation, port: MessagePort);
+    initialize(): Promise<void>;
+    private removePort;
+    /**
+     * Called by a client after obtaining a lock with a random name.
+     *
+     * When the client tab is closed, its lock will be returned. So when the shared worker attempts to acquire the lock,
+     * it can consider the connection to be closed.
+     */
+    addLockBasedCloseSignal(name: string): void;
+    setLogLevel(level: ILogLevel): void;
+    triggerCrudUpload(): void;
+    setParams(params: SharedSyncInitOptions, subscriptions: SubscribedStream[]): Promise<void>;
+    getWriteCheckpoint(): Promise<string>;
+    hasCompletedSync(): Promise<boolean>;
+    connect(options?: PowerSyncConnectionOptions): Promise<void>;
+    updateSubscriptions(subscriptions: SubscribedStream[]): void;
+    disconnect(): Promise<void>;
+    _testUpdateAllStatuses(status: SyncStatusOptions): Promise<void>;
+}

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

@@ -0,0 +1,84 @@
+import * as Comlink from 'comlink';
+import { SharedSyncClientEvent } from './SharedSyncImplementation';
+import { getNavigatorLocks } from '../../shared/navigator';
+/**
+ * A client to the shared sync worker.
+ *
+ * The shared sync implementation needs a per-client view of subscriptions so that subscriptions of closed tabs can
+ * automatically be evicted later.
+ */
+export class WorkerClient {
+    sync;
+    port;
+    resolvedPort = null;
+    constructor(sync, port) {
+        this.sync = sync;
+        this.port = port;
+    }
+    async initialize() {
+        /**
+         * Adds an extra listener which can remove this port
+         * from the list of monitored ports.
+         */
+        this.port.addEventListener('message', async (event) => {
+            const payload = event.data;
+            if (payload?.event == SharedSyncClientEvent.CLOSE_CLIENT) {
+                await this.removePort();
+            }
+        });
+        this.resolvedPort = await this.sync.addPort(this.port);
+        Comlink.expose(this, this.port);
+    }
+    async removePort() {
+        if (this.resolvedPort) {
+            const release = await this.sync.removePort(this.resolvedPort);
+            this.resolvedPort = null;
+            this.port.postMessage({
+                event: SharedSyncClientEvent.CLOSE_ACK,
+                data: {}
+            });
+            release?.();
+        }
+    }
+    /**
+     * Called by a client after obtaining a lock with a random name.
+     *
+     * When the client tab is closed, its lock will be returned. So when the shared worker attempts to acquire the lock,
+     * it can consider the connection to be closed.
+     */
+    addLockBasedCloseSignal(name) {
+        getNavigatorLocks().request(name, async () => {
+            await this.removePort();
+        });
+    }
+    setLogLevel(level) {
+        this.sync.setLogLevel(level);
+    }
+    triggerCrudUpload() {
+        return this.sync.triggerCrudUpload();
+    }
+    setParams(params, subscriptions) {
+        this.resolvedPort.currentSubscriptions = subscriptions;
+        return this.sync.setParams(params);
+    }
+    getWriteCheckpoint() {
+        return this.sync.getWriteCheckpoint();
+    }
+    hasCompletedSync() {
+        return this.sync.hasCompletedSync();
+    }
+    connect(options) {
+        return this.sync.connect(options);
+    }
+    updateSubscriptions(subscriptions) {
+        if (this.resolvedPort) {
+            this.sync.updateSubscriptions(this.resolvedPort, subscriptions);
+        }
+    }
+    disconnect() {
+        return this.sync.disconnect();
+    }
+    async _testUpdateAllStatuses(status) {
+        return this.sync._testUpdateAllStatuses(status);
+    }
+}