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

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

@@ -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,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>;
 }