@bunbase-ae/react-sdk 1.0.1-next.7.bc3dec2 → 1.1.0

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@bunbase-ae/react-sdk",
-  "version": "1.0.1-next.7.bc3dec2",
+  "version": "1.1.0",
   "type": "module",
   "description": "React hooks for BunBase — caching, mutations, auth, realtime",
-  "homepage": "https://docs-bunbase.palmcode.ae/sdk/react",
   "files": [
     "src"
   ],
@@ -17,7 +16,7 @@
   "peerDependencies": {
     "react": ">=19",
     "react-dom": ">=19",
-    "@bunbase-ae/js": ">=1.0.0"
+    "@bunbase-ae/js": ">=1.1.0"
   },
   "devDependencies": {
     "@types/react": "19.2.14",

package/src/cache.ts

@@ -24,18 +24,6 @@ export interface CacheEntry {
   /** Stored so focus-triggered refetch can re-run without external reference. */
   fetcher: (() => Promise<unknown>) | null;
   staleTime: number;
-  retryableError: boolean;
-  /** Number of consecutive fetch failures — used to compute exponential backoff. */
-  consecutiveErrors: number;
-  /** Epoch ms before which fetch() is a no-op (exponential backoff window). */
-  backoffUntil: number;
-  /**
-   * True when this entry was explicitly invalidated (via `invalidate()`) and has
-   * not yet been re-fetched. Subscription callbacks use this flag to distinguish
-   * "app-triggered invalidation → fetch" from "settled fetch → re-render only",
-   * which prevents error/success notifications from spawning a new fetch cycle.
-   */
-  invalidated: boolean;
 }
 
 // ─── Storage adapter ─────────────────────────────────────────────────────────
@@ -171,10 +159,6 @@ export class QueryCache {
               promise: null,
               fetcher: null,
               staleTime: stored.staleTime,
-              retryableError: false,
-              consecutiveErrors: 0,
-              backoffUntil: 0,
-              invalidated: false,
             });
           } catch {
             // Corrupt entry — skip silently.
@@ -228,18 +212,10 @@ export class QueryCache {
 
   isStale(key: string): boolean {
     const e = this.entries.get(key);
-    if (!e) return true;
-    // Errored entries have staleAt = backoffUntil; they are stale once the backoff expires.
-    if (e.status === "error") return Date.now() >= e.staleAt;
-    if (e.status !== "success") return true;
+    if (!e || e.status !== "success") return true;
     return Date.now() >= e.staleAt;
   }
 
-  /** True only when this entry was explicitly invalidated and hasn't been re-fetched yet. */
-  isInvalidated(key: string): boolean {
-    return this.entries.get(key)?.invalidated === true;
-  }
-
   // ─── Fetch ──────────────────────────────────────────────────────────────────
 
   /**
@@ -259,9 +235,6 @@ export class QueryCache {
     // Data is fresh — nothing to do.
     if (existing?.status === "success" && Date.now() < existing.staleAt) return;
 
-    // Respect exponential backoff after consecutive errors.
-    if (existing?.backoffUntil && Date.now() < existing.backoffUntil) return;
-
     // Keep existing data visible while refetching (SWR).
     const entry: CacheEntry = {
       data: existing?.data,
@@ -271,10 +244,6 @@ export class QueryCache {
       promise: null,
       fetcher,
       staleTime,
-      retryableError: false,
-      consecutiveErrors: existing?.consecutiveErrors ?? 0,
-      backoffUntil: existing?.backoffUntil ?? 0,
-      invalidated: false,
     };
 
     const promise: Promise<void> = fetcher().then(
@@ -290,10 +259,6 @@ export class QueryCache {
           promise: null,
           fetcher,
           staleTime,
-          retryableError: false,
-          consecutiveErrors: 0,
-          backoffUntil: 0,
-          invalidated: false,
         };
         this.entries.set(key, next);
         this.persist(key, next);
@@ -303,22 +268,14 @@ export class QueryCache {
       (err: unknown) => {
         const current = this.entries.get(key);
         if (current?.promise !== promise) return;
-        const consecutiveErrors = (current.consecutiveErrors ?? 0) + 1;
-        // Exponential backoff: 1s → 2s → 4s → 8s → 16s → 30s cap.
-        const backoffMs = Math.min(1_000 * 2 ** (consecutiveErrors - 1), 30_000);
-        const backoffUntil = Date.now() + backoffMs;
         this.entries.set(key, {
           data: current?.data,
           error: err instanceof Error ? err : new Error(String(err)),
           status: "error",
-          staleAt: backoffUntil,
+          staleAt: 0,
           promise: null,
           fetcher,
           staleTime,
-          retryableError: isRetryableError(err),
-          consecutiveErrors,
-          backoffUntil,
-          invalidated: false,
         });
         this.notify(key);
       },
@@ -335,17 +292,7 @@ export class QueryCache {
   refetch(key: string): void {
     const entry = this.entries.get(key);
     if (!entry?.fetcher) return;
-    // Clear backoff and reset error state so the forced refetch always proceeds.
-    this.entries.set(key, {
-      ...entry,
-      error: null,
-      status: entry.data !== undefined ? "success" : "loading",
-      staleAt: 0,
-      promise: null,
-      retryableError: false,
-      backoffUntil: 0,
-      invalidated: true,
-    });
+    this.entries.set(key, { ...entry, staleAt: 0, promise: null });
     this.fetch(key, entry.fetcher, entry.staleTime);
   }
 
@@ -356,27 +303,13 @@ export class QueryCache {
    *
    * Data is KEPT so components remain in a loaded state (not loading) while the
    * background re-fetch runs. Subscribers should call `cache.fetch()` when they
-   * receive a notification and find the entry is invalidated.
+   * receive a notification and find the entry is stale.
    */
   invalidate(prefix: string): void {
     const toNotify: string[] = [];
     for (const [key, entry] of this.entries) {
       if (key.startsWith(prefix)) {
-        this.entries.set(key, {
-          ...entry,
-          error: null,
-          status:
-            entry.status === "error"
-              ? entry.data !== undefined
-                ? "success"
-                : "loading"
-              : entry.status,
-          staleAt: 0,
-          promise: null,
-          retryableError: false,
-          backoffUntil: 0,
-          invalidated: true,
-        });
+        this.entries.set(key, { ...entry, staleAt: 0, promise: null });
         toNotify.push(key);
       }
     }
@@ -398,10 +331,6 @@ export class QueryCache {
       promise: null,
       fetcher: null,
       staleTime,
-      retryableError: false,
-      consecutiveErrors: 0,
-      backoffUntil: 0,
-      invalidated: false,
     };
     this.entries.set(key, entry);
     this.persist(key, entry);
@@ -425,10 +354,6 @@ export class QueryCache {
       promise: null,
       fetcher: existing?.fetcher ?? null,
       staleTime,
-      retryableError: false,
-      consecutiveErrors: 0,
-      backoffUntil: 0,
-      invalidated: false,
     };
     this.entries.set(key, entry);
     this.persist(key, entry);
@@ -465,20 +390,14 @@ export class QueryCache {
     }
   }
 
-  /** Re-fetch all stale entries. Called on window focus. */
+  /** Re-fetch all stale or errored entries. Called on window focus. */
   refetchStale(): void {
     for (const [key, entry] of this.entries) {
       if (!entry.fetcher) continue;
-      // Errored entries have staleAt = backoffUntil, so the same check handles them.
-      if (!entry.promise && Date.now() >= entry.staleAt) {
+      const isStale = entry.status === "error" || Date.now() >= entry.staleAt;
+      if (isStale && !entry.promise) {
         this.fetch(key, entry.fetcher, entry.staleTime);
       }
     }
   }
 }
-
-function isRetryableError(error: unknown): boolean {
-  if (!error || typeof error !== "object" || !("status" in error)) return true;
-  const status = (error as { status?: unknown }).status;
-  return typeof status !== "number" || status < 400 || status >= 500;
-}

package/src/useAuth.ts

@@ -170,6 +170,5 @@ export function useAuth<T>(selector?: (s: UseAuthResult) => T): UseAuthResult |
   return useSyncExternalStore(
     useCallback((fn) => client.auth.subscribeSnapshot(fn), [client]),
     getSnapshot,
-    getSnapshot,
   ) as UseAuthResult | T;
 }

package/src/useList.ts

@@ -74,10 +74,7 @@ export function useList<
   useEffect(
     () =>
       cache.subscribe(cacheKey, () => {
-        // Only re-fetch when the entry was explicitly invalidated (invalidate() /
-        // refetch() / interval). Do NOT re-fetch on error or success notifications —
-        // that would create a tight retry loop bypassing refetchInterval and backoff.
-        if (enabledRef.current && cache.isInvalidated(cacheKey)) {
+        if (enabledRef.current && cache.isStale(cacheKey)) {
           cache.fetch(cacheKey, () => fetcherRef.current(), staleTimeRef.current);
         }
         rerender();

package/src/useRecord.ts

@@ -47,8 +47,7 @@ export function useRecord<
   useEffect(() => {
     if (!cacheKey) return;
     return cache.subscribe(cacheKey, () => {
-      // Only re-fetch on explicit invalidation — not on error/success notifications.
-      if (cacheKey && cache.isInvalidated(cacheKey)) {
+      if (cacheKey && cache.isStale(cacheKey)) {
         cache.fetch(cacheKey, () => fetcherRef.current(), staleTimeRef.current);
       }
       rerender();