@powersync/web 0.0.0-dev-20250922105207 → 0.0.0-dev-20250922105508

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

@@ -59,7 +59,6 @@ export const DEFAULT_MODULE_FACTORIES = {
     },
     [WASQLiteVFS.AccessHandlePoolVFS]: async (options) => {
         let module;
-        options.logger?.debug(`Opening VFS with options`, JSON.stringify(options));
         if (options.encryptionKey) {
             module = await MultiCipherSyncWASQLiteModuleFactory();
         }
@@ -68,26 +67,9 @@ export const DEFAULT_MODULE_FACTORIES = {
         }
         // @ts-expect-error The types for this static method are missing upstream
         const { AccessHandlePoolVFS } = await import('@journeyapps/wa-sqlite/src/examples/AccessHandlePoolVFS.js');
-        const vfs = new AccessHandlePoolVFS(options.dbFileName, module);
-        // Allow extra logs
-        const proxiedVFS = new Proxy(vfs, {
-            get(target, prop, receiver) {
-                const value = Reflect.get(target, prop, receiver);
-                // Only wrap methods, not properties
-                if (typeof value === 'function') {
-                    return function (...args) {
-                        options.logger?.debug(`VFS: Called ${String(prop)} with:`, args);
-                        return value.apply(vfs, args);
-                    };
-                }
-                return value;
-            }
-        });
-        await vfs.isReady();
-        // const vfs = await AccessHandlePoolVFS.create(options.dbFileName, module);
         return {
             module,
-            vfs: proxiedVFS
+            vfs: await AccessHandlePoolVFS.create(options.dbFileName, module)
         };
     },
     [WASQLiteVFS.OPFSCoopSyncVFS]: async (options) => {
@@ -160,9 +142,7 @@ export class WASqliteConnection extends BaseObserver {
     async openSQLiteAPI() {
         const { module, vfs } = await this._moduleFactory({
             dbFileName: this.options.dbFilename,
-            encryptionKey: this.options.encryptionKey,
-            debugMode: this.options.debugMode,
-            logger: this.options.logger
+            encryptionKey: this.options.encryptionKey
         });
         const sqlite3 = SQLite.Factory(module);
         sqlite3.vfs_register(vfs, true);
@@ -200,7 +180,6 @@ export class WASqliteConnection extends BaseObserver {
         }
     }
     async init() {
-        this.options.logger?.debug('Opening WASQLite connection for', this.options.dbFilename);
         this._sqliteAPI = await this.openSQLiteAPI();
         await this.openDB();
         this.registerBroadcastListeners();
@@ -298,7 +277,6 @@ export class WASqliteConnection extends BaseObserver {
         });
     }
     async close() {
-        this.options.logger?.debug('Closing WASQLite connection', this.options.dbFilename);
         this.broadcastChannel?.close();
         await this.sqliteAPI.close(this.dbP);
     }
@@ -347,10 +325,6 @@ export class WASqliteConnection extends BaseObserver {
         return results.flatMap((resultset) => resultset.rows.map((row) => resultset.columns.map((_, index) => row[index])));
     }
     async _execute(sql, bindings) {
-        // TODO, this might be redundant
-        if (this.options.debugMode) {
-            this.options.logger?.debug(`Executing SQL: ${sql}`);
-        }
         const results = [];
         for await (const stmt of this.sqliteAPI.statements(this.dbP, sql)) {
             let columns;

package/lib/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.d.ts

@@ -9,7 +9,7 @@ export interface WASQLiteOpenFactoryOptions extends WebSQLOpenFactoryOptions {
 export interface ResolvedWASQLiteOpenFactoryOptions extends ResolvedWebSQLOpenOptions {
     vfs: WASQLiteVFS;
 }
-export interface WorkerDBOpenerOptions extends Omit<ResolvedWASQLiteOpenFactoryOptions, 'logger'> {
+export interface WorkerDBOpenerOptions extends ResolvedWASQLiteOpenFactoryOptions {
     logLevel: ILogLevel;
 }
 /**

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

@@ -52,12 +52,8 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
                     cacheSizeKb,
                     flags: this.resolvedFlags,
                     encryptionKey: encryptionKey,
-                    logLevel: this.logger.getLevel(),
-                    debugMode: this.options.debugMode
-                }, Comlink.proxy((event) => {
-                    // TODO
-                    this.logger[event.logLevel.toLocaleLowerCase()]('[DB Worker] ', ...event.messages);
-                })),
+                    logLevel: this.logger.getLevel()
+                }),
                 identifier: this.options.dbFilename,
                 onClose: () => {
                     if (workerPort instanceof Worker) {

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/db/WASQLiteDB.worker.js

@@ -2,70 +2,21 @@
  * Supports both shared and dedicated workers, based on how the worker is constructed (new SharedWorker vs new Worker()).
  */
 import '@journeyapps/wa-sqlite';
-import { createBaseLogger, createLogger, LogLevel } from '@powersync/common';
+import { createBaseLogger, createLogger } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
 import { getNavigatorLocks } from '../../shared/navigator';
-import { LogHandler } from './LogHandler';
+const baseLogger = createBaseLogger();
+baseLogger.useDefaults();
+const logger = createLogger('db-worker');
 const DBMap = new Map();
 const OPEN_DB_LOCK = 'open-wasqlite-db';
-function logToAll(logLevel, ...messages) {
-    for (const dbFilename of DBMap.keys()) {
-        logBroadcaster.pushLog({
-            loggerName: dbFilename,
-            logLevel,
-            messages
-        });
-    }
-}
 let nextClientId = 1;
-function logUnhandledException(error) {
-    const errorMessage = `
-  Name: ${error.name}
-  Cause: ${error.cause}
-  Message: ${error.message}
-  Stack: ${error.stack}`.trim();
-    logToAll(LogLevel.ERROR.name, 'Uncaught Exception in DB worker', errorMessage);
-}
-// Report unhandled exceptions to all loggers
-addEventListener('unhandledrejection', (event) => {
-    logUnhandledException(event.reason);
-});
-addEventListener('error', (event) => {
-    logUnhandledException(event.error);
-});
-addEventListener('unload', () => {
-    logToAll(LogLevel.INFO.name, 'DB worker is unloading');
-    Array.from(DBMap.values()).forEach(async (dbConnection) => {
-        const { db, clientIds } = dbConnection;
-        logToAll(LogLevel.INFO.name, `closing db with ids ${clientIds}`);
-        db.close();
-    });
-});
-const baseLogger = createBaseLogger();
-const logBroadcaster = new LogHandler();
-const defaultHandler = baseLogger.createDefaultHandler();
-const logHandler = (messages, context) => {
-    logBroadcaster.pushLog({
-        loggerName: context.name ?? 'unknown',
-        logLevel: context.level.name,
-        messages: messages.map((m) => String(m))
-    });
-    defaultHandler(messages, context);
-};
-baseLogger.useDefaults({
-    formatter: logHandler
-});
-const workerLogger = createLogger('db-worker');
 const openWorkerConnection = async (options) => {
     const connection = new WASqliteConnection(options);
     return {
         init: Comlink.proxy(() => connection.init()),
-        getConfig: Comlink.proxy(async () => {
-            // Can't send the logger over
-            const { logger, ...rest } = await connection.getConfig();
-            return rest;
-        }),
+        getConfig: Comlink.proxy(() => connection.getConfig()),
         close: Comlink.proxy(() => connection.close()),
         execute: Comlink.proxy(async (sql, params) => connection.execute(sql, params)),
         executeRaw: Comlink.proxy(async (sql, params) => connection.executeRaw(sql, params)),
@@ -76,34 +27,15 @@ const openWorkerConnection = async (options) => {
         })
     };
 };
-const openDBShared = async (options, logHandler) => {
+const openDBShared = async (options) => {
     // Prevent multiple simultaneous opens from causing race conditions
     return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
         const clientId = nextClientId++;
         const { dbFilename, logLevel } = options;
-        logToAll(`Worker opening DB connection for`, JSON.stringify(options));
-        // This updates the log level for the worker-level logger
-        // The DB connection logger will automatically track the main context logger
-        // since it passes logs to it.
-        workerLogger.setLevel(logLevel);
-        let disposeLogListener = logHandler
-            ? logBroadcaster.registerListener({
-                onLog: (event) => {
-                    if (event.loggerName !== dbFilename) {
-                        return;
-                    }
-                    logHandler(event);
-                }
-            })
-            : null;
+        logger.setLevel(logLevel);
         if (!DBMap.has(dbFilename)) {
             const clientIds = new Set();
-            const logger = createLogger(dbFilename);
-            logger.debug(`Worker opened a new connection`);
-            const connection = await openWorkerConnection({
-                ...options,
-                logger
-            });
+            const connection = await openWorkerConnection(options);
             await connection.init();
             DBMap.set(dbFilename, {
                 clientIds,
@@ -120,15 +52,14 @@ const openDBShared = async (options, logHandler) => {
             }),
             close: Comlink.proxy(async () => {
                 const { clientIds } = dbEntry;
-                disposeLogListener?.();
-                workerLogger.debug(`Close requested from client ${clientId} of ${[...clientIds]}`);
+                logger.debug(`Close requested from client ${clientId} of ${[...clientIds]}`);
                 clientIds.delete(clientId);
                 if (clientIds.size == 0) {
-                    workerLogger.debug(`Closing connection to ${dbFilename}.`);
+                    logger.debug(`Closing connection to ${dbFilename}.`);
                     DBMap.delete(dbFilename);
                     return db.close?.();
                 }
-                workerLogger.debug(`Connection to ${dbFilename} not closed yet due to active clients.`);
+                logger.debug(`Connection to ${dbFilename} not closed yet due to active clients.`);
                 return;
             })
         };
@@ -147,3 +78,9 @@ else {
     // A dedicated worker can be shared externally
     Comlink.expose(openDBShared);
 }
+addEventListener('unload', () => {
+    Array.from(DBMap.values()).forEach(async (dbConnection) => {
+        const { db } = dbConnection;
+        db.close?.();
+    });
+});

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>;
+}