@powersync/web 0.0.0-dev-20250528152729 → 0.0.0-dev-20250529141956

package/lib/src/db/PowerSyncDatabase.d.ts

@@ -69,7 +69,6 @@ export declare class PowerSyncDatabase extends AbstractPowerSyncDatabase {
      * multiple tabs are not enabled.
      */
     close(options?: PowerSyncCloseOptions): Promise<void>;
-    protected connectExclusive(callback: () => Promise<void>): Promise<void>;
     protected generateBucketStorageAdapter(): BucketStorageAdapter;
     protected runExclusive<T>(cb: () => Promise<T>): Promise<any>;
     protected generateSyncStreamImplementation(connector: PowerSyncBackendConnector, options: RequiredAdditionalConnectionOptions): StreamingSyncImplementation;

package/lib/src/db/PowerSyncDatabase.js

@@ -81,9 +81,6 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
             disconnect: options.disconnect ?? !this.resolvedFlags.enableMultiTabs
         });
     }
-    async connectExclusive(callback) {
-        await this.runExclusive(callback);
-    }
     generateBucketStorageAdapter() {
         return new SqliteBucketStorage(this.database, AbstractPowerSyncDatabase.transactionMutex);
     }

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

@@ -5,6 +5,7 @@ import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions }
 import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags';
 import { AbstractSharedSyncClientProvider } from './AbstractSharedSyncClientProvider';
 /**
+ * @internal
  * Manual message events for shared sync clients
  */
 export declare enum SharedSyncClientEvent {
@@ -15,6 +16,9 @@ export declare enum SharedSyncClientEvent {
     CLOSE_CLIENT = "close-client",
     CLOSE_ACK = "close-ack"
 }
+/**
+ * @internal
+ */
 export type ManualSharedSyncPayload = {
     event: SharedSyncClientEvent;
     data: any;
@@ -93,7 +97,7 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
      * Removes a message port client from this manager's managed
      * clients.
      */
-    removePort(port: MessagePort): Promise<(() => void) | undefined>;
+    removePort(port: MessagePort): Promise<() => void>;
     triggerCrudUpload(): void;
     hasCompletedSync(): Promise<boolean>;
     getWriteCheckpoint(): Promise<string>;

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

@@ -7,6 +7,7 @@ import { LockedAsyncDatabaseAdapter } from '../../db/adapters/LockedAsyncDatabas
 import { WorkerWrappedAsyncDatabaseConnection } from '../../db/adapters/WorkerWrappedAsyncDatabaseConnection';
 import { BroadcastLogger } from './BroadcastLogger';
 /**
+ * @internal
  * Manual message events for shared sync clients
  */
 export var SharedSyncClientEvent;
@@ -61,21 +62,23 @@ export class SharedSyncImplementation extends BaseObserver {
         this.syncStatus = new SyncStatus({});
         this.broadCastLogger = new BroadcastLogger(this.ports);
         this.connectionManager = new ConnectionManager({
-            createSyncImplementation: async (connector, options) => {
-                await this.waitForReady();
-                if (!this.dbAdapter) {
-                    await this.openInternalDB();
-                }
-                const sync = this.generateStreamingImplementation();
-                const onDispose = sync.registerListener({
-                    statusChanged: (status) => {
-                        this.updateAllStatuses(status.toJSON());
+            createSyncImplementation: async () => {
+                return this.portMutex.runExclusive(async () => {
+                    await this.waitForReady();
+                    if (!this.dbAdapter) {
+                        await this.openInternalDB();
                     }
+                    const sync = this.generateStreamingImplementation();
+                    const onDispose = sync.registerListener({
+                        statusChanged: (status) => {
+                            this.updateAllStatuses(status.toJSON());
+                        }
+                    });
+                    return {
+                        sync,
+                        onDispose
+                    };
                 });
-                return {
-                    sync,
-                    onDispose
-                };
             },
             logger: this.logger
         });
@@ -109,12 +112,14 @@ export class SharedSyncImplementation extends BaseObserver {
     async setParams(params) {
         await this.portMutex.runExclusive(async () => {
             if (this.syncParams) {
+                // Cannot modify already existing sync implementation params
+                // But we can ask for a DB adapter, if required, at this point.
                 if (!this.dbAdapter) {
                     await this.openInternalDB();
                 }
-                // Cannot modify already existing sync implementation
                 return;
             }
+            // First time setting params
             this.syncParams = params;
             if (params.streamOptions?.flags?.broadcastLogs) {
                 this.logger = this.broadCastLogger;
@@ -141,16 +146,11 @@ export class SharedSyncImplementation extends BaseObserver {
      * connects.
      */
     async connect(options) {
-        await this.portMutex.runExclusive(async () => {
-            // Keep track of the last connect options if we need to reconnect due to a lost client
-            this.lastConnectOptions = options;
-            return this.connectionManager.connect(CONNECTOR_PLACEHOLDER, options);
-        });
+        this.lastConnectOptions = options;
+        return this.connectionManager.connect(CONNECTOR_PLACEHOLDER, options);
     }
     async disconnect() {
-        await this.portMutex.runExclusive(async () => {
-            await this.connectionManager.disconnect();
-        });
+        return this.connectionManager.disconnect();
     }
     /**
      * Adds a new client tab's message port to the list of connected ports
@@ -174,11 +174,14 @@ export class SharedSyncImplementation extends BaseObserver {
      * clients.
      */
     async removePort(port) {
-        return await this.portMutex.runExclusive(async () => {
+        // Remove the port within a mutex context.
+        // Warns if the port is not found. This should not happen in practice.
+        // We return early if the port is not found.
+        const { trackedPort, shouldReconnect } = await this.portMutex.runExclusive(async () => {
             const index = this.ports.findIndex((p) => p.port == port);
             if (index < 0) {
                 this.logger.warn(`Could not remove port ${port} since it is not present in active ports.`);
-                return;
+                return {};
             }
             const trackedPort = this.ports[index];
             // Remove from the list of active ports
@@ -193,26 +196,35 @@ export class SharedSyncImplementation extends BaseObserver {
                 }
             });
             const shouldReconnect = !!this.connectionManager.syncStreamImplementation && this.ports.length > 0;
-            if (this.dbAdapter && this.dbAdapter == trackedPort.db) {
-                if (shouldReconnect) {
-                    await this.connectionManager.disconnect();
-                }
-                // Clearing the adapter will result in a new one being opened in connect
-                this.dbAdapter = null;
-                if (shouldReconnect) {
-                    await this.connectionManager.connect(CONNECTOR_PLACEHOLDER, this.lastConnectOptions);
-                }
+            return {
+                shouldReconnect,
+                trackedPort
+            };
+        });
+        if (!trackedPort) {
+            // We could not find the port to remove
+            return () => { };
+        }
+        if (this.dbAdapter && this.dbAdapter == trackedPort.db) {
+            if (shouldReconnect) {
+                await this.connectionManager.disconnect();
             }
-            if (trackedPort.db) {
-                await trackedPort.db.close();
+            // Clearing the adapter will result in a new one being opened in connect
+            this.dbAdapter = null;
+            if (shouldReconnect) {
+                await this.connectionManager.connect(CONNECTOR_PLACEHOLDER, this.lastConnectOptions);
             }
-            this.logger.debug(`Port ${port} removed from shared sync implementation.`);
-            // Release proxy
-            return () => trackedPort.clientProvider[Comlink.releaseProxy]();
-        });
+        }
+        if (trackedPort.db) {
+            await trackedPort.db.close();
+        }
+        // Release proxy
+        return () => trackedPort.clientProvider[Comlink.releaseProxy]();
     }
     triggerCrudUpload() {
-        this.waitForReady().then(() => this.connectionManager.syncStreamImplementation?.triggerCrudUpload());
+        this.withSyncImplementation(async (sync) => {
+            sync.triggerCrudUpload();
+        });
     }
     async hasCompletedSync() {
         return this.withSyncImplementation(async (sync) => {
@@ -340,7 +352,7 @@ export class SharedSyncImplementation extends BaseObserver {
      * A function only used for unit tests which updates the internal
      * sync stream client and all tab client's sync status
      */
-    _testUpdateAllStatuses(status) {
+    async _testUpdateAllStatuses(status) {
         if (!this.connectionManager.syncStreamImplementation) {
             // This is just for testing purposes
             this.connectionManager.syncStreamImplementation = this.generateStreamingImplementation();