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

package/src/db/adapters/LockedAsyncDatabaseAdapter.ts

@@ -10,7 +10,7 @@ import {
   createLogger,
   type ILogger
 } from '@powersync/common';
-import { getNavigatorLocks } from '../..//shared/navigator';
+import { getNavigatorLocks } from '../../shared/navigator';
 import { AsyncDatabaseConnection, ConnectionClosedError } from './AsyncDatabaseConnection';
 import { SharedConnectionWorker, WebDBAdapter } from './WebDBAdapter';
 import { WorkerWrappedAsyncDatabaseConnection } from './WorkerWrappedAsyncDatabaseConnection';
@@ -113,23 +113,29 @@ export class LockedAsyncDatabaseAdapter
   }
 
   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);
-    if (isReOpen) {
-      this.iterateListeners((cb) => cb.databaseReOpened?.());
-    }
     /**
-     * This is only required for the long-lived shared IndexedDB connections.
+     * Execute opening of the db in a lock in order not to interfere with other operations.
      */
-    this.requiresHolds = (this._config as ResolvedWASQLiteOpenFactoryOptions).vfs == WASQLiteVFS.IDBBatchAtomicVFS;
+    return this._acquireLock(async () => {
+      // Dispose any previous table change listener.
+      this._disposeTableChangeListener?.();
+      this._disposeTableChangeListener = null;
+      this._db?.close().catch((ex) => this.logger.warn(`Error closing database before opening new instance`, ex));
+      const isReOpen = !!this._db;
+      this._db = null;
+
+      this._db = await this.options.openConnection();
+      await this._db.init();
+      this._config = await this._db.getConfig();
+      await this.registerOnChangeListener(this._db);
+      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() {
@@ -154,7 +160,23 @@ export class LockedAsyncDatabaseAdapter
   }
 
   protected async _init() {
-    await this.openInternalDB();
+    /**
+     * For OPFS, we can see this open call sometimes fail due to NoModificationAllowedError.
+     * We should be able to recover from this by re-opening the database.
+     */
+    const maxAttempts = 3;
+    for (let count = 0; count < maxAttempts; count++) {
+      try {
+        await this.openInternalDB();
+        break;
+      } catch (ex) {
+        if (count == maxAttempts - 1) {
+          throw ex;
+        }
+        this.logger.warn(`Attempt ${count + 1} of ${maxAttempts} to open database failed, retrying in 1 second...`, ex);
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+      }
+    }
     this.iterateListeners((cb) => cb.initialized?.());
   }
 
@@ -252,13 +274,10 @@ export class LockedAsyncDatabaseAdapter
     );
   }
 
-  protected async acquireLock(callback: () => Promise<any>, options?: { timeoutMs?: number }): Promise<any> {
-    await this.waitForInitialized();
-
+  protected async _acquireLock(callback: () => Promise<any>, options?: { timeoutMs?: number }): Promise<any> {
     if (this.closing) {
       throw new Error(`Cannot acquire lock, the database is closing`);
     }
-
     const abortController = new AbortController();
     this.pendingAbortControllers.add(abortController);
     const { timeoutMs } = options ?? {};
@@ -278,37 +297,49 @@ export class LockedAsyncDatabaseAdapter
         if (timeoutId) {
           clearTimeout(timeoutId);
         }
-        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;
-            }
-          }
+        return await callback();
+      }
+    );
+  }
 
-          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);
+  protected async acquireLock(callback: () => Promise<any>, options?: { timeoutMs?: number }): Promise<any> {
+    await this.waitForInitialized();
+
+    // The database is being opened in the background. Wait for it here.
+    if (this.databaseOpenPromise) {
+      await this.databaseOpenPromise;
+    }
+
+    return this._acquireLock(async () => {
+      let holdId: string | null = null;
+      try {
+        /**
+         * We can't await this since it uses the same lock as we're in now.
+         * If there is a pending open, this call will throw.
+         * If there is no pending open, but there is also no database - the open
+         * might have failed. We need to re-open the database.
+         */
+        if (this.databaseOpenPromise || !this._db) {
+          throw new ConnectionClosedError('Connection is busy re-opening');
+        }
+
+        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.
+            // Note, don't await this since it uses the same lock as we're in now.
+            this.reOpenInternalDB();
           }
         }
+        throw ex;
+      } finally {
+        if (holdId) {
+          await this.baseDB.releaseHold(holdId);
+        }
       }
-    );
+    }, options);
   }
 
   async readTransaction<T>(fn: (tx: Transaction) => Promise<T>, options?: DBLockOptions | undefined): Promise<T> {

package/src/db/adapters/wa-sqlite/WASQLiteConnection.ts

@@ -3,7 +3,6 @@ import { BaseObserver, BatchedUpdateNotification } from '@powersync/common';
 import { Mutex } from 'async-mutex';
 import { AsyncDatabaseConnection, OnTableChangeCallback, ProxiedQueryResult } from '../AsyncDatabaseConnection';
 import { ResolvedWASQLiteOpenFactoryOptions } from './WASQLiteOpenFactory';
-
 /**
  * List of currently tested virtual filesystems
  */
@@ -126,9 +125,10 @@ export const DEFAULT_MODULE_FACTORIES = {
     }
     // @ts-expect-error The types for this static method are missing upstream
     const { OPFSCoopSyncVFS } = await import('@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js');
+    const vfs = await OPFSCoopSyncVFS.create(options.dbFileName, module);
     return {
       module,
-      vfs: await OPFSCoopSyncVFS.create(options.dbFileName, module)
+      vfs
     };
   }
 };
@@ -387,7 +387,15 @@ export class WASqliteConnection
 
   async close() {
     this.broadcastChannel?.close();
-    await this.sqliteAPI.close(this.dbP);
+    await this.acquireExecuteLock(async () => {
+      /**
+       * Running the close operation inside the same execute mutex prevents errors like:
+       * ```
+       * unable to close due to unfinalized statements or unfinished backups
+       * ```
+       */
+      await this.sqliteAPI.close(this.dbP);
+    });
   }
 
   async registerOnTableChange(callback: OnTableChangeCallback) {

package/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.ts

@@ -1,17 +1,17 @@
-import { type ILogLevel, DBAdapter } from '@powersync/common';
+import { DBAdapter, type ILogLevel } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database';
 import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory';
 import { AsyncDatabaseConnection, OpenAsyncDatabaseConnection } from '../AsyncDatabaseConnection';
 import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter';
+import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection';
 import {
   DEFAULT_CACHE_SIZE_KB,
   ResolvedWebSQLOpenOptions,
   TemporaryStorageOption,
   WebSQLOpenFactoryOptions
 } from '../web-sql-flags';
-import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection';
-import { WASqliteConnection, WASQLiteVFS } from './WASQLiteConnection';
+import { WASQLiteVFS, WASqliteConnection } from './WASQLiteConnection';
 
 export interface WASQLiteOpenFactoryOptions extends WebSQLOpenFactoryOptions {
   vfs?: WASQLiteVFS;

package/src/worker/db/WASQLiteDB.worker.ts

@@ -17,7 +17,6 @@ const logger = createLogger('db-worker');
 
 const DBMap = new Map<string, SharedDBWorkerConnection>();
 const OPEN_DB_LOCK = 'open-wasqlite-db';
-
 let nextClientId = 1;
 
 const openDBShared = async (options: WorkerDBOpenerOptions): Promise<AsyncDatabaseConnection> => {

package/src/worker/sync/SharedSyncImplementation.ts

@@ -190,7 +190,8 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
    */
   protected async getRandomWrappedPort(): Promise<WrappedSyncPort | undefined> {
     return await this.portMutex.runExclusive(() => {
-      return this.ports[Math.floor(Math.random() * this.ports.length)];
+      const nonClosingPorts = this.ports.filter((p) => !p.isClosing);
+      return nonClosingPorts[Math.floor(Math.random() * nonClosingPorts.length)];
     });
   }
 
@@ -495,84 +496,87 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
    * Opens a worker wrapped database connection. Using the last connected client port.
    */
   protected async openInternalDB() {
-    while (true) {
-      try {
-        const client = await this.getRandomWrappedPort();
-        if (!client) {
-          // Should not really happen in practice
-          throw new Error(`Could not open DB connection since no client is connected.`);
-        }
+    const client = await this.getRandomWrappedPort();
+    if (!client) {
+      // Should not really happen in practice
+      throw new Error(`Could not open DB connection since no client is connected.`);
+    }
 
-        // Fail-safe timeout for opening a database connection.
-        const timeout = setTimeout(() => {
-          abortController.abort();
-        }, 10_000);
-
-        /**
-         * Handle cases where the client might close while opening a connection.
-         */
-        const abortController = new AbortController();
-        const closeListener = () => {
-          abortController.abort();
-        };
+    // Fail-safe timeout for opening a database connection.
+    const timeout = setTimeout(() => {
+      abortController.abort();
+    }, 10_000);
+
+    /**
+     * Handle cases where the client might close while opening a connection.
+     */
+    const abortController = new AbortController();
+    const closeListener = () => {
+      abortController.abort();
+    };
 
-        const removeCloseListener = () => {
-          const index = client.closeListeners.indexOf(closeListener);
-          if (index >= 0) {
-            client.closeListeners.splice(index, 1);
-          }
-        };
+    const removeCloseListener = () => {
+      const index = client.closeListeners.indexOf(closeListener);
+      if (index >= 0) {
+        client.closeListeners.splice(index, 1);
+      }
+    };
 
-        client.closeListeners.push(closeListener);
+    client.closeListeners.push(closeListener);
 
-        const workerPort = await withAbort(() => client.clientProvider.getDBWorkerPort(), abortController.signal).catch(
-          (ex) => {
-            removeCloseListener();
-            throw ex;
-          }
-        );
-
-        const remote = Comlink.wrap<OpenAsyncDatabaseConnection>(workerPort);
-        const identifier = this.syncParams!.dbParams.dbFilename;
-
-        /**
-         * The open could fail if the tab is closed while we're busy opening the database.
-         * This operation is typically executed inside an exclusive portMutex lock.
-         * We typically execute the closeListeners using the portMutex in a different context.
-         * We can't rely on the closeListeners to abort the operation if the tab is closed.
-         */
-        const db = await withAbort(() => remote(this.syncParams!.dbParams), abortController.signal).finally(() => {
-          // We can remove the close listener here since we no longer need it past this point.
-          removeCloseListener();
-        });
+    const workerPort = await withAbort({
+      action: () => client.clientProvider.getDBWorkerPort(),
+      signal: abortController.signal,
+      cleanupOnAbort: (port) => {
+        port.close();
+      }
+    }).catch((ex) => {
+      removeCloseListener();
+      throw ex;
+    });
 
-        clearTimeout(timeout);
+    const remote = Comlink.wrap<OpenAsyncDatabaseConnection>(workerPort);
+    const identifier = this.syncParams!.dbParams.dbFilename;
+
+    /**
+     * The open could fail if the tab is closed while we're busy opening the database.
+     * This operation is typically executed inside an exclusive portMutex lock.
+     * We typically execute the closeListeners using the portMutex in a different context.
+     * We can't rely on the closeListeners to abort the operation if the tab is closed.
+     */
+    const db = await withAbort({
+      action: () => remote(this.syncParams!.dbParams),
+      signal: abortController.signal,
+      cleanupOnAbort: (db) => {
+        db.close();
+      }
+    }).finally(() => {
+      // We can remove the close listener here since we no longer need it past this point.
+      removeCloseListener();
+    });
 
-        const wrapped = new WorkerWrappedAsyncDatabaseConnection({
-          remote,
-          baseConnection: db,
-          identifier,
-          // It's possible for this worker to outlive the client hosting the database for us. We need to be prepared for
-          // that and ensure pending requests are aborted when the tab is closed.
-          remoteCanCloseUnexpectedly: true
-        });
-        client.closeListeners.push(async () => {
-          this.logger.info('Aborting open connection because associated tab closed.');
-          /**
-           * Don't await this close operation. It might never resolve if the tab is closed.
-           * We mark the remote as closed first, this will reject any pending requests.
-           * We then call close. The close operation is configured to fire-and-forget, the main promise will reject immediately.
-           */
-          wrapped.markRemoteClosed();
-          wrapped.close().catch((ex) => this.logger.warn('error closing database connection', ex));
-        });
+    clearTimeout(timeout);
 
-        return wrapped;
-      } catch (ex) {
-        this.logger.warn('Error opening internal DB', ex);
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-      }
-    }
+    const wrapped = new WorkerWrappedAsyncDatabaseConnection({
+      remote,
+      baseConnection: db,
+      identifier,
+      // It's possible for this worker to outlive the client hosting the database for us. We need to be prepared for
+      // that and ensure pending requests are aborted when the tab is closed.
+      remoteCanCloseUnexpectedly: true
+    });
+    client.closeListeners.push(async () => {
+      this.logger.info('Aborting open connection because associated tab closed.');
+      /**
+       * Don't await this close operation. It might never resolve if the tab is closed.
+       * We mark the remote as closed first, this will reject any pending requests.
+       * We then call close. The close operation is configured to fire-and-forget, the main promise will reject immediately.
+       */
+      wrapped.markRemoteClosed();
+      wrapped.close().catch((ex) => this.logger.warn('error closing database connection', ex));
+    });
+
+    return wrapped;
   }
 
   /**
@@ -588,7 +592,12 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
 /**
  * Runs the action with an abort controller.
  */
-function withAbort<T>(action: () => Promise<T>, signal: AbortSignal): Promise<T> {
+function withAbort<T>(options: {
+  action: () => Promise<T>;
+  signal: AbortSignal;
+  cleanupOnAbort?: (result: T) => void;
+}): Promise<T> {
+  const { action, signal, cleanupOnAbort } = options;
   return new Promise((resolve, reject) => {
     if (signal.aborted) {
       reject(new AbortOperation('Operation aborted by abort controller'));
@@ -608,7 +617,13 @@ function withAbort<T>(action: () => Promise<T>, signal: AbortSignal): Promise<T>
     }
 
     action()
-      .then((data) => completePromise(() => resolve(data)))
+      .then((data) => {
+        // We already rejected due to the abort, allow for cleanup
+        if (signal.aborted) {
+          return completePromise(() => cleanupOnAbort?.(data));
+        }
+        completePromise(() => resolve(data));
+      })
       .catch((e) => completePromise(() => reject(e)));
   });
 }

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

@@ -1,2 +0,0 @@
-export * from './MockSyncServiceTypes';
-export * from './MockSyncServiceWorker';

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

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

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

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

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

@@ -1 +0,0 @@
-export {};

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

@@ -1,56 +0,0 @@
-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;