@powersync/web 1.30.0 → 1.32.0

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

@@ -1,9 +1,9 @@
 import * as Comlink from 'comlink';
-import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider';
-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';
+import { getNavigatorLocks } from '../../shared/navigator.js';
+import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider.js';
+import { SharedSyncClientEvent } from '../../worker/sync/SharedSyncImplementation.js';
+import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption, resolveWebSQLFlags } from '../adapters/web-sql-flags.js';
+import { WebStreamingSyncImplementation } from './WebStreamingSyncImplementation.js';
 /**
  * The shared worker will trigger methods on this side of the message port
  * via this client provider.
@@ -119,7 +119,19 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
                 type: 'module'
             }).port;
         }
+        /**
+         * Pass along any sync status updates to this listener
+         */
+        this.clientProvider = new SharedSyncClientProvider(this.webOptions, (status) => {
+            this.updateSyncStatus(status);
+        }, options.db);
         this.syncManager = Comlink.wrap(this.messagePort);
+        /**
+         * The sync worker will call this client provider when it needs
+         * to fetch credentials or upload data.
+         * This performs bi-directional method calling.
+         */
+        Comlink.expose(this.clientProvider, this.messagePort);
         this.syncManager.setLogLevel(this.logger.getLevel());
         this.triggerCrudUpload = this.syncManager.triggerCrudUpload;
         /**
@@ -128,9 +140,43 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
          * DB worker, but a port to the DB worker can be transferred to the
          * sync worker.
          */
+        this.isInitialized = this._init();
+    }
+    async _init() {
+        /**
+         * The general flow of initialization is:
+         *  - The client requests a unique navigator lock.
+         *    - Once the lock is acquired, we register the lock with the shared worker.
+         *    - The shared worker can then request the same lock. The client has been closed if the shared worker can acquire the lock.
+         *    - Once the shared worker knows the client's lock, we can guarentee that the shared worker will detect if the client has been closed.
+         *    - This makes the client safe for the shared worker to use.
+         *    - The client is only added to the SharedSyncImplementation once the lock has been registered.
+         *      This ensures we don't ever keep track of dead clients (tabs that closed before the lock was registered).
+         *    - The client side lock is held until the client is disposed.
+         *    - We resolve the top-level promise after the lock has been registered with the shared worker.
+         * - The client sends the params to the shared worker after locks have been registered.
+         */
+        await new Promise((resolve) => {
+            // 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.
+            // We take hold of this lock as soon-as-possible in order to cater for potentially closed tabs.
+            getNavigatorLocks().request(`tab-close-signal-${crypto.randomUUID()}`, async (lock) => {
+                if (this.abortOnClose.signal.aborted) {
+                    return;
+                }
+                // Awaiting here ensures the worker is waiting for the lock
+                await this.syncManager.addLockBasedCloseSignal(lock.name);
+                // The lock has been registered, we can continue with the initialization
+                resolve();
+                await new Promise((r) => {
+                    this.abortOnClose.signal.onabort = () => r();
+                });
+            });
+        });
         const { crudUploadThrottleMs, identifier, retryDelayMs } = this.options;
         const flags = { ...this.webOptions.flags, workers: undefined };
-        this.isInitialized = this.syncManager.setParams({
+        await this.syncManager.setParams({
             dbParams: this.dbAdapter.getConfiguration(),
             streamOptions: {
                 crudUploadThrottleMs,
@@ -138,30 +184,7 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
                 retryDelayMs,
                 flags: flags
             }
-        }, options.subscriptions);
-        /**
-         * Pass along any sync status updates to this listener
-         */
-        this.clientProvider = new SharedSyncClientProvider(this.webOptions, (status) => {
-            this.iterateListeners((l) => this.updateSyncStatus(status));
-        }, options.db);
-        /**
-         * The sync worker will call this client provider when it needs
-         * to fetch credentials or upload data.
-         * 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();
-                });
-            }
-        });
+        }, this.options.subscriptions);
     }
     /**
      * Starts the sync process, this effectively acts as a call to
@@ -184,7 +207,6 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
     }
     async dispose() {
         await this.waitForReady();
-        await super.dispose();
         await new Promise((resolve) => {
             // Listen for the close acknowledgment from the worker
             this.messagePort.addEventListener('message', (event) => {
@@ -200,6 +222,7 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
             };
             this.messagePort.postMessage(closeMessagePayload);
         });
+        await super.dispose();
         this.abortOnClose.abort();
         // Release the proxy
         this.syncManager[Comlink.releaseProxy]();
@@ -211,11 +234,4 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
     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());
-    }
 }

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

@@ -1,5 +1,5 @@
 import { AbstractRemote, DEFAULT_REMOTE_LOGGER, FetchImplementationProvider } from '@powersync/common';
-import { getUserAgentInfo } from './userAgent';
+import { getUserAgentInfo } from './userAgent.js';
 /*
  * Depends on browser's implementation of global fetch.
  */

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

@@ -1,5 +1,5 @@
 import { AbstractStreamingSyncImplementation, AbstractStreamingSyncImplementationOptions, LockOptions } from '@powersync/common';
-import { ResolvedWebSQLOpenOptions, WebSQLFlags } from '../adapters/web-sql-flags';
+import { ResolvedWebSQLOpenOptions, WebSQLFlags } from '../adapters/web-sql-flags.js';
 export interface WebStreamingSyncImplementationOptions extends AbstractStreamingSyncImplementationOptions {
     flags?: WebSQLFlags;
     sync?: {

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

@@ -1,5 +1,5 @@
 import { AbstractStreamingSyncImplementation, LockType } from '@powersync/common';
-import { getNavigatorLocks } from '../../shared/navigator';
+import { getNavigatorLocks } from '../../shared/navigator.js';
 export class WebStreamingSyncImplementation extends AbstractStreamingSyncImplementation {
     constructor(options) {
         // Super will store and provide default values for options

package/lib/src/index.d.ts

@@ -1,13 +1,13 @@
 export * from '@powersync/common';
-export * from './db/adapters/AsyncDatabaseConnection';
-export * from './db/adapters/AbstractWebPowerSyncDatabaseOpenFactory';
-export * from './db/adapters/AbstractWebSQLOpenFactory';
-export * from './db/adapters/wa-sqlite/WASQLiteConnection';
-export * from './db/adapters/wa-sqlite/WASQLiteDBAdapter';
-export * from './db/adapters/wa-sqlite/WASQLiteOpenFactory';
-export * from './db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory';
-export * from './db/adapters/web-sql-flags';
-export * from './db/PowerSyncDatabase';
-export * from './db/sync/SharedWebStreamingSyncImplementation';
-export * from './db/sync/WebRemote';
-export * from './db/sync/WebStreamingSyncImplementation';
+export * from './db/adapters/AbstractWebPowerSyncDatabaseOpenFactory.js';
+export * from './db/adapters/AbstractWebSQLOpenFactory.js';
+export * from './db/adapters/AsyncDatabaseConnection.js';
+export * from './db/adapters/wa-sqlite/WASQLiteConnection.js';
+export * from './db/adapters/wa-sqlite/WASQLiteDBAdapter.js';
+export * from './db/adapters/wa-sqlite/WASQLiteOpenFactory.js';
+export * from './db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory.js';
+export * from './db/adapters/web-sql-flags.js';
+export * from './db/PowerSyncDatabase.js';
+export * from './db/sync/SharedWebStreamingSyncImplementation.js';
+export * from './db/sync/WebRemote.js';
+export * from './db/sync/WebStreamingSyncImplementation.js';

package/lib/src/index.js

@@ -1,13 +1,13 @@
 export * from '@powersync/common';
-export * from './db/adapters/AsyncDatabaseConnection';
-export * from './db/adapters/AbstractWebPowerSyncDatabaseOpenFactory';
-export * from './db/adapters/AbstractWebSQLOpenFactory';
-export * from './db/adapters/wa-sqlite/WASQLiteConnection';
-export * from './db/adapters/wa-sqlite/WASQLiteDBAdapter';
-export * from './db/adapters/wa-sqlite/WASQLiteOpenFactory';
-export * from './db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory';
-export * from './db/adapters/web-sql-flags';
-export * from './db/PowerSyncDatabase';
-export * from './db/sync/SharedWebStreamingSyncImplementation';
-export * from './db/sync/WebRemote';
-export * from './db/sync/WebStreamingSyncImplementation';
+export * from './db/adapters/AbstractWebPowerSyncDatabaseOpenFactory.js';
+export * from './db/adapters/AbstractWebSQLOpenFactory.js';
+export * from './db/adapters/AsyncDatabaseConnection.js';
+export * from './db/adapters/wa-sqlite/WASQLiteConnection.js';
+export * from './db/adapters/wa-sqlite/WASQLiteDBAdapter.js';
+export * from './db/adapters/wa-sqlite/WASQLiteOpenFactory.js';
+export * from './db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory.js';
+export * from './db/adapters/web-sql-flags.js';
+export * from './db/PowerSyncDatabase.js';
+export * from './db/sync/SharedWebStreamingSyncImplementation.js';
+export * from './db/sync/WebRemote.js';
+export * from './db/sync/WebStreamingSyncImplementation.js';

package/lib/src/worker/db/SharedWASQLiteConnection.d.ts

@@ -1,6 +1,6 @@
 import { ILogger } from '@powersync/common';
-import { AsyncDatabaseConnection, OnTableChangeCallback, ProxiedQueryResult } from '../../db/adapters/AsyncDatabaseConnection';
-import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags';
+import { AsyncDatabaseConnection, OnTableChangeCallback, ProxiedQueryResult } from '../../db/adapters/AsyncDatabaseConnection.js';
+import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags.js';
 /**
  * Keeps track of open DB connections and the clients which
  * are using it.

package/lib/src/worker/db/WASQLiteDB.worker.js

@@ -4,9 +4,9 @@
 import '@journeyapps/wa-sqlite';
 import { createBaseLogger, createLogger } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { getNavigatorLocks } from '../../shared/navigator';
-import { SharedWASQLiteConnection } from './SharedWASQLiteConnection';
-import { WorkerWASQLiteConnection } from './WorkerWASQLiteConnection';
+import { getNavigatorLocks } from '../../shared/navigator.js';
+import { SharedWASQLiteConnection } from './SharedWASQLiteConnection.js';
+import { WorkerWASQLiteConnection } from './WorkerWASQLiteConnection.js';
 const baseLogger = createBaseLogger();
 baseLogger.useDefaults();
 const logger = createLogger('db-worker');

package/lib/src/worker/db/WorkerWASQLiteConnection.d.ts

@@ -1,5 +1,5 @@
-import { OnTableChangeCallback } from '../../db/adapters/AsyncDatabaseConnection';
-import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
+import { OnTableChangeCallback } from '../../db/adapters/AsyncDatabaseConnection.js';
+import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection.js';
 /**
  * A Small proxy wrapper around the WASqliteConnection.
  * This ensures that certain return types are properly proxied.

package/lib/src/worker/db/WorkerWASQLiteConnection.js

@@ -1,5 +1,5 @@
 import * as Comlink from 'comlink';
-import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
+import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection.js';
 /**
  * A Small proxy wrapper around the WASqliteConnection.
  * This ensures that certain return types are properly proxied.

package/lib/src/worker/db/open-worker-database.d.ts

@@ -1,6 +1,6 @@
 import * as Comlink from 'comlink';
-import { OpenAsyncDatabaseConnection } from '../..//db/adapters/AsyncDatabaseConnection';
-import { WASQLiteVFS } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
+import { OpenAsyncDatabaseConnection } from '../../db/adapters/AsyncDatabaseConnection.js';
+import { WASQLiteVFS } from '../../db/adapters/wa-sqlite/WASQLiteConnection.js';
 /**
  * Opens a shared or dedicated worker which exposes opening of database connections
  */

package/lib/src/worker/db/open-worker-database.js

@@ -1,5 +1,5 @@
 import * as Comlink from 'comlink';
-import { WASQLiteVFS } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
+import { WASQLiteVFS } from '../../db/adapters/wa-sqlite/WASQLiteConnection.js';
 /**
  * Opens a shared or dedicated worker which exposes opening of database connections
  */

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

@@ -1,5 +1,5 @@
 import { type ILogger, type ILogLevel } from '@powersync/common';
-import { type WrappedSyncPort } from './SharedSyncImplementation';
+import { type WrappedSyncPort } from './SharedSyncImplementation.js';
 /**
  * Broadcasts logs to all clients
  */

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

@@ -1,9 +1,10 @@
-import { BaseObserver, ConnectionManager, DBAdapter, SubscribedStream, SyncStatus, type ILogger, type ILogLevel, type PowerSyncConnectionOptions, type StreamingSyncImplementation, type StreamingSyncImplementationListener, type SyncStatusOptions } from '@powersync/common';
+import { BaseObserver, ConnectionManager, DBAdapter, SubscribedStream, SyncStatus, type ILogLevel, type ILogger, type PowerSyncConnectionOptions, type StreamingSyncImplementation, type StreamingSyncImplementationListener, type SyncStatusOptions } from '@powersync/common';
 import { Mutex } from 'async-mutex';
 import * as Comlink from 'comlink';
-import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions } from '../../db/sync/WebStreamingSyncImplementation';
-import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags';
-import { AbstractSharedSyncClientProvider } from './AbstractSharedSyncClientProvider';
+import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions } from '../../db/sync/WebStreamingSyncImplementation.js';
+import { WorkerWrappedAsyncDatabaseConnection } from '../../db/adapters/WorkerWrappedAsyncDatabaseConnection.js';
+import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags.js';
+import { AbstractSharedSyncClientProvider } from './AbstractSharedSyncClientProvider.js';
 /**
  * @internal
  * Manual message events for shared sync clients
@@ -45,6 +46,7 @@ export type WrappedSyncPort = {
     db?: DBAdapter;
     currentSubscriptions: SubscribedStream[];
     closeListeners: (() => void | Promise<void>)[];
+    isClosing: boolean;
 };
 /**
  * @internal
@@ -63,7 +65,6 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
     protected statusListener?: () => void;
     protected fetchCredentialsController?: RemoteOperationAbortController;
     protected uploadDataController?: RemoteOperationAbortController;
-    protected dbAdapter: DBAdapter | null;
     protected syncParams: SharedSyncInitOptions | null;
     protected logger: ILogger;
     protected lastConnectOptions: PowerSyncConnectionOptions | undefined;
@@ -72,9 +73,19 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
     protected connectionManager: ConnectionManager;
     syncStatus: SyncStatus;
     broadCastLogger: ILogger;
+    protected distributedDB: DBAdapter | null;
     constructor();
     get lastSyncedAt(): Date | undefined;
     get isConnected(): boolean;
+    /**
+     * Gets the last client port which we know is safe from unexpected closes.
+     */
+    protected getLastWrappedPort(): Promise<WrappedSyncPort | undefined>;
+    /**
+     * In some very rare cases a specific tab might not respond to requests.
+     * This returns a random port which is not closing.
+     */
+    protected getRandomWrappedPort(): Promise<WrappedSyncPort | undefined>;
     waitForStatus(status: SyncStatusOptions): Promise<void>;
     waitUntilStatusMatches(predicate: (status: SyncStatus) => boolean): Promise<void>;
     waitForReady(): Promise<void>;
@@ -102,6 +113,7 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
         clientProvider: Comlink.Remote<AbstractSharedSyncClientProvider>;
         currentSubscriptions: never[];
         closeListeners: never[];
+        isClosing: false;
     }>;
     /**
      * Removes a message port client from this manager's managed
@@ -113,15 +125,13 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
     getWriteCheckpoint(): Promise<string>;
     protected withSyncImplementation<T>(callback: (sync: StreamingSyncImplementation) => Promise<T>): Promise<T>;
     protected generateStreamingImplementation(): WebStreamingSyncImplementation;
-    protected openInternalDB(): Promise<void>;
+    /**
+     * Opens a worker wrapped database connection. Using the last connected client port.
+     */
+    protected openInternalDB(): Promise<WorkerWrappedAsyncDatabaseConnection<ResolvedWebSQLOpenOptions>>;
     /**
      * A method to update the all shared statuses for each
      * client.
      */
     private updateAllStatuses;
-    /**
-     * A function only used for unit tests which updates the internal
-     * sync stream client and all tab client's sync status
-     */
-    _testUpdateAllStatuses(status: SyncStatusOptions): Promise<void>;
 }