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

package/src/db/adapters/LockedAsyncDatabaseAdapter.ts

@@ -57,7 +57,6 @@ export class LockedAsyncDatabaseAdapter
   private _config: ResolvedWebSQLOpenOptions | null = null;
   protected pendingAbortControllers: Set<AbortController>;
   protected requiresHolds: boolean | null;
-  protected requiresReOpen: boolean;
   protected databaseOpenPromise: Promise<void> | null = null;
 
   closing: boolean;
@@ -71,7 +70,6 @@ export class LockedAsyncDatabaseAdapter
     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) {
@@ -134,6 +132,27 @@ export class LockedAsyncDatabaseAdapter
     this.requiresHolds = (this._config as ResolvedWASQLiteOpenFactoryOptions).vfs == WASQLiteVFS.IDBBatchAtomicVFS;
   }
 
+  protected _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(): Promise<void> {
+    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();
+  }
+
   protected async _init() {
     await this.openInternalDB();
     this.iterateListeners((cb) => cb.initialized?.());
@@ -279,9 +298,7 @@ export class LockedAsyncDatabaseAdapter
           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;
-              });
+              this.reOpenInternalDB();
             }
           }
           throw ex;

package/src/db/adapters/WorkerWrappedAsyncDatabaseConnection.ts

@@ -1,3 +1,4 @@
+import { BaseObserver } from '@powersync/common';
 import * as Comlink from 'comlink';
 import {
   AsyncDatabaseConnection,
@@ -24,17 +25,23 @@ export type WrappedWorkerConnectionOptions<Config extends ResolvedWebSQLOpenOpti
   onClose?: () => void;
 };
 
+export type WorkerWrappedAsyncDatabaseConnectionListener = {
+  closing: () => void;
+};
 /**
  * Wraps a provided instance of {@link AsyncDatabaseConnection}, providing necessary proxy
  * functions for worker listeners.
  */
 export class WorkerWrappedAsyncDatabaseConnection<Config extends ResolvedWebSQLOpenOptions = ResolvedWebSQLOpenOptions>
+  extends BaseObserver<WorkerWrappedAsyncDatabaseConnectionListener>
   implements AsyncDatabaseConnection
 {
   protected lockAbortController = new AbortController();
   protected notifyRemoteClosed: AbortController | undefined;
 
   constructor(protected options: WrappedWorkerConnectionOptions<Config>) {
+    super();
+
     if (options.remoteCanCloseUnexpectedly) {
       this.notifyRemoteClosed = new AbortController();
     }
@@ -73,14 +80,17 @@ export class WorkerWrappedAsyncDatabaseConnection<Config extends ResolvedWebSQLO
     return this.withRemote(() => this.baseConnection.isAutoCommit());
   }
 
-  private withRemote<T>(workerPromise: () => Promise<T>): Promise<T> {
+  private withRemote<T>(workerPromise: () => Promise<T>, fireActionOnAbort = false): Promise<T> {
     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() {
@@ -165,10 +175,12 @@ export class WorkerWrappedAsyncDatabaseConnection<Config extends ResolvedWebSQLO
     // 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?.());
     }
   }
 

package/src/db/sync/SharedWebStreamingSyncImplementation.ts

@@ -2,7 +2,6 @@ import {
   PowerSyncConnectionOptions,
   PowerSyncCredentials,
   SubscribedStream,
-  SyncStatus,
   SyncStatusOptions
 } from '@powersync/common';
 import * as Comlink from 'comlink';
@@ -187,6 +186,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.
@@ -255,8 +256,6 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
   async dispose(): Promise<void> {
     await this.waitForReady();
 
-    await super.dispose();
-
     await new Promise<void>((resolve) => {
       // Listen for the close acknowledgment from the worker
       this.messagePort.addEventListener('message', (event) => {
@@ -273,6 +272,9 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
       };
       this.messagePort.postMessage(closeMessagePayload);
     });
+
+    await super.dispose();
+
     this.abortOnClose.abort();
 
     // Release the proxy
@@ -287,12 +289,4 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
   updateSubscriptions(subscriptions: SubscribedStream[]): void {
     this.syncManager.updateSubscriptions(subscriptions);
   }
-
-  /**
-   * Used in tests to force a connection states
-   */
-  private async _testUpdateStatus(status: SyncStatus) {
-    await this.isInitialized;
-    return this.syncManager._testUpdateAllStatuses(status.toJSON());
-  }
 }

package/src/worker/sync/MockSyncService.ts

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

package/src/worker/sync/MockSyncServiceTypes.ts

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

@@ -0,0 +1,406 @@
+import type { MockSyncServiceMessage, MockSyncServiceResponse } from './MockSyncServiceTypes';
+import {
+  ActiveResponse,
+  AutomaticResponseConfig,
+  PendingRequest,
+  PendingRequestInternal
+} 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 class MockSyncService {
+  private pendingRequests: Map<string, PendingRequestInternal> = new Map();
+  private activeResponses: Map<string, ActiveResponse> = new Map();
+  private nextId = 0;
+  private automaticResponse: AutomaticResponseConfig | null = 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 readonly 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: string,
+    method: string,
+    headers: Record<string, string>,
+    body: any,
+    signal?: AbortSignal
+  ): Promise<Response> {
+    const id = `pending-${++this.nextId}`;
+
+    let resolveResponse: (response: Response) => void;
+    let rejectResponse: (error: Error) => void;
+
+    const responsePromise = new Promise<Response>((resolve, reject) => {
+      resolveResponse = resolve;
+      rejectResponse = reject;
+    });
+
+    const pendingRequest: PendingRequestInternal = {
+      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(): PendingRequest[] {
+    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: string, status: number, headers: Record<string, string>): void {
+    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<Uint8Array>({
+      start: (controller) => {
+        // Store the active response once the controller is available
+        // The start callback is called synchronously, so this is safe
+        const activeResponse: 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: string, data: string | ArrayBuffer | Uint8Array): void {
+    const activeResponse = this.activeResponses.get(pendingRequestId);
+    if (!activeResponse) {
+      throw new Error(`Active response ${pendingRequestId} not found`);
+    }
+
+    try {
+      let encoded: Uint8Array;
+
+      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: string): void {
+    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: AutomaticResponseConfig | null): void {
+    this.automaticResponse = config;
+  }
+
+  /**
+   * Automatically reply to all pending requests using the automatic response configuration.
+   * Returns the number of requests that were replied to.
+   */
+  replyToAllPendingRequests(): number {
+    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: MessagePort) {
+  port.addEventListener('message', (event: MessageEvent<MockSyncServiceMessage>) => {
+    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
+            } satisfies MockSyncServiceResponse);
+          } catch (error) {
+            port.postMessage({
+              type: 'error',
+              requestId: message.requestId,
+              error: error instanceof Error ? error.message : String(error)
+            } satisfies MockSyncServiceResponse);
+          }
+          break;
+        }
+        case 'createResponse': {
+          try {
+            service.createResponse(message.pendingRequestId, message.status, message.headers);
+            port.postMessage({
+              type: 'createResponse',
+              requestId: message.requestId,
+              success: true
+            } satisfies MockSyncServiceResponse);
+          } catch (error) {
+            port.postMessage({
+              type: 'error',
+              requestId: message.requestId,
+              error: error instanceof Error ? error.message : String(error)
+            } satisfies MockSyncServiceResponse);
+          }
+          break;
+        }
+        case 'pushBodyData': {
+          try {
+            service.pushBodyData(message.pendingRequestId, message.data);
+            port.postMessage({
+              type: 'pushBodyData',
+              requestId: message.requestId,
+              success: true
+            } satisfies MockSyncServiceResponse);
+          } catch (error) {
+            port.postMessage({
+              type: 'error',
+              requestId: message.requestId,
+              error: error instanceof Error ? error.message : String(error)
+            } satisfies MockSyncServiceResponse);
+          }
+          break;
+        }
+        case 'completeResponse': {
+          try {
+            service.completeResponse(message.pendingRequestId);
+            port.postMessage({
+              type: 'completeResponse',
+              requestId: message.requestId,
+              success: true
+            } satisfies MockSyncServiceResponse);
+          } catch (error) {
+            port.postMessage({
+              type: 'error',
+              requestId: message.requestId,
+              error: error instanceof Error ? error.message : String(error)
+            } satisfies MockSyncServiceResponse);
+          }
+          break;
+        }
+        case 'setAutomaticResponse': {
+          try {
+            service.setAutomaticResponse(message.config);
+            port.postMessage({
+              type: 'setAutomaticResponse',
+              requestId: message.requestId,
+              success: true
+            } satisfies MockSyncServiceResponse);
+          } catch (error) {
+            port.postMessage({
+              type: 'error',
+              requestId: message.requestId,
+              error: error instanceof Error ? error.message : String(error)
+            } satisfies MockSyncServiceResponse);
+          }
+          break;
+        }
+        case 'replyToAllPendingRequests': {
+          try {
+            const count = service.replyToAllPendingRequests();
+            port.postMessage({
+              type: 'replyToAllPendingRequests',
+              requestId: message.requestId,
+              success: true,
+              count
+            } satisfies MockSyncServiceResponse);
+          } catch (error) {
+            port.postMessage({
+              type: 'error',
+              requestId: message.requestId,
+              error: error instanceof Error ? error.message : String(error)
+            } satisfies MockSyncServiceResponse);
+          }
+          break;
+        }
+        default: {
+          const requestId =
+            'requestId' in message && typeof message === 'object' && message !== null
+              ? (message as { requestId?: string }).requestId
+              : undefined;
+          port.postMessage({
+            type: 'error',
+            requestId,
+            error: `Unknown message type: ${(message as any).type}`
+          } satisfies MockSyncServiceResponse);
+          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)
+      } satisfies MockSyncServiceResponse);
+    }
+  });
+
+  port.start();
+}