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

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';
@@ -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) {
@@ -115,27 +113,70 @@ export class LockedAsyncDatabaseAdapter
   }
 
   protected async openInternalDB() {
-    // Dispose any previous table change listener.
-    this._disposeTableChangeListener?.();
-    this._disposeTableChangeListener = null;
+    /**
+     * Execute opening of the db in a lock in order not to interfere with other operations.
+     */
+    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;
+    });
+  }
 
-    const isReOpen = !!this._db;
+  protected _reOpen() {
+    this.databaseOpenPromise = this.openInternalDB().finally(() => {
+      this.databaseOpenPromise = null;
+    });
+    return this.databaseOpenPromise;
+  }
 
-    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?.());
+  /**
+   * 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`);
     }
-    /**
-     * This is only required for the long-lived shared IndexedDB connections.
-     */
-    this.requiresHolds = (this._config as ResolvedWASQLiteOpenFactoryOptions).vfs == WASQLiteVFS.IDBBatchAtomicVFS;
+    if (this.databaseOpenPromise) {
+      return this.databaseOpenPromise;
+    }
+    return this._reOpen();
   }
 
   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?.());
   }
 
@@ -233,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 ?? {};
@@ -259,39 +297,41 @@ 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.databaseOpenPromise = this.openInternalDB().finally(() => {
-                this.databaseOpenPromise = null;
-              });
-            }
-          }
-          throw ex;
-        } finally {
-          if (holdId) {
-            await this.baseDB.releaseHold(holdId);
+  protected async acquireLock(callback: () => Promise<any>, options?: { timeoutMs?: number }): Promise<any> {
+    await this.waitForInitialized();
+
+    return this._acquireLock(async () => {
+      let holdId: string | null = null;
+      try {
+        // The database is being opened in the background. Wait for it here.
+        if (this.databaseOpenPromise) {
+          /**
+           * We can't await this since it uses the same lock as we're in now.
+           */
+          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 || (ex instanceof Error && ex.name === 'NoModificationAllowedError')) {
+          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);
+        }
       }
-    );
+    }, options);
   }
 
   async readTransaction<T>(fn: (tx: Transaction) => Promise<T>, options?: DBLockOptions | undefined): Promise<T> {

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/adapters/wa-sqlite/WASQLiteConnection.ts

@@ -1,9 +1,9 @@
 import * as SQLite from '@journeyapps/wa-sqlite';
 import { BaseObserver, BatchedUpdateNotification } from '@powersync/common';
 import { Mutex } from 'async-mutex';
+import { OPFSCoopSyncVFS } from '../../../worker/db/opfs';
 import { AsyncDatabaseConnection, OnTableChangeCallback, ProxiedQueryResult } from '../AsyncDatabaseConnection';
 import { ResolvedWASQLiteOpenFactoryOptions } from './WASQLiteOpenFactory';
-
 /**
  * List of currently tested virtual filesystems
  */
@@ -124,11 +124,10 @@ export const DEFAULT_MODULE_FACTORIES = {
     } else {
       module = await SyncWASQLiteModuleFactory();
     }
-    // @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: vfs as any
     };
   }
 };

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/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/db/WASQLiteDB.worker.ts

@@ -17,11 +17,9 @@ 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> => {
-  // Prevent multiple simultaneous opens from causing race conditions
   return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
     const clientId = nextClientId++;
     const { dbFilename, logLevel } = options;