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

package/src/worker/sync/SharedSyncImplementation.ts

@@ -17,18 +17,18 @@ import {
 } from '@powersync/common';
 import { Mutex } from 'async-mutex';
 import * as Comlink from 'comlink';
-import { WebRemote } from '../../db/sync/WebRemote';
+import { WebRemote } from '../../db/sync/WebRemote.js';
 import {
   WebStreamingSyncImplementation,
   WebStreamingSyncImplementationOptions
-} from '../../db/sync/WebStreamingSyncImplementation';
+} from '../../db/sync/WebStreamingSyncImplementation.js';
 
-import { OpenAsyncDatabaseConnection } from '../../db/adapters/AsyncDatabaseConnection';
-import { LockedAsyncDatabaseAdapter } from '../../db/adapters/LockedAsyncDatabaseAdapter';
-import { WorkerWrappedAsyncDatabaseConnection } from '../../db/adapters/WorkerWrappedAsyncDatabaseConnection';
-import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags';
-import { AbstractSharedSyncClientProvider } from './AbstractSharedSyncClientProvider';
-import { BroadcastLogger } from './BroadcastLogger';
+import { OpenAsyncDatabaseConnection } from '../../db/adapters/AsyncDatabaseConnection.js';
+import { LockedAsyncDatabaseAdapter } from '../../db/adapters/LockedAsyncDatabaseAdapter.js';
+import { WorkerWrappedAsyncDatabaseConnection } from '../../db/adapters/WorkerWrappedAsyncDatabaseConnection.js';
+import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags.js';
+import { AbstractSharedSyncClientProvider } from './AbstractSharedSyncClientProvider.js';
+import { BroadcastLogger } from './BroadcastLogger.js';
 
 /**
  * @internal
@@ -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)];
     });
   }
 
@@ -276,6 +277,15 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
         // We may have missed some table updates while the database was closed.
         // We can poke the crud in case we missed any updates.
         this.connectionManager.syncStreamImplementation?.triggerCrudUpload();
+
+        /**
+         * FIXME or IMPROVE ME
+         * The Rust client implementation stores sync state on the connection level.
+         * Reopening the database causes a state machine error which should cause the
+         * StreamingSyncImplementation to reconnect. It would be nicer if we could trigger
+         * this reconnect earlier.
+         * This reconnect is not required for IndexedDB.
+         */
       }
     });
 
@@ -495,94 +505,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.`);
-        }
-
-        // 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 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 removeCloseListener = () => {
-          const index = client.closeListeners.indexOf(closeListener);
-          if (index >= 0) {
-            client.closeListeners.splice(index, 1);
-          }
-        };
+    // 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();
+    };
 
-        client.closeListeners.push(closeListener);
+    const removeCloseListener = () => {
+      const index = client.closeListeners.indexOf(closeListener);
+      if (index >= 0) {
+        client.closeListeners.splice(index, 1);
+      }
+    };
 
-        const workerPort = await withAbort({
-          action: () => client.clientProvider.getDBWorkerPort(),
-          signal: abortController.signal,
-          cleanupOnAbort: (port) => {
-            port.close();
-          }
-        }).catch((ex) => {
-          removeCloseListener();
-          throw ex;
-        });
+    client.closeListeners.push(closeListener);
 
-        const remote = Comlink.wrap<OpenAsyncDatabaseConnection>(workerPort);
-        const identifier = this.syncParams!.dbParams.dbFilename;
+    const workerPort = await withAbort({
+      action: () => client.clientProvider.getDBWorkerPort(),
+      signal: abortController.signal,
+      cleanupOnAbort: (port) => {
+        port.close();
+      }
+    }).catch((ex) => {
+      removeCloseListener();
+      throw ex;
+    });
 
-        /**
-         * 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/src/worker/sync/SharedSyncImplementation.worker.ts

@@ -1,6 +1,6 @@
 import { createBaseLogger } from '@powersync/common';
-import { SharedSyncImplementation } from './SharedSyncImplementation';
-import { WorkerClient } from './WorkerClient';
+import { SharedSyncImplementation } from './SharedSyncImplementation.js';
+import { WorkerClient } from './WorkerClient.js';
 
 const _self: SharedWorkerGlobalScope = self as any;
 const logger = createBaseLogger();

package/src/worker/sync/WorkerClient.ts

@@ -1,13 +1,13 @@
 import { ILogLevel, PowerSyncConnectionOptions, SubscribedStream } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { getNavigatorLocks } from '../../shared/navigator';
+import { getNavigatorLocks } from '../../shared/navigator.js';
 import {
   ManualSharedSyncPayload,
   SharedSyncClientEvent,
   SharedSyncImplementation,
   SharedSyncInitOptions,
   WrappedSyncPort
-} from './SharedSyncImplementation';
+} from './SharedSyncImplementation.js';
 
 /**
  * A client to the shared sync worker.

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;
-}