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

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

@@ -1,14 +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();
@@ -41,14 +43,17 @@ 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 ConnectionClosedError('Called operation on closed remote'));
-                    // Don't run the operation if we're going to reject
-                    return;
+                    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 ConnectionClosedError('Remote peer closed with request in flight'));
@@ -119,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

@@ -53,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

@@ -150,6 +150,8 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
          *    - 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.
@@ -205,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) => {
@@ -221,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]();
@@ -232,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;

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

@@ -0,0 +1,369 @@
+/**
+ * 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 class MockSyncService {
+    pendingRequests = new Map();
+    activeResponses = new Map();
+    nextId = 0;
+    automaticResponse = null;
+    /**
+     * 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 GLOBAL_INSTANCE = new 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, method, headers, body, signal) {
+        const id = `pending-${++this.nextId}`;
+        let resolveResponse;
+        let rejectResponse;
+        const responsePromise = new Promise((resolve, reject) => {
+            resolveResponse = resolve;
+            rejectResponse = reject;
+        });
+        const pendingRequest = {
+            id,
+            url,
+            method,
+            headers,
+            body,
+            responsePromise: {
+                resolve: resolveResponse,
+                reject: rejectResponse
+            }
+        };
+        this.pendingRequests.set(id, pendingRequest);
+        signal?.addEventListener('abort', () => {
+            this.pendingRequests.delete(id);
+            rejectResponse(new Error('Request aborted'));
+            // if already in active responses, remove it
+            if (this.activeResponses.has(id)) {
+                const response = this.activeResponses.get(id);
+                if (response) {
+                    response.stream.close();
+                }
+                this.activeResponses.delete(id);
+            }
+        });
+        // If automatic response is configured, apply it immediately
+        if (this.automaticResponse) {
+            // Use setTimeout to ensure the response is created asynchronously
+            // This prevents issues if the response creation happens synchronously
+            setTimeout(() => {
+                try {
+                    // Create response with automatic config
+                    this.createResponse(id, this.automaticResponse.status, this.automaticResponse.headers);
+                    // Push body lines if provided
+                    if (this.automaticResponse.bodyLines) {
+                        for (const line of this.automaticResponse.bodyLines) {
+                            const lineStr = `${JSON.stringify(line)}\n`;
+                            const encoder = new TextEncoder();
+                            this.pushBodyData(id, encoder.encode(lineStr));
+                        }
+                    }
+                    // Complete the response
+                    this.completeResponse(id);
+                }
+                catch (e) {
+                    // If automatic response fails, reject the promise
+                    rejectResponse(e instanceof Error ? e : new Error(String(e)));
+                }
+            }, 0);
+        }
+        // Return the promise - it will resolve when createResponse is called (or immediately if auto-response is set)
+        return responsePromise;
+    }
+    /**
+     * Get all pending requests
+     */
+    getPendingRequestsSync() {
+        return Array.from(this.pendingRequests.values()).map((pr) => ({
+            id: pr.id,
+            url: pr.url,
+            method: pr.method,
+            headers: pr.headers,
+            body: pr.body
+        }));
+    }
+    /**
+     * Create a response for a pending request.
+     * This resolves the response promise and allows pushing body lines.
+     */
+    createResponse(pendingRequestId, status, headers) {
+        const pendingRequest = this.pendingRequests.get(pendingRequestId);
+        if (!pendingRequest) {
+            throw new Error(`Pending request ${pendingRequestId} not found`);
+        }
+        // Create a readable stream that the mock service can control
+        // Response.body is always ReadableStream<Uint8Array>, so we use Uint8Array
+        const stream = new ReadableStream({
+            start: (controller) => {
+                // Store the active response once the controller is available
+                // The start callback is called synchronously, so this is safe
+                const activeResponse = {
+                    id: pendingRequestId,
+                    status,
+                    headers,
+                    stream: controller
+                };
+                this.activeResponses.set(pendingRequestId, activeResponse);
+            },
+            cancel: () => {
+                // Remove response when stream is cancelled
+                this.activeResponses.delete(pendingRequestId);
+                this.pendingRequests.delete(pendingRequestId);
+            }
+        });
+        // Create the Response object
+        const response = new Response(stream, {
+            status,
+            headers
+        });
+        // Resolve the pending request's promise
+        pendingRequest.responsePromise.resolve(response);
+        // Remove from pending (it's now active)
+        this.pendingRequests.delete(pendingRequestId);
+    }
+    /**
+     * 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, data) {
+        const activeResponse = this.activeResponses.get(pendingRequestId);
+        if (!activeResponse) {
+            throw new Error(`Active response ${pendingRequestId} not found`);
+        }
+        try {
+            let encoded;
+            if (typeof data === 'string') {
+                // Encode string to Uint8Array (required by ReadableStream<Uint8Array>)
+                const encoder = new TextEncoder();
+                encoded = encoder.encode(data);
+            }
+            else if (data instanceof ArrayBuffer) {
+                // Convert ArrayBuffer to Uint8Array
+                encoded = new Uint8Array(data);
+            }
+            else {
+                // Already Uint8Array, use directly
+                encoded = data;
+            }
+            activeResponse.stream.enqueue(encoded);
+        }
+        catch (e) {
+            // Stream might be closed, remove it
+            this.activeResponses.delete(pendingRequestId);
+            throw new Error(`Failed to push data to response ${pendingRequestId}: ${e}`);
+        }
+    }
+    /**
+     * Complete an active response (close the stream)
+     */
+    completeResponse(pendingRequestId) {
+        const activeResponse = this.activeResponses.get(pendingRequestId);
+        if (!activeResponse) {
+            throw new Error(`Active response ${pendingRequestId} not found`);
+        }
+        try {
+            activeResponse.stream.close();
+        }
+        catch (e) {
+            // Stream might already be closed
+        }
+        finally {
+            this.activeResponses.delete(pendingRequestId);
+        }
+    }
+    /**
+     * Set the automatic response configuration.
+     * When set, this will be used to automatically reply to all pending requests.
+     */
+    setAutomaticResponse(config) {
+        this.automaticResponse = config;
+    }
+    /**
+     * Automatically reply to all pending requests using the automatic response configuration.
+     * Returns the number of requests that were replied to.
+     */
+    replyToAllPendingRequests() {
+        if (!this.automaticResponse) {
+            throw new Error('Automatic response not set. Call setAutomaticResponse first.');
+        }
+        const pendingRequestIds = Array.from(this.pendingRequests.keys());
+        let count = 0;
+        for (const requestId of pendingRequestIds) {
+            try {
+                // Create response with automatic config
+                this.createResponse(requestId, this.automaticResponse.status, this.automaticResponse.headers);
+                // Push body lines if provided
+                if (this.automaticResponse.bodyLines) {
+                    for (const line of this.automaticResponse.bodyLines) {
+                        const lineStr = `${JSON.stringify(line)}\n`;
+                        const encoder = new TextEncoder();
+                        this.pushBodyData(requestId, encoder.encode(lineStr));
+                    }
+                }
+                // Complete the response
+                this.completeResponse(requestId);
+                count++;
+            }
+            catch (e) {
+                // Skip requests that fail (might already be handled)
+                continue;
+            }
+        }
+        return count;
+    }
+}
+/**
+ * Set up message handler for the mock service on a MessagePort
+ */
+export function setupMockServiceMessageHandler(port) {
+    port.addEventListener('message', (event) => {
+        const message = event.data;
+        if (!message || typeof message !== 'object' || !('type' in message)) {
+            return;
+        }
+        const service = MockSyncService.GLOBAL_INSTANCE;
+        try {
+            switch (message.type) {
+                case 'getPendingRequests': {
+                    try {
+                        const requests = service.getPendingRequestsSync();
+                        port.postMessage({
+                            type: 'getPendingRequests',
+                            requestId: message.requestId,
+                            requests
+                        });
+                    }
+                    catch (error) {
+                        port.postMessage({
+                            type: 'error',
+                            requestId: message.requestId,
+                            error: error instanceof Error ? error.message : String(error)
+                        });
+                    }
+                    break;
+                }
+                case 'createResponse': {
+                    try {
+                        service.createResponse(message.pendingRequestId, message.status, message.headers);
+                        port.postMessage({
+                            type: 'createResponse',
+                            requestId: message.requestId,
+                            success: true
+                        });
+                    }
+                    catch (error) {
+                        port.postMessage({
+                            type: 'error',
+                            requestId: message.requestId,
+                            error: error instanceof Error ? error.message : String(error)
+                        });
+                    }
+                    break;
+                }
+                case 'pushBodyData': {
+                    try {
+                        service.pushBodyData(message.pendingRequestId, message.data);
+                        port.postMessage({
+                            type: 'pushBodyData',
+                            requestId: message.requestId,
+                            success: true
+                        });
+                    }
+                    catch (error) {
+                        port.postMessage({
+                            type: 'error',
+                            requestId: message.requestId,
+                            error: error instanceof Error ? error.message : String(error)
+                        });
+                    }
+                    break;
+                }
+                case 'completeResponse': {
+                    try {
+                        service.completeResponse(message.pendingRequestId);
+                        port.postMessage({
+                            type: 'completeResponse',
+                            requestId: message.requestId,
+                            success: true
+                        });
+                    }
+                    catch (error) {
+                        port.postMessage({
+                            type: 'error',
+                            requestId: message.requestId,
+                            error: error instanceof Error ? error.message : String(error)
+                        });
+                    }
+                    break;
+                }
+                case 'setAutomaticResponse': {
+                    try {
+                        service.setAutomaticResponse(message.config);
+                        port.postMessage({
+                            type: 'setAutomaticResponse',
+                            requestId: message.requestId,
+                            success: true
+                        });
+                    }
+                    catch (error) {
+                        port.postMessage({
+                            type: 'error',
+                            requestId: message.requestId,
+                            error: error instanceof Error ? error.message : String(error)
+                        });
+                    }
+                    break;
+                }
+                case 'replyToAllPendingRequests': {
+                    try {
+                        const count = service.replyToAllPendingRequests();
+                        port.postMessage({
+                            type: 'replyToAllPendingRequests',
+                            requestId: message.requestId,
+                            success: true,
+                            count
+                        });
+                    }
+                    catch (error) {
+                        port.postMessage({
+                            type: 'error',
+                            requestId: message.requestId,
+                            error: error instanceof Error ? error.message : String(error)
+                        });
+                    }
+                    break;
+                }
+                default: {
+                    const requestId = 'requestId' in message && typeof message === 'object' && message !== null
+                        ? message.requestId
+                        : undefined;
+                    port.postMessage({
+                        type: 'error',
+                        requestId,
+                        error: `Unknown message type: ${message.type}`
+                    });
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            // Fallback for any unexpected errors
+            const requestId = 'requestId' in message ? message.requestId : undefined;
+            port.postMessage({
+                type: 'error',
+                requestId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    });
+    port.start();
+}

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

@@ -46,10 +46,6 @@ 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;
 };
 /**
@@ -84,7 +80,12 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
     /**
      * Gets the last client port which we know is safe from unexpected closes.
      */
-    protected get lastWrappedPort(): WrappedSyncPort | undefined;
+    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>;
@@ -112,7 +113,6 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
         clientProvider: Comlink.Remote<AbstractSharedSyncClientProvider>;
         currentSubscriptions: never[];
         closeListeners: never[];
-        isProtectedFromClose: false;
         isClosing: false;
     }>;
     /**
@@ -134,9 +134,4 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
      * 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>;
 }