@drakkar.software/starfish-client 3.0.0-alpha.26 → 3.0.0-alpha.28

package/dist/bindings/zustand.d.ts

@@ -79,6 +79,20 @@ export interface CreateStarfishStoreOptions {
      * ```
      */
     onRemoteUpdate?: (data: Record<string, unknown>) => void;
+    /**
+     * Auto re-attempt a failed flush with exponential backoff while the store
+     * stays dirty + online. Omit to keep the current no-retry behavior.
+     *
+     * Defaults when the option is present: `maxRetries: 5`, `initialDelayMs: 500`,
+     * `maxDelayMs: 30_000`. Backoff is `min(initial * 2^attempt, max) + jitter(100ms)`.
+     * A successful flush resets the counter. Going offline cancels any pending retry.
+     * `AbortError`s are never retried.
+     */
+    flushRetry?: {
+        maxRetries?: number;
+        initialDelayMs?: number;
+        maxDelayMs?: number;
+    };
 }
 export type { DevtoolsOptions };
 export declare function createStarfishStore(options: CreateStarfishStoreOptions): StoreApi<StarfishStore>;

package/dist/bindings/zustand.js

@@ -679,7 +679,20 @@ var StarfishClient = class {
     if (!res.ok) {
       throw new StarfishHttpError(res.status, await res.text());
     }
-    return res.json();
+    const result = await res.json();
+    if (this.cache) {
+      const pullPath = sendPath.replace("/push/", "/pull/");
+      const cacheKey = pullCacheKey(pullPath);
+      const snapshot = {
+        data,
+        hash: result.hash,
+        timestamp: result.timestamp,
+        cachedAt: Date.now()
+      };
+      void this.cache.set(cacheKey, JSON.stringify(snapshot)).catch(() => {
+      });
+    }
+    return result;
   }
   /**
    * Append an element to an appendOnly (`by_timestamp`) collection.
@@ -1069,6 +1082,30 @@ function createStarfishStore(options) {
   const { name, syncManager, storage } = options;
   const storeCreator = (rawSet, get) => {
     const set = rawSet;
+    let retryTimer;
+    let retryAttempt = 0;
+    const scheduleFlushRetry = () => {
+      const retryOpts = options.flushRetry;
+      if (!retryOpts) return;
+      const maxRetries = retryOpts.maxRetries ?? 5;
+      if (retryAttempt >= maxRetries) return;
+      const initialMs = retryOpts.initialDelayMs ?? 500;
+      const maxMs = retryOpts.maxDelayMs ?? 3e4;
+      const delayMs = Math.min(initialMs * Math.pow(2, retryAttempt), maxMs) + Math.random() * 100;
+      retryAttempt++;
+      clearTimeout(retryTimer);
+      retryTimer = setTimeout(() => {
+        if (get().dirty && get().online && !get().syncing) {
+          get().flush().catch(() => {
+          });
+        }
+      }, delayMs);
+    };
+    const cancelFlushRetry = () => {
+      clearTimeout(retryTimer);
+      retryTimer = void 0;
+      retryAttempt = 0;
+    };
     return {
       data: {},
       syncing: false,
@@ -1103,6 +1140,8 @@ function createStarfishStore(options) {
       set: (modifier) => {
         try {
           const next = options.produce ? options.produce(get().data, modifier) : modifier(get().data);
+          retryAttempt = 0;
+          clearTimeout(retryTimer);
           set({ data: next, dirty: true, error: null }, false, "set");
           if (get().online) get().flush().catch(() => {
           });
@@ -1118,15 +1157,22 @@ function createStarfishStore(options) {
         set({ syncing: true, error: null }, false, "flush/start");
         try {
           await syncManager.push(get().data);
+          cancelFlushRetry();
           set({ data: syncManager.getData(), syncing: false, dirty: false, hash: syncManager.getHash(), stale: false }, false, "flush/success");
         } catch (err) {
+          const isAbort = err instanceof Error && (err.name === "AbortError" || typeof DOMException !== "undefined" && err instanceof DOMException && err.name === "AbortError");
           set({ syncing: false, error: err instanceof Error ? err.message : String(err) }, false, "flush/error");
+          if (!isAbort) scheduleFlushRetry();
         }
       },
       setOnline: (online) => {
         set({ online }, false, "setOnline");
-        if (online && get().dirty) get().flush().catch(() => {
-        });
+        if (online && get().dirty) {
+          get().flush().catch(() => {
+          });
+        } else if (!online) {
+          cancelFlushRetry();
+        }
       }
     };
   };