@powersync/common 1.53.0 → 1.53.2

package/dist/bundle.mjs

@@ -2428,30 +2428,44 @@ function throttleTrailing(func, wait) {
         }
     };
 }
-/**
- * Throttle a function to be called at most once every "wait" milliseconds,
- * on the leading and trailing edge.
- *
- * Roughly equivalent to lodash/throttle with {leading: true, trailing: true}
- */
-function throttleLeadingTrailing(func, wait) {
-    let timeoutId = null;
-    let lastCallTime = 0;
-    const invokeFunction = () => {
-        func();
-        lastCallTime = Date.now();
-        timeoutId = null;
-    };
-    return function () {
-        const now = Date.now();
-        const timeToWait = wait - (now - lastCallTime);
-        if (timeToWait <= 0) {
-            // Leading edge: Call the function immediately if enough time has passed
-            invokeFunction();
-        }
-        else if (!timeoutId) {
-            // Set a timeout for the trailing edge if not already set
-            timeoutId = setTimeout(invokeFunction, timeToWait);
+function asyncNotifier() {
+    let waitingConsumer = null;
+    let hasPendingNotification = false;
+    return {
+        notify() {
+            if (waitingConsumer != null) {
+                waitingConsumer();
+                waitingConsumer = null;
+            }
+            else {
+                hasPendingNotification = true;
+            }
+        },
+        waitForNotification(signal) {
+            return new Promise((resolve) => {
+                if (waitingConsumer != null) {
+                    throw new Error('Illegal call to waitForNotification, already has a waiter.');
+                }
+                if (signal.aborted) {
+                    resolve();
+                }
+                else if (hasPendingNotification) {
+                    resolve();
+                    hasPendingNotification = false;
+                }
+                else {
+                    function complete() {
+                        signal.removeEventListener('abort', onAbort);
+                        resolve();
+                    }
+                    function onAbort() {
+                        waitingConsumer = null;
+                        resolve();
+                    }
+                    waitingConsumer = complete;
+                    signal.addEventListener('abort', onAbort);
+                }
+            });
         }
     };
 }
@@ -10653,7 +10667,7 @@ function requireDist () {
 
 var distExports = requireDist();
 
-var version = "1.53.0";
+var version = "1.53.2";
 var PACKAGE = {
 	version: version};
 
@@ -10837,6 +10851,7 @@ function injectable(source) {
     let waiter = undefined; // An active, waiting next() call.
     // A pending upstream event that couldn't be dispatched because inject() has been called before it was resolved.
     let pendingSourceEvent = null;
+    let sourceFetchInFlight = false;
     let pendingInjectedEvents = [];
     const consumeWaiter = () => {
         const pending = waiter;
@@ -10845,6 +10860,7 @@ function injectable(source) {
     };
     const fetchFromSource = () => {
         const resolveWaiter = (propagate) => {
+            sourceFetchInFlight = false;
             const active = consumeWaiter();
             if (active) {
                 propagate(active);
@@ -10853,6 +10869,7 @@ function injectable(source) {
                 pendingSourceEvent = propagate;
             }
         };
+        sourceFetchInFlight = true;
         const nextFromSource = source.next();
         nextFromSource.then((value) => {
             sourceIsDone = value.done == true;
@@ -10879,7 +10896,9 @@ function injectable(source) {
                 }
                 // Nothing pending? Fetch from source
                 waiter = { resolve, reject };
-                return fetchFromSource();
+                if (!sourceFetchInFlight) {
+                    fetchFromSource();
+                }
             });
         },
         inject: (event) => {
@@ -11556,19 +11575,15 @@ const DEFAULT_STREAM_CONNECTION_OPTIONS = {
 class AbstractStreamingSyncImplementation extends BaseObserver {
     options;
     abortController;
-    // In rare cases, mostly for tests, uploads can be triggered without being properly connected.
-    // This allows ensuring that all upload processes can be aborted.
-    uploadAbortController;
     crudUpdateListener;
     streamingSyncPromise;
     logger;
     activeStreams;
     connectionMayHaveChanged = false;
-    isUploadingCrud = false;
+    crudUploadNotifier = asyncNotifier();
     notifyCompletedUploads;
     handleActiveStreamsChange;
     syncStatus;
-    triggerCrudUpload;
     constructor(options) {
         super();
         this.options = options;
@@ -11584,16 +11599,9 @@ class AbstractStreamingSyncImplementation extends BaseObserver {
             }
         });
         this.abortController = null;
-        this.triggerCrudUpload = throttleLeadingTrailing(() => {
-            if (!this.syncStatus.connected || this.isUploadingCrud) {
-                return;
-            }
-            this.isUploadingCrud = true;
-            this._uploadAllCrud().finally(() => {
-                this.notifyCompletedUploads?.();
-                this.isUploadingCrud = false;
-            });
-        }, this.options.crudUploadThrottleMs);
+    }
+    triggerCrudUpload() {
+        this.crudUploadNotifier.notify();
     }
     async waitForReady() { }
     waitForStatus(status) {
@@ -11641,7 +11649,6 @@ class AbstractStreamingSyncImplementation extends BaseObserver {
         super.dispose();
         this.crudUpdateListener?.();
         this.crudUpdateListener = undefined;
-        this.uploadAbortController?.abort();
     }
     async getWriteCheckpoint() {
         const clientId = await this.options.adapter.getClientId();
@@ -11651,7 +11658,17 @@ class AbstractStreamingSyncImplementation extends BaseObserver {
         this.logger.debug(`Created write checkpoint: ${checkpoint}`);
         return checkpoint;
     }
-    async _uploadAllCrud() {
+    async crudUploadLoop(signal) {
+        while (!signal.aborted) {
+            await Promise.all([
+                // Start the initial CRUD upload on connect. Then, keep polling until we're done.
+                this._uploadAllCrud(signal),
+                this.delayRetry(signal, this.options.crudUploadThrottleMs)
+            ]);
+            await this.crudUploadNotifier.waitForNotification(signal);
+        }
+    }
+    async _uploadAllCrud(signal) {
         return this.obtainLock({
             type: LockType.CRUD,
             callback: async () => {
@@ -11659,12 +11676,7 @@ class AbstractStreamingSyncImplementation extends BaseObserver {
                  * Keep track of the first item in the CRUD queue for the last `uploadCrud` iteration.
                  */
                 let checkedCrudItem;
-                const controller = new AbortController();
-                this.uploadAbortController = controller;
-                this.abortController?.signal.addEventListener('abort', () => {
-                    controller.abort();
-                }, { once: true });
-                while (!controller.signal.aborted) {
+                while (!signal.aborted) {
                     try {
                         /**
                          * This is the first item in the FIFO CRUD queue.
@@ -11694,7 +11706,10 @@ The next upload iteration will be delayed.`);
                         else {
                             // Uploading is completed
                             const neededUpdate = await this.options.adapter.updateLocalTarget(() => this.getWriteCheckpoint());
-                            if (neededUpdate == false && checkedCrudItem != null) {
+                            if (neededUpdate) {
+                                this.notifyCompletedUploads?.();
+                            }
+                            else if (checkedCrudItem != null) {
                                 // Only log this if there was something to upload
                                 this.logger.debug('Upload complete, no write checkpoint needed.');
                             }
@@ -11709,7 +11724,7 @@ The next upload iteration will be delayed.`);
                                 uploadError: ex
                             }
                         });
-                        await this.delayRetry(controller.signal);
+                        await this.delayRetry(signal);
                         if (!this.isConnected) {
                             // Exit the upload loop if the sync stream is no longer connected
                             break;
@@ -11724,7 +11739,6 @@ The next upload iteration will be delayed.`);
                         });
                     }
                 }
-                this.uploadAbortController = undefined;
             }
         });
     }
@@ -11734,7 +11748,10 @@ The next upload iteration will be delayed.`);
         }
         const controller = new AbortController();
         this.abortController = controller;
-        this.streamingSyncPromise = this.streamingSync(this.abortController.signal, options);
+        this.streamingSyncPromise = Promise.all([
+            this.crudUploadLoop(controller.signal).catch((ex) => this.logger.error('Error in crud upload loop', ex)),
+            this.streamingSync(controller.signal, options)
+        ]);
         // Return a promise that resolves when the connection status is updated to indicate that we're connected.
         return new Promise((resolve) => {
             const disposer = this.registerListener({
@@ -11772,14 +11789,7 @@ The next upload iteration will be delayed.`);
         this.abortController = null;
         this.updateSyncStatus({ connected: false, connecting: false });
     }
-    /**
-     * @deprecated use [connect instead]
-     */
     async streamingSync(signal, options) {
-        if (!signal) {
-            this.abortController = new AbortController();
-            signal = this.abortController.signal;
-        }
         /**
          * Listen for CRUD updates and trigger upstream uploads
          */
@@ -12153,14 +12163,13 @@ The next upload iteration will be delayed.`);
         // trigger this for all updates
         this.iterateListeners((cb) => cb.statusUpdated?.(options));
     }
-    async delayRetry(signal) {
+    async delayRetry(signal, delay = this.options.retryDelayMs) {
         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();
@@ -12171,7 +12180,7 @@ The next upload iteration will be delayed.`);
                 signal?.removeEventListener('abort', endDelay);
             };
             signal?.addEventListener('abort', endDelay, { once: true });
-            timeoutId = setTimeout(endDelay, retryDelayMs);
+            timeoutId = setTimeout(endDelay, delay);
         });
     }
     updateSubscriptions(subscriptions) {