@powersync/web 0.0.0-dev-20260311103504 → 0.0.0-dev-20260503073249

package/lib/src/worker/db/WASQLiteDB.worker.js

@@ -4,66 +4,27 @@
 import '@journeyapps/wa-sqlite';
 import { createBaseLogger, createLogger } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { getNavigatorLocks } from '../../shared/navigator.js';
-import { SharedWASQLiteConnection } from './SharedWASQLiteConnection.js';
-import { WorkerWASQLiteConnection } from './WorkerWASQLiteConnection.js';
+import { isSharedWorker, MultiDatabaseServer } from './MultiDatabaseServer.js';
 const baseLogger = createBaseLogger();
 baseLogger.useDefaults();
 const logger = createLogger('db-worker');
-const DBMap = new Map();
-const OPEN_DB_LOCK = 'open-wasqlite-db';
-let nextClientId = 1;
-const openDBShared = async (options) => {
-    // Prevent multiple simultaneous opens from causing race conditions
-    return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
-        const clientId = nextClientId++;
-        const { dbFilename, logLevel } = options;
-        logger.setLevel(logLevel);
-        if (!DBMap.has(dbFilename)) {
-            const clientIds = new Set();
-            // This format returns proxy objects for function callbacks
-            const connection = new WorkerWASQLiteConnection(options);
-            await connection.init();
-            connection.registerListener({
-                holdOverwritten: async () => {
-                    /**
-                     * The previous hold has been overwritten, without being released.
-                     * we need to cleanup any resources associated with it.
-                     * We can perform a rollback to release any potential transactions that were started.
-                     */
-                    await connection.execute('ROLLBACK').catch(() => { });
-                }
-            });
-            DBMap.set(dbFilename, {
-                clientIds,
-                db: connection
-            });
-        }
-        // Associates this clientId with the shared connection entry
-        const sharedConnection = new SharedWASQLiteConnection({
-            dbMap: DBMap,
-            dbFilename,
-            clientId,
-            logger
-        });
-        return Comlink.proxy(sharedConnection);
-    });
+const server = new MultiDatabaseServer(logger);
+const exposedFunctions = {
+    connect: (config) => server.handleConnection(config),
+    connectToExisting: ({ identifier, lockName }) => server.connectToExisting(identifier, lockName)
 };
 // Check if we're in a SharedWorker context
-if (typeof SharedWorkerGlobalScope !== 'undefined') {
+if (isSharedWorker) {
     const _self = self;
     _self.onconnect = function (event) {
         const port = event.ports[0];
-        Comlink.expose(openDBShared, port);
+        Comlink.expose(exposedFunctions, port);
     };
 }
 else {
     // A dedicated worker can be shared externally
-    Comlink.expose(openDBShared);
+    Comlink.expose(exposedFunctions);
 }
 addEventListener('unload', () => {
-    Array.from(DBMap.values()).forEach(async (dbConnection) => {
-        const { db } = dbConnection;
-        db.close?.();
-    });
+    server.closeAll();
 });

package/lib/src/worker/db/open-worker-database.d.ts

@@ -1,6 +1,6 @@
 import * as Comlink from 'comlink';
-import { OpenAsyncDatabaseConnection } from '../../db/adapters/AsyncDatabaseConnection.js';
-import { WASQLiteVFS } from '../../db/adapters/wa-sqlite/WASQLiteConnection.js';
+import { WASQLiteVFS } from '../../db/adapters/wa-sqlite/vfs.js';
+import { OpenWorkerConnection } from '../../db/adapters/wa-sqlite/DatabaseClient.js';
 /**
  * Opens a shared or dedicated worker which exposes opening of database connections
  */
@@ -9,6 +9,6 @@ export declare function openWorkerDatabasePort(workerIdentifier: string, multipl
  * @returns A function which allows for opening database connections inside
  * a worker.
  */
-export declare function getWorkerDatabaseOpener(workerIdentifier: string, multipleTabs?: boolean, worker?: string | URL): Comlink.Remote<OpenAsyncDatabaseConnection>;
+export declare function getWorkerDatabaseOpener(workerIdentifier: string, multipleTabs?: boolean, worker?: string | URL): Comlink.Remote<OpenWorkerConnection>;
 export declare function resolveWorkerDatabasePortFactory(worker: () => Worker | SharedWorker): Worker | MessagePort;
 export declare function isSharedWorker(worker: Worker | SharedWorker): worker is SharedWorker;

package/lib/src/worker/db/open-worker-database.js

@@ -1,10 +1,10 @@
 import * as Comlink from 'comlink';
-import { WASQLiteVFS } from '../../db/adapters/wa-sqlite/WASQLiteConnection.js';
+import { vfsRequiresDedicatedWorkers } from '../../db/adapters/wa-sqlite/vfs.js';
 /**
  * Opens a shared or dedicated worker which exposes opening of database connections
  */
 export function openWorkerDatabasePort(workerIdentifier, multipleTabs = true, worker = '', vfs) {
-    const needsDedicated = vfs == WASQLiteVFS.AccessHandlePoolVFS || vfs == WASQLiteVFS.OPFSCoopSyncVFS;
+    const needsDedicated = vfs && vfsRequiresDedicatedWorkers(vfs);
     if (worker) {
         return !needsDedicated && multipleTabs
             ? new SharedWorker(`${worker}`, {

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

@@ -1,8 +1,6 @@
-import { BaseObserver, ConnectionManager, DBAdapter, SubscribedStream, SyncStatus, type ILogLevel, type ILogger, type PowerSyncConnectionOptions, type StreamingSyncImplementation, type StreamingSyncImplementationListener, type SyncStatusOptions } from '@powersync/common';
-import { Mutex } from 'async-mutex';
+import { BaseObserver, ConnectionManager, DBAdapter, SubscribedStream, SyncStatus, Mutex, type ILogLevel, type ILogger, type PowerSyncConnectionOptions, type StreamingSyncImplementation, type StreamingSyncImplementationListener, type SyncStatusOptions } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions } from '../../db/sync/WebStreamingSyncImplementation.js';
-import { WorkerWrappedAsyncDatabaseConnection } from '../../db/adapters/WorkerWrappedAsyncDatabaseConnection.js';
 import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags.js';
 import { AbstractSharedSyncClientProvider } from './AbstractSharedSyncClientProvider.js';
 /**
@@ -73,7 +71,7 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
     protected connectionManager: ConnectionManager;
     syncStatus: SyncStatus;
     broadCastLogger: ILogger;
-    protected distributedDB: DBAdapter | null;
+    protected readonly database: DBAdapter;
     constructor();
     get lastSyncedAt(): Date | undefined;
     get isConnected(): boolean;
@@ -126,9 +124,10 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
     protected withSyncImplementation<T>(callback: (sync: StreamingSyncImplementation) => Promise<T>): Promise<T>;
     protected generateStreamingImplementation(): WebStreamingSyncImplementation;
     /**
-     * Opens a worker wrapped database connection. Using the last connected client port.
+     * Requests a random client to share its database connection with us.
      */
-    protected openInternalDB(): Promise<WorkerWrappedAsyncDatabaseConnection<ResolvedWebSQLOpenOptions>>;
+    private openInternalDB;
+    private generateReconnectableDatabase;
     /**
      * A method to update the all shared statuses for each
      * client.

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,82 @@ 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();
+                    // The Rust client implementation stores sync state on the connection level. Reopening the database causes a
+                    // disruption of the connection state and forces us to reconnect. We want to do that as soon as possible to
+                    // minimize downtime.
+                    impl?.markConnectionMayHaveChanged();
+                }
+            }
+            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