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

package/src/db/adapters/LockedAsyncDatabaseAdapter.ts

@@ -11,7 +11,7 @@ import {
   type ILogger
 } from '@powersync/common';
 import { getNavigatorLocks } from '../..//shared/navigator';
-import { AsyncDatabaseConnection } from './AsyncDatabaseConnection';
+import { AsyncDatabaseConnection, ConnectionClosedError } from './AsyncDatabaseConnection';
 import { SharedConnectionWorker, WebDBAdapter } from './WebDBAdapter';
 import { WorkerWrappedAsyncDatabaseConnection } from './WorkerWrappedAsyncDatabaseConnection';
 import { WASQLiteVFS } from './wa-sqlite/WASQLiteConnection';
@@ -26,10 +26,16 @@ export interface LockedAsyncDatabaseAdapterOptions {
   openConnection: () => Promise<AsyncDatabaseConnection>;
   debugMode?: boolean;
   logger?: ILogger;
+  defaultLockTimeoutMs?: number;
+  reOpenOnConnectionClosed?: boolean;
 }
 
 export type LockedAsyncDatabaseAdapterListener = DBAdapterListener & {
   initialized?: () => void;
+  /**
+   * Fired when the database is re-opened after being closed.
+   */
+  databaseReOpened?: () => void;
 };
 
 /**
@@ -51,6 +57,7 @@ export class LockedAsyncDatabaseAdapter
   private _config: ResolvedWebSQLOpenOptions | null = null;
   protected pendingAbortControllers: Set<AbortController>;
   protected requiresHolds: boolean | null;
+  protected databaseOpenPromise: Promise<void> | null = null;
 
   closing: boolean;
   closed: boolean;
@@ -105,18 +112,52 @@ export class LockedAsyncDatabaseAdapter
     return this.initPromise;
   }
 
-  protected async _init() {
+  protected 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 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?.());
+  }
+
   getConfiguration(): ResolvedWebSQLOpenOptions {
     if (!this._config) {
       throw new Error(`Cannot get config before initialization is completed`);
@@ -196,7 +237,7 @@ export class LockedAsyncDatabaseAdapter
     return this.acquireLock(
       async () => fn(this.generateDBHelpers({ execute: this._execute, executeRaw: this._executeRaw })),
       {
-        timeoutMs: options?.timeoutMs
+        timeoutMs: options?.timeoutMs ?? this.options.defaultLockTimeoutMs
       }
     );
   }
@@ -206,7 +247,7 @@ export class LockedAsyncDatabaseAdapter
     return this.acquireLock(
       async () => fn(this.generateDBHelpers({ execute: this._execute, executeRaw: this._executeRaw })),
       {
-        timeoutMs: options?.timeoutMs
+        timeoutMs: options?.timeoutMs ?? this.options.defaultLockTimeoutMs
       }
     );
   }
@@ -222,7 +263,7 @@ export class LockedAsyncDatabaseAdapter
     this.pendingAbortControllers.add(abortController);
     const { timeoutMs } = options ?? {};
 
-    const timoutId = timeoutMs
+    const timeoutId = timeoutMs
       ? setTimeout(() => {
           abortController.abort(`Timeout after ${timeoutMs}ms`);
           this.pendingAbortControllers.delete(abortController);
@@ -234,12 +275,33 @@ export class LockedAsyncDatabaseAdapter
       { 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: string | null = 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/src/db/adapters/WorkerWrappedAsyncDatabaseConnection.ts

@@ -1,6 +1,8 @@
+import { BaseObserver } from '@powersync/common';
 import * as Comlink from 'comlink';
 import {
   AsyncDatabaseConnection,
+  ConnectionClosedError,
   OnTableChangeCallback,
   OpenAsyncDatabaseConnection,
   ProxiedQueryResult
@@ -23,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();
     }
@@ -72,18 +80,21 @@ 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 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: () => void) {
@@ -164,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';
@@ -146,7 +145,25 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
       ).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<WorkerClient>(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;
@@ -157,25 +174,49 @@ 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();
+  }
+
+  protected 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<void>((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<void>((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: {
@@ -185,26 +226,8 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
           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
+      this.options.subscriptions
     );
-
-    /**
-     * 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);
   }
 
   /**
@@ -233,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) => {
@@ -251,6 +272,9 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
       };
       this.messagePort.postMessage(closeMessagePayload);
     });
+
+    await super.dispose();
+
     this.abortOnClose.abort();
 
     // Release the proxy
@@ -265,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>;
+}