@powersync/web 0.0.0-dev-20251126195153 → 0.0.0-dev-20251129133952

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

@@ -14,6 +14,9 @@ export type ProxiedQueryResult = Omit<QueryResult, 'rows'> & {
  * @internal
  */
 export type OnTableChangeCallback = (event: BatchedUpdateNotification) => void;
+export declare class ConnectionClosedError extends Error {
+    constructor(message: string);
+}
 /**
  * @internal
  * An async Database connection which provides basic async SQL methods.

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

@@ -1 +1,6 @@
-export {};
+export class ConnectionClosedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ConnectionClosedError';
+    }
+}

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

@@ -10,9 +10,15 @@ export interface LockedAsyncDatabaseAdapterOptions {
     openConnection: () => Promise<AsyncDatabaseConnection>;
     debugMode?: boolean;
     logger?: ILogger;
+    defaultLockTimeoutMs?: number;
+    reOpenOnConnectionClosed?: boolean;
 }
 export type LockedAsyncDatabaseAdapterListener = DBAdapterListener & {
     initialized?: () => void;
+    /**
+     * Fired when the database is re-opened after being closed.
+     */
+    databaseReOpened?: () => void;
 };
 /**
  * @internal
@@ -31,6 +37,8 @@ export declare class LockedAsyncDatabaseAdapter extends BaseObserver<LockedAsync
     private _config;
     protected pendingAbortControllers: Set<AbortController>;
     protected requiresHolds: boolean | null;
+    protected requiresReOpen: boolean;
+    protected databaseOpenPromise: Promise<void> | null;
     closing: boolean;
     closed: boolean;
     constructor(options: LockedAsyncDatabaseAdapterOptions);
@@ -40,6 +48,7 @@ export declare class LockedAsyncDatabaseAdapter extends BaseObserver<LockedAsync
      * Init is automatic, this helps catch errors or explicitly await initialization
      */
     init(): Promise<void>;
+    protected openInternalDB(): Promise<void>;
     protected _init(): Promise<void>;
     getConfiguration(): ResolvedWebSQLOpenOptions;
     protected waitForInitialized(): Promise<void>;

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

@@ -1,5 +1,6 @@
 import { BaseObserver, createLogger } from '@powersync/common';
 import { getNavigatorLocks } from '../..//shared/navigator';
+import { ConnectionClosedError } from './AsyncDatabaseConnection';
 import { WorkerWrappedAsyncDatabaseConnection } from './WorkerWrappedAsyncDatabaseConnection';
 import { WASQLiteVFS } from './wa-sqlite/WASQLiteConnection';
 /**
@@ -19,6 +20,8 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
     _config = null;
     pendingAbortControllers;
     requiresHolds;
+    requiresReOpen;
+    databaseOpenPromise = null;
     closing;
     closed;
     constructor(options) {
@@ -30,6 +33,7 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
         this.closed = false;
         this.closing = false;
         this.requiresHolds = null;
+        this.requiresReOpen = false;
         // Set the name if provided. We can query for the name if not available yet
         this.debugMode = options.debugMode ?? false;
         if (this.debugMode) {
@@ -68,17 +72,27 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
     async init() {
         return this.initPromise;
     }
-    async _init() {
+    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);
-        this.iterateListeners((cb) => cb.initialized?.());
+        if (isReOpen) {
+            this.iterateListeners((cb) => cb.databaseReOpened?.());
+        }
         /**
          * This is only required for the long-lived shared IndexedDB connections.
          */
         this.requiresHolds = this._config.vfs == WASQLiteVFS.IDBBatchAtomicVFS;
     }
+    async _init() {
+        await this.openInternalDB();
+        this.iterateListeners((cb) => cb.initialized?.());
+    }
     getConfiguration() {
         if (!this._config) {
             throw new Error(`Cannot get config before initialization is completed`);
@@ -144,13 +158,13 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
     async readLock(fn, options) {
         await this.waitForInitialized();
         return this.acquireLock(async () => fn(this.generateDBHelpers({ execute: this._execute, executeRaw: this._executeRaw })), {
-            timeoutMs: options?.timeoutMs
+            timeoutMs: options?.timeoutMs ?? this.options.defaultLockTimeoutMs
         });
     }
     async writeLock(fn, options) {
         await this.waitForInitialized();
         return this.acquireLock(async () => fn(this.generateDBHelpers({ execute: this._execute, executeRaw: this._executeRaw })), {
-            timeoutMs: options?.timeoutMs
+            timeoutMs: options?.timeoutMs ?? this.options.defaultLockTimeoutMs
         });
     }
     async acquireLock(callback, options) {
@@ -161,7 +175,7 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
         const abortController = new AbortController();
         this.pendingAbortControllers.add(abortController);
         const { timeoutMs } = options ?? {};
-        const timoutId = timeoutMs
+        const timeoutId = timeoutMs
             ? setTimeout(() => {
                 abortController.abort(`Timeout after ${timeoutMs}ms`);
                 this.pendingAbortControllers.delete(abortController);
@@ -169,13 +183,37 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
             : null;
         return getNavigatorLocks().request(`db-lock-${this._dbIdentifier}`, { signal: abortController.signal }, async () => {
             this.pendingAbortControllers.delete(abortController);
-            if (timoutId) {
-                clearTimeout(timoutId);
+            if (timeoutId) {
+                clearTimeout(timeoutId);
             }
-            const holdId = this.requiresHolds ? await this.baseDB.markHold() : null;
+            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 ConnectionClosedError('Could not open database');
+                        wrappedError.cause = ex;
+                        throw wrappedError;
+                    }
+                }
+                holdId = this.requiresHolds ? await this.baseDB.markHold() : null;
                 return await callback();
             }
+            catch (ex) {
+                if (ex instanceof ConnectionClosedError) {
+                    if (this.options.reOpenOnConnectionClosed && !this.databaseOpenPromise && !this.closing) {
+                        // Immediately re-open the database. We need to miss as little table updates as possible.
+                        this.databaseOpenPromise = this.openInternalDB().finally(() => {
+                            this.databaseOpenPromise = null;
+                        });
+                    }
+                }
+                throw ex;
+            }
             finally {
                 if (holdId) {
                     await this.baseDB.releaseHold(holdId);

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

@@ -1,4 +1,5 @@
 import * as Comlink from 'comlink';
+import { ConnectionClosedError } from './AsyncDatabaseConnection';
 /**
  * Wraps a provided instance of {@link AsyncDatabaseConnection}, providing necessary proxy
  * functions for worker listeners.
@@ -45,12 +46,12 @@ export class WorkerWrappedAsyncDatabaseConnection {
         if (controller) {
             return new Promise((resolve, reject) => {
                 if (controller.signal.aborted) {
-                    reject(new Error('Called operation on closed remote'));
+                    reject(new ConnectionClosedError('Called operation on closed remote'));
                     // Don't run the operation if we're going to reject
                     return;
                 }
                 function handleAbort() {
-                    reject(new Error('Remote peer closed with request in flight'));
+                    reject(new ConnectionClosedError('Remote peer closed with request in flight'));
                 }
                 function completePromise(action) {
                     controller.signal.removeEventListener('abort', handleAbort);

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

@@ -1,9 +1,9 @@
 import { PowerSyncConnectionOptions, PowerSyncCredentials, SubscribedStream, SyncStatusOptions } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider';
+import { WorkerClient } from '../../worker/sync/WorkerClient';
 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.
@@ -41,6 +41,7 @@ export declare class SharedWebStreamingSyncImplementation extends WebStreamingSy
     protected dbAdapter: WebDBAdapter;
     private abortOnClose;
     constructor(options: SharedWebStreamingSyncImplementationOptions);
+    protected _init(): Promise<void>;
     /**
      * Starts the sync process, this effectively acts as a call to
      * `connect` if not yet connected.

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

@@ -1,9 +1,9 @@
 import * as Comlink from 'comlink';
+import { getNavigatorLocks } from '../../shared/navigator';
 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 { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption, resolveWebSQLFlags } 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.
@@ -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,41 @@ 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 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 +182,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

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

@@ -1,7 +1,8 @@
-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 { WorkerWrappedAsyncDatabaseConnection } from '../../db/adapters/WorkerWrappedAsyncDatabaseConnection';
 import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags';
 import { AbstractSharedSyncClientProvider } from './AbstractSharedSyncClientProvider';
 /**
@@ -45,6 +46,11 @@ export type WrappedSyncPort = {
     db?: DBAdapter;
     currentSubscriptions: SubscribedStream[];
     closeListeners: (() => void | Promise<void>)[];
+    /**
+     * If we can use Navigator locks to detect if the client has closed.
+     */
+    isProtectedFromClose: boolean;
+    isClosing: boolean;
 };
 /**
  * @internal
@@ -63,7 +69,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 +77,14 @@ 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 get lastWrappedPort(): WrappedSyncPort | undefined;
     waitForStatus(status: SyncStatusOptions): Promise<void>;
     waitUntilStatusMatches(predicate: (status: SyncStatus) => boolean): Promise<void>;
     waitForReady(): Promise<void>;
@@ -102,6 +112,8 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
         clientProvider: Comlink.Remote<AbstractSharedSyncClientProvider>;
         currentSubscriptions: never[];
         closeListeners: never[];
+        isProtectedFromClose: false;
+        isClosing: false;
     }>;
     /**
      * Removes a message port client from this manager's managed
@@ -113,7 +125,10 @@ 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.