@electric-sql/client 1.1.1 → 1.1.2

package/dist/index.d.ts

@@ -135,38 +135,16 @@ interface BackoffOptions {
     initialDelay: number;
     /**
      * Maximum retry delay in milliseconds
-     * After reaching this, delay stays constant (e.g., retry every 60s)
      */
     maxDelay: number;
     multiplier: number;
     onFailedAttempt?: () => void;
     debug?: boolean;
-    /**
-     * Maximum number of retry attempts before giving up.
-     * Set to Infinity (default) for indefinite retries - needed for offline scenarios
-     * where clients may go offline and come back later.
-     *
-     * The retry budget provides protection against retry storms even with infinite retries.
-     */
-    maxRetries?: number;
-    /**
-     * Percentage of requests that can be retries (0.1 = 10%)
-     *
-     * This is the primary load shedding mechanism. It limits the *rate* of retries,
-     * not the total count. Even with infinite retries, at most 10% of your traffic
-     * will be retries, preventing retry storms from amplifying server load.
-     *
-     * The budget resets every 60 seconds, so a temporary spike of errors won't
-     * permanently exhaust the budget.
-     */
-    retryBudgetPercent?: number;
 }
 declare const BackoffDefaults: {
     initialDelay: number;
     maxDelay: number;
     multiplier: number;
-    maxRetries: number;
-    retryBudgetPercent: number;
 };
 
 declare const LIVE_CACHE_BUSTER_QUERY_PARAM = "cursor";

package/dist/index.legacy-esm.js

@@ -316,13 +316,8 @@ var ELECTRIC_PROTOCOL_QUERY_PARAMS = [
 var HTTP_RETRY_STATUS_CODES = [429];
 var BackoffDefaults = {
   initialDelay: 100,
-  maxDelay: 6e4,
-  // Cap at 60s - reasonable for long-lived connections
-  multiplier: 1.3,
-  maxRetries: Infinity,
-  // Retry forever - clients may go offline and come back
-  retryBudgetPercent: 0.1
-  // 10% retry budget prevents amplification
+  maxDelay: 1e4,
+  multiplier: 1.3
 };
 function createFetchWithBackoff(fetchClient, backoffOptions = BackoffDefaults) {
   const {
@@ -330,29 +325,8 @@ function createFetchWithBackoff(fetchClient, backoffOptions = BackoffDefaults) {
     maxDelay,
     multiplier,
     debug = false,
-    onFailedAttempt,
-    maxRetries = Infinity,
-    retryBudgetPercent = 0.1
+    onFailedAttempt
   } = backoffOptions;
-  let totalRequests = 0;
-  let totalRetries = 0;
-  let budgetResetTime = Date.now() + 6e4;
-  function checkRetryBudget(percent) {
-    const now = Date.now();
-    if (now > budgetResetTime) {
-      totalRequests = 0;
-      totalRetries = 0;
-      budgetResetTime = now + 6e4;
-    }
-    totalRequests++;
-    if (totalRequests < 10) return true;
-    const currentRetryRate = totalRetries / totalRequests;
-    const hasCapacity = currentRetryRate < percent;
-    if (hasCapacity) {
-      totalRetries++;
-    }
-    return hasCapacity;
-  }
   return async (...args) => {
     var _a;
     const url = args[0];
@@ -362,10 +336,7 @@ function createFetchWithBackoff(fetchClient, backoffOptions = BackoffDefaults) {
     while (true) {
       try {
         const result = await fetchClient(...args);
-        if (result.ok) {
-          delay = initialDelay;
-          return result;
-        }
+        if (result.ok) return result;
         const err = await FetchError.fromResponse(result, url.toString());
         throw err;
       } catch (e) {
@@ -375,51 +346,12 @@ function createFetchWithBackoff(fetchClient, backoffOptions = BackoffDefaults) {
         } else if (e instanceof FetchError && !HTTP_RETRY_STATUS_CODES.includes(e.status) && e.status >= 400 && e.status < 500) {
           throw e;
         } else {
-          attempt++;
-          if (attempt >= maxRetries) {
-            if (debug) {
-              console.log(
-                `Max retries reached (${attempt}/${maxRetries}), giving up`
-              );
-            }
-            throw e;
-          }
-          if (!checkRetryBudget(retryBudgetPercent)) {
-            if (debug) {
-              console.log(
-                `Retry budget exhausted (attempt ${attempt}), backing off`
-              );
-            }
-            await new Promise((resolve) => setTimeout(resolve, maxDelay));
-            continue;
-          }
-          let serverMinimumMs = 0;
-          if (e instanceof FetchError && e.headers) {
-            const retryAfter = e.headers[`retry-after`];
-            if (retryAfter) {
-              const retryAfterSec = Number(retryAfter);
-              if (Number.isFinite(retryAfterSec) && retryAfterSec > 0) {
-                serverMinimumMs = retryAfterSec * 1e3;
-              } else {
-                const retryDate = Date.parse(retryAfter);
-                if (!isNaN(retryDate)) {
-                  const deltaMs = retryDate - Date.now();
-                  serverMinimumMs = Math.max(0, Math.min(deltaMs, 36e5));
-                }
-              }
-            }
-          }
-          const jitter = Math.random() * delay;
-          const clientBackoffMs = Math.min(jitter, maxDelay);
-          const waitMs = Math.max(serverMinimumMs, clientBackoffMs);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          delay = Math.min(delay * multiplier, maxDelay);
           if (debug) {
-            const source = serverMinimumMs > 0 ? `server+client` : `client`;
-            console.log(
-              `Retry attempt #${attempt} after ${waitMs}ms (${source}, serverMin=${serverMinimumMs}ms, clientBackoff=${clientBackoffMs}ms)`
-            );
+            attempt++;
+            console.log(`Retry attempt #${attempt} after ${delay}ms`);
           }
-          await new Promise((resolve) => setTimeout(resolve, waitMs));
-          delay = Math.min(delay * multiplier, maxDelay);
         }
       }
     }
@@ -784,8 +716,9 @@ function canonicalShapeKey(url) {
   cleanUrl.searchParams.sort();
   return cleanUrl.toString();
 }
-var _error, _fetchClient2, _sseFetchClient, _messageParser, _subscribers, _started, _state, _lastOffset, _liveCacheBuster, _lastSyncedAt, _isUpToDate, _isMidStream, _connected, _shapeHandle, _mode, _schema, _onError, _requestAbortController, _isRefreshing, _tickPromise, _tickPromiseResolver, _tickPromiseRejecter, _messageChain, _snapshotTracker, _activeSnapshotRequests, _midStreamPromise, _midStreamPromiseResolver, _ShapeStream_instances, start_fn, requestShape_fn, constructUrl_fn, createAbortListener_fn, onInitialResponse_fn, onMessages_fn, fetchShape_fn, requestShapeLongPoll_fn, requestShapeSSE_fn, pause_fn, resume_fn, nextTick_fn, waitForStreamEnd_fn, publish_fn, sendErrorToSubscribers_fn, subscribeToVisibilityChanges_fn, reset_fn, fetchSnapshot_fn;
+var _error, _fetchClient2, _sseFetchClient, _messageParser, _subscribers, _started, _state, _lastOffset, _liveCacheBuster, _lastSyncedAt, _isUpToDate, _isMidStream, _connected, _shapeHandle, _mode, _schema, _onError, _requestAbortController, _isRefreshing, _tickPromise, _tickPromiseResolver, _tickPromiseRejecter, _messageChain, _snapshotTracker, _activeSnapshotRequests, _midStreamPromise, _midStreamPromiseResolver, _lastSseConnectionStartTime, _minSseConnectionDuration, _consecutiveShortSseConnections, _maxShortSseConnections, _sseFallbackToLongPolling, _sseBackoffBaseDelay, _sseBackoffMaxDelay, _ShapeStream_instances, start_fn, requestShape_fn, constructUrl_fn, createAbortListener_fn, onInitialResponse_fn, onMessages_fn, fetchShape_fn, requestShapeLongPoll_fn, requestShapeSSE_fn, pause_fn, resume_fn, nextTick_fn, waitForStreamEnd_fn, publish_fn, sendErrorToSubscribers_fn, subscribeToVisibilityChanges_fn, reset_fn, fetchSnapshot_fn;
 var ShapeStream = class {
+  // Maximum delay cap (ms)
   constructor(options) {
     __privateAdd(this, _ShapeStream_instances);
     __privateAdd(this, _error, null);
@@ -819,6 +752,16 @@ var ShapeStream = class {
     // counter for concurrent snapshot requests
     __privateAdd(this, _midStreamPromise);
     __privateAdd(this, _midStreamPromiseResolver);
+    __privateAdd(this, _lastSseConnectionStartTime);
+    __privateAdd(this, _minSseConnectionDuration, 1e3);
+    // Minimum expected SSE connection duration (1 second)
+    __privateAdd(this, _consecutiveShortSseConnections, 0);
+    __privateAdd(this, _maxShortSseConnections, 3);
+    // Fall back to long polling after this many short connections
+    __privateAdd(this, _sseFallbackToLongPolling, false);
+    __privateAdd(this, _sseBackoffBaseDelay, 100);
+    // Base delay for exponential backoff (ms)
+    __privateAdd(this, _sseBackoffMaxDelay, 5e3);
     var _a, _b, _c, _d;
     this.options = __spreadValues({ subscribe: true }, options);
     validateOptions(this.options);
@@ -990,9 +933,16 @@ _snapshotTracker = new WeakMap();
 _activeSnapshotRequests = new WeakMap();
 _midStreamPromise = new WeakMap();
 _midStreamPromiseResolver = new WeakMap();
+_lastSseConnectionStartTime = new WeakMap();
+_minSseConnectionDuration = new WeakMap();
+_consecutiveShortSseConnections = new WeakMap();
+_maxShortSseConnections = new WeakMap();
+_sseFallbackToLongPolling = new WeakMap();
+_sseBackoffBaseDelay = new WeakMap();
+_sseBackoffMaxDelay = new WeakMap();
 _ShapeStream_instances = new WeakSet();
 start_fn = async function() {
-  var _a;
+  var _a, _b, _c, _d, _e;
   __privateSet(this, _started, true);
   try {
     await __privateMethod(this, _ShapeStream_instances, requestShape_fn).call(this);
@@ -1000,24 +950,34 @@ start_fn = async function() {
     __privateSet(this, _error, err);
     if (__privateGet(this, _onError)) {
       const retryOpts = await __privateGet(this, _onError).call(this, err);
-      if (typeof retryOpts === `object`) {
-        __privateMethod(this, _ShapeStream_instances, reset_fn).call(this);
-        if (`params` in retryOpts) {
-          this.options.params = retryOpts.params;
+      if (retryOpts && typeof retryOpts === `object`) {
+        if (retryOpts.params) {
+          this.options.params = __spreadValues(__spreadValues({}, (_a = this.options.params) != null ? _a : {}), retryOpts.params);
         }
-        if (`headers` in retryOpts) {
-          this.options.headers = retryOpts.headers;
+        if (retryOpts.headers) {
+          this.options.headers = __spreadValues(__spreadValues({}, (_b = this.options.headers) != null ? _b : {}), retryOpts.headers);
         }
+        __privateSet(this, _error, null);
         __privateSet(this, _started, false);
-        __privateMethod(this, _ShapeStream_instances, start_fn).call(this);
+        await __privateMethod(this, _ShapeStream_instances, start_fn).call(this);
+        return;
+      }
+      if (err instanceof Error) {
+        __privateMethod(this, _ShapeStream_instances, sendErrorToSubscribers_fn).call(this, err);
       }
+      __privateSet(this, _connected, false);
+      (_c = __privateGet(this, _tickPromiseRejecter)) == null ? void 0 : _c.call(this);
       return;
     }
-    throw err;
-  } finally {
+    if (err instanceof Error) {
+      __privateMethod(this, _ShapeStream_instances, sendErrorToSubscribers_fn).call(this, err);
+    }
     __privateSet(this, _connected, false);
-    (_a = __privateGet(this, _tickPromiseRejecter)) == null ? void 0 : _a.call(this);
+    (_d = __privateGet(this, _tickPromiseRejecter)) == null ? void 0 : _d.call(this);
+    throw err;
   }
+  __privateSet(this, _connected, false);
+  (_e = __privateGet(this, _tickPromiseRejecter)) == null ? void 0 : _e.call(this);
 };
 requestShape_fn = async function() {
   var _a, _b;
@@ -1062,7 +1022,6 @@ requestShape_fn = async function() {
       await __privateMethod(this, _ShapeStream_instances, publish_fn).call(this, Array.isArray(e.json) ? e.json : [e.json]);
       return __privateMethod(this, _ShapeStream_instances, requestShape_fn).call(this);
     } else {
-      __privateMethod(this, _ShapeStream_instances, sendErrorToSubscribers_fn).call(this, e);
       throw e;
     }
   } finally {
@@ -1204,7 +1163,7 @@ onMessages_fn = async function(batch, isSseMessage = false) {
 fetchShape_fn = async function(opts) {
   var _a;
   const useSse = (_a = this.options.liveSse) != null ? _a : this.options.experimentalLiveSse;
-  if (__privateGet(this, _isUpToDate) && useSse && !__privateGet(this, _isRefreshing) && !opts.resumingFromPause) {
+  if (__privateGet(this, _isUpToDate) && useSse && !__privateGet(this, _isRefreshing) && !opts.resumingFromPause && !__privateGet(this, _sseFallbackToLongPolling)) {
     opts.fetchUrl.searchParams.set(EXPERIMENTAL_LIVE_SSE_QUERY_PARAM, `true`);
     opts.fetchUrl.searchParams.set(LIVE_SSE_QUERY_PARAM, `true`);
     return __privateMethod(this, _ShapeStream_instances, requestShapeSSE_fn).call(this, opts);
@@ -1228,6 +1187,7 @@ requestShapeLongPoll_fn = async function(opts) {
 requestShapeSSE_fn = async function(opts) {
   const { fetchUrl, requestAbortController, headers } = opts;
   const fetch2 = __privateGet(this, _sseFetchClient);
+  __privateSet(this, _lastSseConnectionStartTime, Date.now());
   try {
     let buffer = [];
     await fetchEventSource(fetchUrl.toString(), {
@@ -1261,6 +1221,27 @@ requestShapeSSE_fn = async function(opts) {
       throw new FetchBackoffAbortError();
     }
     throw error;
+  } finally {
+    const connectionDuration = Date.now() - __privateGet(this, _lastSseConnectionStartTime);
+    const wasAborted = requestAbortController.signal.aborted;
+    if (connectionDuration < __privateGet(this, _minSseConnectionDuration) && !wasAborted) {
+      __privateWrapper(this, _consecutiveShortSseConnections)._++;
+      if (__privateGet(this, _consecutiveShortSseConnections) >= __privateGet(this, _maxShortSseConnections)) {
+        __privateSet(this, _sseFallbackToLongPolling, true);
+        console.warn(
+          `[Electric] SSE connections are closing immediately (possibly due to proxy buffering or misconfiguration). Falling back to long polling. Your proxy must support streaming SSE responses (not buffer the complete response). Configuration: Nginx add 'X-Accel-Buffering: no', Caddy add 'flush_interval -1' to reverse_proxy. Note: Do NOT disable caching entirely - Electric uses cache headers to enable request collapsing for efficiency.`
+        );
+      } else {
+        const maxDelay = Math.min(
+          __privateGet(this, _sseBackoffMaxDelay),
+          __privateGet(this, _sseBackoffBaseDelay) * Math.pow(2, __privateGet(this, _consecutiveShortSseConnections))
+        );
+        const delayMs = Math.floor(Math.random() * maxDelay);
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
+    } else if (connectionDuration >= __privateGet(this, _minSseConnectionDuration)) {
+      __privateSet(this, _consecutiveShortSseConnections, 0);
+    }
   }
 };
 pause_fn = function() {
@@ -1352,6 +1333,8 @@ reset_fn = function(handle) {
   __privateSet(this, _connected, false);
   __privateSet(this, _schema, void 0);
   __privateSet(this, _activeSnapshotRequests, 0);
+  __privateSet(this, _consecutiveShortSseConnections, 0);
+  __privateSet(this, _sseFallbackToLongPolling, false);
 };
 fetchSnapshot_fn = async function(url, headers) {
   const response = await __privateGet(this, _fetchClient2).call(this, url.toString(), { headers });