@powersync/common 0.0.0-dev-20250520135616 → 0.0.0-dev-20250526133243

package/lib/client/AbstractPowerSyncDatabase.d.ts

@@ -79,6 +79,10 @@ export interface PowerSyncCloseOptions {
      */
     disconnect?: boolean;
 }
+type StoredConnectionOptions = {
+    connector: PowerSyncBackendConnector;
+    options: PowerSyncConnectionOptions;
+};
 export declare const DEFAULT_POWERSYNC_CLOSE_OPTIONS: PowerSyncCloseOptions;
 export declare const DEFAULT_WATCH_THROTTLE_MS = 30;
 export declare const DEFAULT_POWERSYNC_DB_OPTIONS: {
@@ -121,6 +125,29 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
     protected _isReadyPromise: Promise<void>;
     protected _schema: Schema;
     private _database;
+    /**
+     * Tracks active connection attempts
+     */
+    protected connectingPromise: Promise<void> | null;
+    /**
+     * Tracks actively instantiating a streaming sync implementation.
+     */
+    protected syncStreamInitPromise: Promise<void> | null;
+    /**
+     * Active disconnect operation. Calling disconnect multiple times
+     * will resolve to the same operation.
+     */
+    protected disconnectingPromise: Promise<void> | null;
+    /**
+     * Tracks the last parameters supplied to `connect` calls.
+     * Calling `connect` multiple times in succession will result in:
+     * - 1 pending connection operation which will be aborted.
+     * - updating the last set of parameters while waiting for the pending
+     *   attempt to be aborted
+     * - internally connecting with the last set of parameters
+     */
+    protected pendingConnectionOptions: StoredConnectionOptions | null;
+    protected connectionMutex: Mutex;
     constructor(options: PowerSyncDatabaseOptionsWithDBAdapter);
     constructor(options: PowerSyncDatabaseOptionsWithOpenFactory);
     constructor(options: PowerSyncDatabaseOptionsWithSettings);
@@ -190,6 +217,12 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
      */
     init(): Promise<void>;
     resolvedConnectionOptions(options?: PowerSyncConnectionOptions): RequiredAdditionalConnectionOptions;
+    /**
+     * Locking mechanism for exclusively running critical portions of connect/disconnect operations.
+     * Locking here is mostly only important on web for multiple tab scenarios.
+     */
+    protected runExclusive<T>(callback: () => Promise<T>): Promise<T>;
+    protected connectInternal(): Promise<void>;
     /**
      * Connects to stream of events from the PowerSync instance.
      */
@@ -200,6 +233,8 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
      * Use {@link connect} to connect again.
      */
     disconnect(): Promise<void>;
+    protected disconnectInternal(): Promise<void>;
+    protected performDisconnect(): Promise<void>;
     /**
      *  Disconnect and clear the database.
      *  Use this when logging out.
@@ -484,3 +519,4 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
      */
     private executeReadOnly;
 }
+export {};

package/lib/client/AbstractPowerSyncDatabase.js

@@ -2,12 +2,13 @@ import { Mutex } from 'async-mutex';
 import { EventIterator } from 'event-iterator';
 import Logger from 'js-logger';
 import { isBatchedUpdateNotification } from '../db/DBAdapter.js';
+import { FULL_SYNC_PRIORITY } from '../db/crud/SyncProgress.js';
 import { SyncStatus } from '../db/crud/SyncStatus.js';
 import { UploadQueueStats } from '../db/crud/UploadQueueStatus.js';
 import { BaseObserver } from '../utils/BaseObserver.js';
 import { ControlledExecutor } from '../utils/ControlledExecutor.js';
-import { mutexRunExclusive } from '../utils/mutex.js';
 import { throttleTrailing } from '../utils/async.js';
+import { mutexRunExclusive } from '../utils/mutex.js';
 import { isDBAdapter, isSQLOpenFactory, isSQLOpenOptions } from './SQLOpenFactory.js';
 import { runOnSchemaChange } from './runOnSchemaChange.js';
 import { PSInternalTable } from './sync/bucket/BucketStorageAdapter.js';
@@ -15,7 +16,6 @@ import { CrudBatch } from './sync/bucket/CrudBatch.js';
 import { CrudEntry } from './sync/bucket/CrudEntry.js';
 import { CrudTransaction } from './sync/bucket/CrudTransaction.js';
 import { DEFAULT_CRUD_UPLOAD_THROTTLE_MS, DEFAULT_RETRY_DELAY_MS } from './sync/stream/AbstractStreamingSyncImplementation.js';
-import { FULL_SYNC_PRIORITY } from '../db/crud/SyncProgress.js';
 const POWERSYNC_TABLE_MATCH = /(^ps_data__|^ps_data_local__)/;
 const DEFAULT_DISCONNECT_CLEAR_OPTIONS = {
     clearLocal: true
@@ -66,6 +66,29 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
     _isReadyPromise;
     _schema;
     _database;
+    /**
+     * Tracks active connection attempts
+     */
+    connectingPromise;
+    /**
+     * Tracks actively instantiating a streaming sync implementation.
+     */
+    syncStreamInitPromise;
+    /**
+     * Active disconnect operation. Calling disconnect multiple times
+     * will resolve to the same operation.
+     */
+    disconnectingPromise;
+    /**
+     * Tracks the last parameters supplied to `connect` calls.
+     * Calling `connect` multiple times in succession will result in:
+     * - 1 pending connection operation which will be aborted.
+     * - updating the last set of parameters while waiting for the pending
+     *   attempt to be aborted
+     * - internally connecting with the last set of parameters
+     */
+    pendingConnectionOptions;
+    connectionMutex;
     constructor(options) {
         super();
         this.options = options;
@@ -92,6 +115,10 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
         this._schema = schema;
         this.ready = false;
         this.sdkVersion = '';
+        this.connectingPromise = null;
+        this.syncStreamInitPromise = null;
+        this.pendingConnectionOptions = null;
+        this.connectionMutex = new Mutex();
         // Start async init
         this._isReadyPromise = this.initialize();
     }
@@ -265,30 +292,100 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
             crudUploadThrottleMs: options?.crudUploadThrottleMs ?? this.options.crudUploadThrottleMs ?? DEFAULT_CRUD_UPLOAD_THROTTLE_MS
         };
     }
+    /**
+     * Locking mechanism for exclusively running critical portions of connect/disconnect operations.
+     * Locking here is mostly only important on web for multiple tab scenarios.
+     */
+    runExclusive(callback) {
+        return this.connectionMutex.runExclusive(callback);
+    }
+    async connectInternal() {
+        let appliedOptions = null;
+        // This method ensures a disconnect before any connection attempt
+        await this.disconnectInternal();
+        /**
+         * This portion creates a sync implementation which can be racy when disconnecting or
+         * if multiple tabs on web are in use.
+         * This is protected in an exclusive lock.
+         * The promise tracks the creation which is used to synchronize disconnect attempts.
+         */
+        this.syncStreamInitPromise = this.runExclusive(async () => {
+            if (this.closed) {
+                throw new Error('Cannot connect using a closed client');
+            }
+            // Always await this if present since we will be populating a new sync implementation shortly
+            await this.disconnectingPromise;
+            if (!this.pendingConnectionOptions) {
+                // A disconnect could have cleared this.
+                return;
+            }
+            // get pending options and clear it in order for other connect attempts to queue other options
+            const { connector, options } = this.pendingConnectionOptions;
+            appliedOptions = options;
+            this.pendingConnectionOptions = null;
+            this.syncStreamImplementation = this.generateSyncStreamImplementation(connector, this.resolvedConnectionOptions(options));
+            this.syncStatusListenerDisposer = this.syncStreamImplementation.registerListener({
+                statusChanged: (status) => {
+                    this.currentStatus = new SyncStatus({
+                        ...status.toJSON(),
+                        hasSynced: this.currentStatus?.hasSynced || !!status.lastSyncedAt
+                    });
+                    this.iterateListeners((cb) => cb.statusChanged?.(this.currentStatus));
+                }
+            });
+            await this.syncStreamImplementation.waitForReady();
+        });
+        await this.syncStreamInitPromise;
+        this.syncStreamInitPromise = null;
+        if (!appliedOptions) {
+            // A disconnect could have cleared the options which did not create a syncStreamImplementation
+            return;
+        }
+        // It might be possible that a disconnect triggered between the last check
+        // and this point. Awaiting here allows the sync stream to be cleared if disconnected.
+        await this.disconnectingPromise;
+        this.syncStreamImplementation?.triggerCrudUpload();
+        this.options.logger?.debug('Attempting to connect to PowerSync instance');
+        await this.syncStreamImplementation?.connect(appliedOptions);
+    }
     /**
      * Connects to stream of events from the PowerSync instance.
      */
     async connect(connector, options) {
+        // Keep track if there were pending operations before this call
+        const hadPendingOptions = !!this.pendingConnectionOptions;
+        // Update pending options to the latest values
+        this.pendingConnectionOptions = {
+            connector,
+            options: options ?? {}
+        };
         await this.waitForReady();
-        // close connection if one is open
-        await this.disconnect();
-        if (this.closed) {
-            throw new Error('Cannot connect using a closed client');
+        // Disconnecting here provides aborting in progress connection attempts.
+        // The connectInternal method will clear pending options once it starts connecting (with the options).
+        // We only need to trigger a disconnect here if we have already reached the point of connecting.
+        // If we do already have pending options, a disconnect has already been performed.
+        // The connectInternal method also does a sanity disconnect to prevent straggler connections.
+        if (!hadPendingOptions) {
+            await this.disconnectInternal();
         }
-        const resolvedConnectOptions = this.resolvedConnectionOptions(options);
-        this.syncStreamImplementation = this.generateSyncStreamImplementation(connector, resolvedConnectOptions);
-        this.syncStatusListenerDisposer = this.syncStreamImplementation.registerListener({
-            statusChanged: (status) => {
-                this.currentStatus = new SyncStatus({
-                    ...status.toJSON(),
-                    hasSynced: this.currentStatus?.hasSynced || !!status.lastSyncedAt
-                });
-                this.iterateListeners((cb) => cb.statusChanged?.(this.currentStatus));
+        // Triggers a connect which checks if pending options are available after the connect completes.
+        // The completion can be for a successful, unsuccessful or aborted connection attempt.
+        // If pending options are available another connection will be triggered.
+        const checkConnection = async () => {
+            if (this.pendingConnectionOptions) {
+                // Pending options have been placed while connecting.
+                // Need to reconnect.
+                this.connectingPromise = this.connectInternal().finally(checkConnection);
+                return this.connectingPromise;
             }
-        });
-        await this.syncStreamImplementation.waitForReady();
-        this.syncStreamImplementation.triggerCrudUpload();
-        await this.syncStreamImplementation.connect(options);
+            else {
+                // Clear the connecting promise, done.
+                this.connectingPromise = null;
+                return;
+            }
+        };
+        this.connectingPromise ??= this.connectInternal().finally(checkConnection);
+        return this.connectingPromise;
     }
     /**
      * Close the sync connection.
@@ -297,6 +394,23 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
      */
     async disconnect() {
         await this.waitForReady();
+        // This will help abort pending connects
+        this.pendingConnectionOptions = null;
+        await this.disconnectInternal();
+    }
+    async disconnectInternal() {
+        if (this.disconnectingPromise) {
+            // A disconnect is already in progress
+            return this.disconnectingPromise;
+        }
+        // Wait if a sync stream implementation is being created before closing it
+        // (syncStreamImplementation must be assigned before we can properly dispose it)
+        await this.syncStreamInitPromise;
+        this.disconnectingPromise = this.performDisconnect();
+        await this.disconnectingPromise;
+        this.disconnectingPromise = null;
+    }
+    async performDisconnect() {
         await this.syncStreamImplementation?.disconnect();
         this.syncStatusListenerDisposer?.();
         await this.syncStreamImplementation?.dispose();

package/lib/client/sync/stream/AbstractRemote.js

@@ -283,8 +283,16 @@ export class AbstractRemote {
             }, syncQueueRequestSize, // The initial N amount
             {
                 onError: (e) => {
-                    if (e.message.includes('Authorization failed') || e.message.includes('PSYNC_S21')) {
-                        this.invalidateCredentials();
+                    if (e.message.includes('PSYNC_')) {
+                        if (e.message.includes('PSYNC_S21')) {
+                            this.invalidateCredentials();
+                        }
+                    }
+                    else {
+                        // Possible that connection is with an older service, always invalidate to be safe
+                        if (e.message !== 'Closed. ') {
+                            this.invalidateCredentials();
+                        }
                     }
                     // Don't log closed as an error
                     if (e.message !== 'Closed. ') {

package/lib/client/sync/stream/AbstractStreamingSyncImplementation.js

@@ -196,11 +196,12 @@ The next upload iteration will be delayed.`);
         if (this.abortController) {
             await this.disconnect();
         }
-        this.abortController = new AbortController();
+        const controller = new AbortController();
+        this.abortController = controller;
         this.streamingSyncPromise = this.streamingSync(this.abortController.signal, options);
         // Return a promise that resolves when the connection status is updated
         return new Promise((resolve) => {
-            const l = this.registerListener({
+            const disposer = this.registerListener({
                 statusUpdated: (update) => {
                     // This is triggered as soon as a connection is read from
                     if (typeof update.connected == 'undefined') {
@@ -209,12 +210,14 @@ The next upload iteration will be delayed.`);
                     }
                     if (update.connected == false) {
                         /**
-                         * This function does not reject if initial connect attempt failed
+                         * This function does not reject if initial connect attempt failed.
+                         * Connected can be false if the connection attempt was aborted or if the initial connection
+                         * attempt failed.
                          */
                         this.logger.warn('Initial connect attempt did not successfully connect to server');
                     }
+                    disposer();
                     resolve();
-                    l();
                 }
             });
         });
@@ -356,6 +359,9 @@ The next upload iteration will be delayed.`);
                 let validatedCheckpoint = null;
                 let appliedCheckpoint = null;
                 const clientId = await this.options.adapter.getClientId();
+                if (signal.aborted) {
+                    return;
+                }
                 this.logger.debug('Requesting stream from server');
                 const syncOptions = {
                     path: '/sync/stream',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powersync/common",
-  "version": "0.0.0-dev-20250520135616",
+  "version": "0.0.0-dev-20250526133243",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"