@powersync/web 0.0.0-dev-20251127205344 → 0.0.0-dev-20251201150812

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,7 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
     _config = null;
     pendingAbortControllers;
     requiresHolds;
+    databaseOpenPromise = null;
     closing;
     closed;
     constructor(options) {
@@ -68,17 +70,46 @@ 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;
     }
+    _reOpen() {
+        this.databaseOpenPromise = this.openInternalDB().finally(() => {
+            this.databaseOpenPromise = null;
+        });
+        return this.databaseOpenPromise;
+    }
+    /**
+     * Re-opens the underlying database.
+     * Returns a pending operation if one is already in progress.
+     */
+    async reOpenInternalDB() {
+        if (!this.options.reOpenOnConnectionClosed) {
+            throw new Error(`Cannot re-open underlying database, reOpenOnConnectionClosed is not enabled`);
+        }
+        if (this.databaseOpenPromise) {
+            return this.databaseOpenPromise;
+        }
+        return this._reOpen();
+    }
+    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 +175,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 +192,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 +200,35 @@ 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.reOpenInternalDB();
+                    }
+                }
+                throw ex;
+            }
             finally {
                 if (holdId) {
                     await this.baseDB.releaseHold(holdId);

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

@@ -1,3 +1,4 @@
+import { BaseObserver } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { AsyncDatabaseConnection, OnTableChangeCallback, OpenAsyncDatabaseConnection, ProxiedQueryResult } from './AsyncDatabaseConnection';
 import { ResolvedWebSQLOpenOptions } from './web-sql-flags';
@@ -15,11 +16,14 @@ export type WrappedWorkerConnectionOptions<Config extends ResolvedWebSQLOpenOpti
     remote: Comlink.Remote<OpenAsyncDatabaseConnection<Config>>;
     onClose?: () => void;
 };
+export type WorkerWrappedAsyncDatabaseConnectionListener = {
+    closing: () => void;
+};
 /**
  * Wraps a provided instance of {@link AsyncDatabaseConnection}, providing necessary proxy
  * functions for worker listeners.
  */
-export declare class WorkerWrappedAsyncDatabaseConnection<Config extends ResolvedWebSQLOpenOptions = ResolvedWebSQLOpenOptions> implements AsyncDatabaseConnection {
+export declare class WorkerWrappedAsyncDatabaseConnection<Config extends ResolvedWebSQLOpenOptions = ResolvedWebSQLOpenOptions> extends BaseObserver<WorkerWrappedAsyncDatabaseConnectionListener> implements AsyncDatabaseConnection {
     protected options: WrappedWorkerConnectionOptions<Config>;
     protected lockAbortController: AbortController;
     protected notifyRemoteClosed: AbortController | undefined;

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

@@ -1,13 +1,16 @@
+import { BaseObserver } from '@powersync/common';
 import * as Comlink from 'comlink';
+import { ConnectionClosedError } from './AsyncDatabaseConnection';
 /**
  * Wraps a provided instance of {@link AsyncDatabaseConnection}, providing necessary proxy
  * functions for worker listeners.
  */
-export class WorkerWrappedAsyncDatabaseConnection {
+export class WorkerWrappedAsyncDatabaseConnection extends BaseObserver {
     options;
     lockAbortController = new AbortController();
     notifyRemoteClosed;
     constructor(options) {
+        super();
         this.options = options;
         if (options.remoteCanCloseUnexpectedly) {
             this.notifyRemoteClosed = new AbortController();
@@ -40,17 +43,20 @@ export class WorkerWrappedAsyncDatabaseConnection {
     isAutoCommit() {
         return this.withRemote(() => this.baseConnection.isAutoCommit());
     }
-    withRemote(workerPromise) {
+    withRemote(workerPromise, fireActionOnAbort = false) {
         const controller = this.notifyRemoteClosed;
         if (controller) {
             return new Promise((resolve, reject) => {
                 if (controller.signal.aborted) {
-                    reject(new Error('Called operation on closed remote'));
-                    // Don't run the operation if we're going to reject
-                    return;
+                    reject(new ConnectionClosedError('Called operation on closed remote'));
+                    if (!fireActionOnAbort) {
+                        // Don't run the operation if we're going to reject
+                        // We might want to fire-and-forget the operation in some cases (like a close operation)
+                        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);
@@ -118,11 +124,13 @@ export class WorkerWrappedAsyncDatabaseConnection {
         // Abort any pending lock requests.
         this.lockAbortController.abort();
         try {
-            await this.withRemote(() => this.baseConnection.close());
+            // fire and forget the close operation
+            await this.withRemote(() => this.baseConnection.close(), true);
         }
         finally {
             this.options.remote[Comlink.releaseProxy]();
             this.options.onClose?.();
+            this.iterateListeners((l) => l.closing?.());
         }
     }
     execute(sql, params) {

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

@@ -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.
@@ -52,9 +53,5 @@ export declare class SharedWebStreamingSyncImplementation extends WebStreamingSy
     dispose(): Promise<void>;
     waitForReady(): Promise<void>;
     updateSubscriptions(subscriptions: SubscribedStream[]): void;
-    /**
-     * Used in tests to force a connection states
-     */
-    private _testUpdateStatus;
 }
 export {};

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

@@ -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,22 +140,43 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
          * DB worker, but a port to the DB worker can be transferred to the
          * sync worker.
          */
-        const { crudUploadThrottleMs, identifier, retryDelayMs } = this.options;
-        const flags = { ...this.webOptions.flags, workers: undefined };
-        // 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) {
+        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();
                 });
-            }
+            });
         });
-        this.isInitialized = this.syncManager.setParams({
+        const { crudUploadThrottleMs, identifier, retryDelayMs } = this.options;
+        const flags = { ...this.webOptions.flags, workers: undefined };
+        await this.syncManager.setParams({
             dbParams: this.dbAdapter.getConfiguration(),
             streamOptions: {
                 crudUploadThrottleMs,
@@ -151,19 +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);
+        }, this.options.subscriptions);
     }
     /**
      * Starts the sync process, this effectively acts as a call to
@@ -186,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) => {
@@ -202,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]();
@@ -213,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/worker/sync/MockSyncService.d.ts

@@ -0,0 +1,2 @@
+export * from './MockSyncServiceTypes';
+export * from './MockSyncServiceWorker';

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

@@ -0,0 +1,3 @@
+// Re-export types and worker-side implementation
+export * from './MockSyncServiceTypes';
+export * from './MockSyncServiceWorker';

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

@@ -0,0 +1,101 @@
+/**
+ * Representation of a pending request
+ */
+export interface PendingRequest {
+    id: string;
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body: any;
+}
+/**
+ * Automatic response configuration
+ */
+export interface AutomaticResponseConfig {
+    status: number;
+    headers: Record<string, string>;
+    bodyLines?: any[];
+}
+/**
+ * Message types for communication via MessagePort
+ */
+export type MockSyncServiceMessage = {
+    type: 'getPendingRequests';
+    requestId: string;
+} | {
+    type: 'createResponse';
+    requestId: string;
+    pendingRequestId: string;
+    status: number;
+    headers: Record<string, string>;
+} | {
+    type: 'pushBodyData';
+    requestId: string;
+    pendingRequestId: string;
+    data: string | ArrayBuffer | Uint8Array;
+} | {
+    type: 'completeResponse';
+    requestId: string;
+    pendingRequestId: string;
+} | {
+    type: 'setAutomaticResponse';
+    requestId: string;
+    config: AutomaticResponseConfig | null;
+} | {
+    type: 'replyToAllPendingRequests';
+    requestId: string;
+};
+export type MockSyncServiceResponse = {
+    type: 'getPendingRequests';
+    requestId: string;
+    requests: PendingRequest[];
+} | {
+    type: 'createResponse';
+    requestId: string;
+    success: boolean;
+} | {
+    type: 'pushBodyData';
+    requestId: string;
+    success: boolean;
+} | {
+    type: 'completeResponse';
+    requestId: string;
+    success: boolean;
+} | {
+    type: 'setAutomaticResponse';
+    requestId: string;
+    success: boolean;
+} | {
+    type: 'replyToAllPendingRequests';
+    requestId: string;
+    success: boolean;
+    count: number;
+} | {
+    type: 'error';
+    requestId?: string;
+    error: string;
+};
+/**
+ * Internal representation of a pending request with response promise
+ */
+export interface PendingRequestInternal {
+    id: string;
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body: any;
+    responsePromise: {
+        resolve: (response: Response) => void;
+        reject: (error: Error) => void;
+    };
+    streamController?: ReadableStreamDefaultController<Uint8Array>;
+}
+/**
+ * Internal representation of an active response
+ */
+export interface ActiveResponse {
+    id: string;
+    status: number;
+    headers: Record<string, string>;
+    stream: ReadableStreamDefaultController<Uint8Array>;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,56 @@
+import { AutomaticResponseConfig, PendingRequest } from './MockSyncServiceTypes';
+/**
+ * Mock sync service implementation for shared worker environments.
+ * This allows tests to mock sync responses when using enableMultipleTabs: true.
+ * Requests are kept pending until a client explicitly creates a response.
+ */
+export declare class MockSyncService {
+    private pendingRequests;
+    private activeResponses;
+    private nextId;
+    private automaticResponse;
+    /**
+     * A Static instance of the mock sync service.
+     * This can be used directly for non-worker environments.
+     * A proxy is required for worker environments.
+     */
+    static readonly GLOBAL_INSTANCE: MockSyncService;
+    /**
+     * Register a new pending request (called by WebRemote when a sync stream is requested).
+     * Returns a promise that resolves when a client creates a response for this request.
+     */
+    registerPendingRequest(url: string, method: string, headers: Record<string, string>, body: any, signal?: AbortSignal): Promise<Response>;
+    /**
+     * Get all pending requests
+     */
+    getPendingRequestsSync(): PendingRequest[];
+    /**
+     * Create a response for a pending request.
+     * This resolves the response promise and allows pushing body lines.
+     */
+    createResponse(pendingRequestId: string, status: number, headers: Record<string, string>): void;
+    /**
+     * Push body data to an active response.
+     * Accepts either text (string) or binary data (ArrayBuffer or Uint8Array).
+     * All data is encoded to Uint8Array before enqueueing (required by ReadableStream<Uint8Array>).
+     */
+    pushBodyData(pendingRequestId: string, data: string | ArrayBuffer | Uint8Array): void;
+    /**
+     * Complete an active response (close the stream)
+     */
+    completeResponse(pendingRequestId: string): void;
+    /**
+     * Set the automatic response configuration.
+     * When set, this will be used to automatically reply to all pending requests.
+     */
+    setAutomaticResponse(config: AutomaticResponseConfig | null): void;
+    /**
+     * Automatically reply to all pending requests using the automatic response configuration.
+     * Returns the number of requests that were replied to.
+     */
+    replyToAllPendingRequests(): number;
+}
+/**
+ * Set up message handler for the mock service on a MessagePort
+ */
+export declare function setupMockServiceMessageHandler(port: MessagePort): void;