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

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

@@ -20,6 +20,7 @@ const OPEN_DB_LOCK = 'open-wasqlite-db';
 let nextClientId = 1;
 
 const openDBShared = async (options: WorkerDBOpenerOptions): Promise<AsyncDatabaseConnection> => {
+  // Prevent multiple simultaneous opens from causing race conditions
   return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
     const clientId = nextClientId++;
     const { dbFilename, logLevel } = options;

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,94 +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({
-          action: () => client.clientProvider.getDBWorkerPort(),
-          signal: abortController.signal,
-          cleanupOnAbort: (port) => {
-            port.close();
-          }
-        }).catch((ex) => {
-          removeCloseListener();
-          throw ex;
-        });
+    const workerPort = await withAbort({
+      action: () => client.clientProvider.getDBWorkerPort(),
+      signal: abortController.signal,
+      cleanupOnAbort: (port) => {
+        port.close();
+      }
+    }).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({
-          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 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();
+    });
 
-        clearTimeout(timeout);
+    clearTimeout(timeout);
 
-        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));
-        });
+    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;
-      } catch (ex) {
-        this.logger.warn('Error opening internal DB', ex);
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-      }
-    }
+    return wrapped;
   }
 
   /**

package/lib/src/worker/db/opfs.d.ts

@@ -1,96 +0,0 @@
-import { FacadeVFS } from '@journeyapps/wa-sqlite/src/FacadeVFS.js';
-export declare class OPFSCoopSyncVFS extends FacadeVFS {
-    #private;
-    /** @type {Map<number, File>} */ mapIdToFile: Map<any, any>;
-    lastError: null;
-    log: null;
-    /** @type {Map<string, PersistentFile>} */ persistentFiles: Map<any, any>;
-    /** @type {Map<string, FileSystemSyncAccessHandle>} */ boundAccessHandles: Map<any, any>;
-    /** @type {Set<FileSystemSyncAccessHandle>} */ unboundAccessHandles: Set<unknown>;
-    /** @type {Set<string>} */ accessiblePaths: Set<unknown>;
-    releaser: null;
-    static create(name: any, module: any): Promise<OPFSCoopSyncVFS>;
-    constructor(name: any, module: any);
-    /**
-     * @param {string?} zName
-     * @param {number} fileId
-     * @param {number} flags
-     * @param {DataView} pOutFlags
-     * @returns {number}
-     */
-    jOpen(zName: any, fileId: any, flags: any, pOutFlags: any): 0 | 5 | 14;
-    /**
-     * @param {string} zName
-     * @param {number} syncDir
-     * @returns {number}
-     */
-    jDelete(zName: any, syncDir: any): 0 | 2570;
-    /**
-     * @param {string} zName
-     * @param {number} flags
-     * @param {DataView} pResOut
-     * @returns {number}
-     */
-    jAccess(zName: any, flags: any, pResOut: any): 0 | 3338;
-    /**
-     * @param {number} fileId
-     * @returns {number}
-     */
-    jClose(fileId: any): 0 | 4106;
-    /**
-     * @param {number} fileId
-     * @param {Uint8Array} pData
-     * @param {number} iOffset
-     * @returns {number}
-     */
-    jRead(fileId: any, pData: any, iOffset: any): 0 | 522 | 266;
-    /**
-     * @param {number} fileId
-     * @param {Uint8Array} pData
-     * @param {number} iOffset
-     * @returns {number}
-     */
-    jWrite(fileId: any, pData: any, iOffset: any): 0 | 778;
-    /**
-     * @param {number} fileId
-     * @param {number} iSize
-     * @returns {number}
-     */
-    jTruncate(fileId: any, iSize: any): 0 | 1546;
-    /**
-     * @param {number} fileId
-     * @param {number} flags
-     * @returns {number}
-     */
-    jSync(fileId: any, flags: any): 0 | 1034;
-    /**
-     * @param {number} fileId
-     * @param {DataView} pSize64
-     * @returns {number}
-     */
-    jFileSize(fileId: any, pSize64: any): 0 | 1802;
-    /**
-     * @param {number} fileId
-     * @param {number} lockType
-     * @returns {number}
-     */
-    jLock(fileId: any, lockType: any): 0 | 5;
-    /**
-     * @param {number} fileId
-     * @param {number} lockType
-     * @returns {number}
-     */
-    jUnlock(fileId: any, lockType: any): 0;
-    /**
-     * @param {number} fileId
-     * @param {number} op
-     * @param {DataView} pArg
-     * @returns {number|Promise<number>}
-     */
-    jFileControl(fileId: any, op: any, pArg: any): 10 | 12;
-    /**
-     * @param {Uint8Array} zBuf
-     * @returns
-     */
-    jGetLastError(zBuf: any): 0;
-}