@powersync/common 0.0.0-dev-20250528152729 → 0.0.0-dev-20250609122429

package/lib/client/AbstractPowerSyncDatabase.d.ts

@@ -122,7 +122,7 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
     get syncStreamImplementation(): StreamingSyncImplementation | null;
     protected _schema: Schema;
     private _database;
-    protected connectionMutex: Mutex;
+    protected runExclusiveMutex: Mutex;
     constructor(options: PowerSyncDatabaseOptionsWithDBAdapter);
     constructor(options: PowerSyncDatabaseOptionsWithOpenFactory);
     constructor(options: PowerSyncDatabaseOptionsWithSettings);

package/lib/client/AbstractPowerSyncDatabase.js

@@ -69,7 +69,7 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
     }
     _schema;
     _database;
-    connectionMutex;
+    runExclusiveMutex;
     constructor(options) {
         super();
         this.options = options;
@@ -96,7 +96,7 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
         this._schema = schema;
         this.ready = false;
         this.sdkVersion = '';
-        this.connectionMutex = new Mutex();
+        this.runExclusiveMutex = new Mutex();
         // Start async init
         this.connectionManager = new ConnectionManager({
             createSyncImplementation: async (connector, options) => {
@@ -298,7 +298,7 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
      * Locking here is mostly only important on web for multiple tab scenarios.
      */
     runExclusive(callback) {
-        return this.connectionMutex.runExclusive(callback);
+        return this.runExclusiveMutex.runExclusive(callback);
     }
     /**
      * Connects to stream of events from the PowerSync instance.

package/lib/client/ConnectionManager.d.ts

@@ -7,6 +7,10 @@ import { PowerSyncConnectionOptions, StreamingSyncImplementation } from './sync/
  */
 export interface ConnectionManagerSyncImplementationResult {
     sync: StreamingSyncImplementation;
+    /**
+     * Additional cleanup function which is called after the sync stream implementation
+     * is disposed.
+     */
     onDispose: () => Promise<void> | void;
 }
 /**
@@ -54,7 +58,11 @@ export declare class ConnectionManager extends BaseObserver<ConnectionManagerLis
      */
     protected pendingConnectionOptions: StoredConnectionOptions | null;
     syncStreamImplementation: StreamingSyncImplementation | null;
-    syncDisposer: (() => Promise<void> | void) | null;
+    /**
+     * Additional cleanup function which is called after the sync stream implementation
+     * is disposed.
+     */
+    protected syncDisposer: (() => Promise<void> | void) | null;
     constructor(options: ConnectionManagerOptions);
     get logger(): ILogger;
     close(): Promise<void>;

package/lib/client/ConnectionManager.js

@@ -27,6 +27,10 @@ export class ConnectionManager extends BaseObserver {
      */
     pendingConnectionOptions;
     syncStreamImplementation;
+    /**
+     * Additional cleanup function which is called after the sync stream implementation
+     * is disposed.
+     */
     syncDisposer;
     constructor(options) {
         super();
@@ -42,6 +46,7 @@ export class ConnectionManager extends BaseObserver {
         return this.options.logger;
     }
     async close() {
+        await this.syncStreamImplementation?.dispose();
         await this.syncDisposer?.();
     }
     async connect(connector, options) {
@@ -58,7 +63,7 @@ export class ConnectionManager extends BaseObserver {
         // 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.
         // We should also disconnect if we have already completed a connection attempt.
-        if (!hadPendingOptions) {
+        if (!hadPendingOptions || this.syncStreamImplementation) {
             await this.disconnectInternal();
         }
         // Triggers a connect which checks if pending options are available after the connect completes.
@@ -68,7 +73,9 @@ export class ConnectionManager extends BaseObserver {
             if (this.pendingConnectionOptions) {
                 // Pending options have been placed while connecting.
                 // Need to reconnect.
-                this.connectingPromise = this.connectInternal().finally(checkConnection);
+                this.connectingPromise = this.connectInternal()
+                    .catch(() => { })
+                    .finally(checkConnection);
                 return this.connectingPromise;
             }
             else {
@@ -77,7 +84,9 @@ export class ConnectionManager extends BaseObserver {
                 return;
             }
         };
-        this.connectingPromise ??= this.connectInternal().finally(checkConnection);
+        this.connectingPromise ??= this.connectInternal()
+            .catch(() => { })
+            .finally(checkConnection);
         return this.connectingPromise;
     }
     async connectInternal() {
@@ -95,6 +104,11 @@ export class ConnectionManager extends BaseObserver {
                 if (!this.pendingConnectionOptions) {
                     this.logger.debug('No pending connection options found, not creating sync stream implementation');
                     // A disconnect could have cleared this.
+                    resolve();
+                    return;
+                }
+                if (this.disconnectingPromise) {
+                    resolve();
                     return;
                 }
                 const { connector, options } = this.pendingConnectionOptions;
@@ -139,14 +153,14 @@ export class ConnectionManager extends BaseObserver {
             // 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() {
+        // 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;
         // Keep reference to the sync stream implementation and disposer
         // The class members will be cleared before we trigger the disconnect
         // to prevent any further calls to the sync stream implementation.

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

@@ -2,10 +2,10 @@ import { Buffer } from 'buffer';
 import ndjsonStream from 'can-ndjson-stream';
 import Logger from 'js-logger';
 import { RSocketConnector } from 'rsocket-core';
-import { WebsocketClientTransport } from 'rsocket-websocket-client';
 import PACKAGE from '../../../../package.json' with { type: 'json' };
 import { AbortOperation } from '../../../utils/AbortOperation.js';
 import { DataStream } from '../../../utils/DataStream.js';
+import { WebsocketClientTransport } from './WebsocketClientTransport.js';
 const POWERSYNC_TRAILING_SLASH_MATCH = /\/+$/;
 const POWERSYNC_JS_VERSION = PACKAGE.version;
 const SYNC_QUEUE_REQUEST_LOW_WATER = 5;
@@ -211,17 +211,12 @@ export class AbstractRemote {
         // headers with websockets on web. The browser userAgent is however added
         // automatically as a header.
         const userAgent = this.getUserAgent();
-        let socketCreationError;
+        const url = this.options.socketUrlTransformer(request.url);
         const connector = new RSocketConnector({
             transport: new WebsocketClientTransport({
-                url: this.options.socketUrlTransformer(request.url),
+                url,
                 wsCreator: (url) => {
-                    const s = this.createSocket(url);
-                    s.addEventListener('error', (e) => {
-                        socketCreationError = new Error('Failed to create connection to websocket: ', e.target.url ?? '');
-                        this.logger.warn('Socket error', e);
-                    });
-                    return s;
+                    return this.createSocket(url);
                 }
             }),
             setup: {
@@ -243,11 +238,8 @@ export class AbstractRemote {
             rsocket = await connector.connect();
         }
         catch (ex) {
-            /**
-             * On React native the connection exception can be `undefined` this causes issues
-             * with detecting the exception inside async-mutex
-             */
-            throw new Error(`Could not connect to PowerSync instance: ${JSON.stringify(ex ?? socketCreationError)}`);
+            this.logger.error(`Failed to connect WebSocket`, ex);
+            throw ex;
         }
         const stream = new DataStream({
             logger: this.logger,

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

@@ -286,6 +286,7 @@ The next upload iteration will be delayed.`);
          */
         while (true) {
             this.updateSyncStatus({ connecting: true });
+            let shouldDelayRetry = true;
             try {
                 if (signal?.aborted) {
                     break;
@@ -298,12 +299,15 @@ The next upload iteration will be delayed.`);
                  * Either:
                  *  - A network request failed with a failed connection or not OKAY response code.
                  *  - There was a sync processing error.
-                 * This loop will retry.
+                 *  - The connection was aborted.
+                 * This loop will retry after a delay if the connection was not aborted.
                  * The nested abort controller will cleanup any open network requests and streams.
                  * The WebRemote should only abort pending fetch requests or close active Readable streams.
                  */
                 if (ex instanceof AbortOperation) {
                     this.logger.warn(ex);
+                    shouldDelayRetry = false;
+                    // A disconnect was requested, we should not delay since there is no explicit retry
                 }
                 else {
                     this.logger.error(ex);
@@ -313,8 +317,6 @@ The next upload iteration will be delayed.`);
                         downloadError: ex
                     }
                 });
-                // On error, wait a little before retrying
-                await this.delayRetry();
             }
             finally {
                 if (!signal.aborted) {
@@ -325,6 +327,10 @@ The next upload iteration will be delayed.`);
                     connected: false,
                     connecting: true // May be unnecessary
                 });
+                // On error, wait a little before retrying
+                if (shouldDelayRetry) {
+                    await this.delayRetry(nestedAbortController.signal);
+                }
             }
         }
         // Mark as disconnected if here
@@ -503,7 +509,7 @@ The next upload iteration will be delayed.`);
                             if (progressForBucket) {
                                 updatedProgress[data.bucket] = {
                                     ...progressForBucket,
-                                    sinceLast: progressForBucket.sinceLast + data.data.length
+                                    sinceLast: Math.min(progressForBucket.sinceLast + data.data.length, progressForBucket.targetCount - progressForBucket.atLast)
                                 };
                             }
                         }
@@ -568,16 +574,32 @@ The next upload iteration will be delayed.`);
     async updateSyncStatusForStartingCheckpoint(checkpoint) {
         const localProgress = await this.options.adapter.getBucketOperationProgress();
         const progress = {};
+        let invalidated = false;
         for (const bucket of checkpoint.buckets) {
             const savedProgress = localProgress[bucket.bucket];
+            const atLast = savedProgress?.atLast ?? 0;
+            const sinceLast = savedProgress?.sinceLast ?? 0;
             progress[bucket.bucket] = {
                 // The fallback priority doesn't matter here, but 3 is the one newer versions of the sync service
                 // will use by default.
                 priority: bucket.priority ?? 3,
-                atLast: savedProgress?.atLast ?? 0,
-                sinceLast: savedProgress?.sinceLast ?? 0,
+                atLast: atLast,
+                sinceLast: sinceLast,
                 targetCount: bucket.count ?? 0
             };
+            if (bucket.count != null && bucket.count < atLast + sinceLast) {
+                // Either due to a defrag / sync rule deploy or a compaction operation, the size
+                // of the bucket shrank so much that the local ops exceed the ops in the updated
+                // bucket. We can't prossibly report progress in this case (it would overshoot 100%).
+                invalidated = true;
+            }
+        }
+        if (invalidated) {
+            for (const bucket in progress) {
+                const bucketProgress = progress[bucket];
+                bucketProgress.atLast = 0;
+                bucketProgress.sinceLast = 0;
+            }
         }
         this.updateSyncStatus({
             dataFlow: {
@@ -645,7 +667,25 @@ The next upload iteration will be delayed.`);
         // trigger this for all updates
         this.iterateListeners((cb) => cb.statusUpdated?.(options));
     }
-    async delayRetry() {
-        return new Promise((resolve) => setTimeout(resolve, this.options.retryDelayMs));
+    async delayRetry(signal) {
+        return new Promise((resolve) => {
+            if (signal?.aborted) {
+                // If the signal is already aborted, resolve immediately
+                resolve();
+                return;
+            }
+            const { retryDelayMs } = this.options;
+            let timeoutId;
+            const endDelay = () => {
+                resolve();
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                    timeoutId = undefined;
+                }
+                signal?.removeEventListener('abort', endDelay);
+            };
+            signal?.addEventListener('abort', endDelay, { once: true });
+            timeoutId = setTimeout(endDelay, retryDelayMs);
+        });
     }
 }

package/lib/client/sync/stream/WebsocketClientTransport.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Adapted from rsocket-websocket-client
+ * https://github.com/rsocket/rsocket-js/blob/e224cf379e747c4f1ddc4f2fa111854626cc8575/packages/rsocket-websocket-client/src/WebsocketClientTransport.ts#L17
+ * This adds additional error handling for React Native iOS.
+ * This particularly adds a close listener to handle cases where the WebSocket
+ * connection closes immediately after opening without emitting an error.
+ */
+import { ClientTransport, Closeable, Demultiplexer, DuplexConnection, FrameHandler, Multiplexer, Outbound } from 'rsocket-core';
+import { ClientOptions } from 'rsocket-websocket-client';
+export declare class WebsocketClientTransport implements ClientTransport {
+    private readonly url;
+    private readonly factory;
+    constructor(options: ClientOptions);
+    connect(multiplexerDemultiplexerFactory: (outbound: Outbound & Closeable) => Multiplexer & Demultiplexer & FrameHandler): Promise<DuplexConnection>;
+}

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

@@ -0,0 +1,60 @@
+/**
+ * Adapted from rsocket-websocket-client
+ * https://github.com/rsocket/rsocket-js/blob/e224cf379e747c4f1ddc4f2fa111854626cc8575/packages/rsocket-websocket-client/src/WebsocketClientTransport.ts#L17
+ * This adds additional error handling for React Native iOS.
+ * This particularly adds a close listener to handle cases where the WebSocket
+ * connection closes immediately after opening without emitting an error.
+ */
+import { Deserializer } from 'rsocket-core';
+import { WebsocketDuplexConnection } from 'rsocket-websocket-client/dist/WebsocketDuplexConnection.js';
+export class WebsocketClientTransport {
+    url;
+    factory;
+    constructor(options) {
+        this.url = options.url;
+        this.factory = options.wsCreator ?? ((url) => new WebSocket(url));
+    }
+    connect(multiplexerDemultiplexerFactory) {
+        return new Promise((resolve, reject) => {
+            const websocket = this.factory(this.url);
+            websocket.binaryType = 'arraybuffer';
+            let removeListeners;
+            const openListener = () => {
+                removeListeners();
+                resolve(new WebsocketDuplexConnection(websocket, new Deserializer(), multiplexerDemultiplexerFactory));
+            };
+            const errorListener = (ev) => {
+                removeListeners();
+                // We add a default error in that case.
+                if (ev.error != null) {
+                    // undici typically provides an error object
+                    reject(ev.error);
+                }
+                else if (ev.message != null) {
+                    // React Native typically does not provide an error object, but does provide a message
+                    reject(new Error(`Failed to create websocket connection: ${ev.message}`));
+                }
+                else {
+                    // Browsers often provide no details at all
+                    reject(new Error(`Failed to create websocket connection to ${this.url}`));
+                }
+            };
+            /**
+             * In some cases, such as React Native iOS, the WebSocket connection may close immediately after opening
+             * without and error. In such cases, we need to handle the close event to reject the promise.
+             */
+            const closeListener = () => {
+                removeListeners();
+                reject(new Error('WebSocket connection closed while opening'));
+            };
+            removeListeners = () => {
+                websocket.removeEventListener('open', openListener);
+                websocket.removeEventListener('error', errorListener);
+                websocket.removeEventListener('close', closeListener);
+            };
+            websocket.addEventListener('open', openListener);
+            websocket.addEventListener('error', errorListener);
+            websocket.addEventListener('close', closeListener);
+        });
+    }
+}

package/lib/db/crud/SyncStatus.js

@@ -123,7 +123,21 @@ export class SyncStatus {
      * @returns {boolean} True if the instances are considered equal, false otherwise
      */
     isEqual(status) {
-        return JSON.stringify(this.options) == JSON.stringify(status.options);
+        /**
+         * By default Error object are serialized to an empty object.
+         * This replaces Errors with more useful information before serialization.
+         */
+        const replacer = (_, value) => {
+            if (value instanceof Error) {
+                return {
+                    name: value.name,
+                    message: value.message,
+                    stack: value.stack
+                };
+            }
+            return value;
+        };
+        return JSON.stringify(this.options, replacer) == JSON.stringify(status.options, replacer);
     }
     /**
      * Creates a human-readable string representation of the current sync status.

package/package.json

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