@powersync/web 1.36.0 → 1.37.0

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

@@ -1,11 +1,10 @@
-import { AbortOperation, BaseObserver, ConnectionManager, SqliteBucketStorage, SyncStatus, createLogger } from '@powersync/common';
-import { Mutex } from 'async-mutex';
+import { AbortOperation, BaseObserver, ConnectionManager, DBAdapterDefaultMixin, SqliteBucketStorage, SyncStatus, createLogger, Mutex } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { WebRemote } from '../../db/sync/WebRemote.js';
 import { WebStreamingSyncImplementation } from '../../db/sync/WebStreamingSyncImplementation.js';
-import { LockedAsyncDatabaseAdapter } from '../../db/adapters/LockedAsyncDatabaseAdapter.js';
-import { WorkerWrappedAsyncDatabaseConnection } from '../../db/adapters/WorkerWrappedAsyncDatabaseConnection.js';
 import { BroadcastLogger } from './BroadcastLogger.js';
+import { DatabaseClient } from '../../db/adapters/wa-sqlite/DatabaseClient.js';
+import { generateTabCloseSignal } from '../../shared/tab_close_signal.js';
 /**
  * @internal
  * Manual message events for shared sync clients
@@ -43,7 +42,7 @@ export class SharedSyncImplementation extends BaseObserver {
     connectionManager;
     syncStatus;
     broadCastLogger;
-    distributedDB;
+    database = this.generateReconnectableDatabase();
     constructor() {
         super();
         this.ports = [];
@@ -59,8 +58,6 @@ export class SharedSyncImplementation extends BaseObserver {
                 }
             });
         });
-        // Should be configured once we get params
-        this.distributedDB = null;
         this.syncStatus = new SyncStatus({});
         this.broadCastLogger = new BroadcastLogger(this.ports);
         this.connectionManager = new ConnectionManager({
@@ -160,38 +157,8 @@ export class SharedSyncImplementation extends BaseObserver {
         if (params.streamOptions?.flags?.broadcastLogs) {
             this.logger = this.broadCastLogger;
         }
-        const lockedAdapter = new LockedAsyncDatabaseAdapter({
-            name: params.dbParams.dbFilename,
-            openConnection: async () => {
-                // Gets a connection from the clients when a new connection is requested.
-                const db = await this.openInternalDB();
-                db.registerListener({
-                    closing: () => {
-                        lockedAdapter.reOpenInternalDB();
-                    }
-                });
-                return db;
-            },
-            logger: this.logger,
-            reOpenOnConnectionClosed: true
-        });
-        this.distributedDB = lockedAdapter;
-        await lockedAdapter.init();
-        lockedAdapter.registerListener({
-            databaseReOpened: () => {
-                // 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.
-                 */
-            }
-        });
+        // Ensure we have a usable database connection, the reconnectable database will connect lazily on first use.
+        await this.database.readLock(async () => { });
         self.onerror = (event) => {
             // Share any uncaught events on the broadcast logger
             this.logger.error('Uncaught exception in PowerSync shared sync worker', event);
@@ -308,7 +275,7 @@ export class SharedSyncImplementation extends BaseObserver {
         const syncParams = this.syncParams;
         // Create a new StreamingSyncImplementation for each connect call. This is usually done is all SDKs.
         return new WebStreamingSyncImplementation({
-            adapter: new SqliteBucketStorage(this.distributedDB, this.logger),
+            adapter: new SqliteBucketStorage(this.database, this.logger),
             remote: new WebRemote({
                 invalidateCredentials: async () => {
                     const lastPort = await this.getLastWrappedPort();
@@ -379,9 +346,9 @@ export class SharedSyncImplementation extends BaseObserver {
         });
     }
     /**
-     * Opens a worker wrapped database connection. Using the last connected client port.
+     * Requests a random client to share its database connection with us.
      */
-    async openInternalDB() {
+    async openInternalDB(handleClosed) {
         const client = await this.getRandomWrappedPort();
         if (!client) {
             // Should not really happen in practice
@@ -417,6 +384,7 @@ export class SharedSyncImplementation extends BaseObserver {
         });
         const remote = Comlink.wrap(workerPort);
         const identifier = this.syncParams.dbParams.dbFilename;
+        const clientLockName = await generateTabCloseSignal();
         /**
          * 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.
@@ -424,7 +392,16 @@ export class SharedSyncImplementation extends BaseObserver {
          * 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),
+            action: async () => {
+                const clientView = await remote.connectToExisting({ identifier, lockName: clientLockName });
+                return new DatabaseClient({
+                    connection: clientView,
+                    source: remote,
+                    // 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
+                }, this.syncParams.dbParams);
+            },
             signal: abortController.signal,
             cleanupOnAbort: (db) => {
                 db.close();
@@ -434,25 +411,86 @@ export class SharedSyncImplementation extends BaseObserver {
             removeCloseListener();
         });
         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.');
+            handleClosed(db);
             /**
              * 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));
+            db.markRemoteClosed();
+            db.close().catch((ex) => this.logger.warn('error closing database connection', ex));
         });
-        return wrapped;
+        return db;
+    }
+    generateReconnectableDatabase() {
+        const syncParams = this.syncParams;
+        const sharedSync = this;
+        class ReconnectPool extends BaseObserver {
+            connectionState = null;
+            get name() {
+                return syncParams?.dbParams.dbFilename;
+            }
+            async connect() {
+                if (this.connectionState == null) {
+                    const handleClosed = this.handleClientClosed.bind(this);
+                    this.connectionState = (async () => {
+                        try {
+                            const db = await sharedSync.openInternalDB(handleClosed);
+                            db.registerListener({
+                                tablesUpdated: (notification) => {
+                                    this.iterateListeners((l) => l.tablesUpdated?.(notification));
+                                }
+                            });
+                            this.connectionState = db;
+                            return db;
+                        }
+                        catch (e) {
+                            // Allow reconnecting when the database is used again.
+                            this.connectionState = null;
+                            throw e;
+                        }
+                    })();
+                }
+                return await this.connectionState;
+            }
+            async close() {
+                if (this.connectionState != null) {
+                    await (await this.connectionState).close();
+                }
+            }
+            handleClientClosed(client) {
+                if (client === this.connectionState) {
+                    this.connectionState = null;
+                    // We may have missed some table updates while the database was closed.
+                    // We can poke the crud in case we missed any updates.
+                    const impl = sharedSync.connectionManager.syncStreamImplementation;
+                    impl?.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.
+                     */
+                }
+            }
+            async readLock(fn, options) {
+                const db = await this.connect();
+                return db.readLock(fn, options);
+            }
+            async writeLock(fn, options) {
+                const db = await this.connect();
+                return db.writeLock(fn, options);
+            }
+            async refreshSchema() {
+                // Not used by sync client.
+            }
+        }
+        const Adapter = DBAdapterDefaultMixin(ReconnectPool);
+        return new Adapter();
     }
     /**
      * A method to update the all shared statuses for each