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

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

@@ -1,369 +0,0 @@
-/**
- * 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/src/worker/sync/MockSyncService.ts

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

package/src/worker/sync/MockSyncServiceTypes.ts

@@ -1,71 +0,0 @@
-/**
- * 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>;
-}