@oxyhq/auth 2.0.4 → 2.0.5

package/dist/esm/WebOxyProvider.js

@@ -9,7 +9,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, } from 'react';
 import { OxyServices, CrossDomainAuth, createAuthManager, } from '@oxyhq/core';
 import { QueryClientProvider } from '@tanstack/react-query';
-import { createQueryClient } from './hooks/queryClient';
+import { attachQueryPersistence, createQueryClient } from './hooks/queryClient';
 const WebOxyContext = createContext(null);
 /**
  * Web-only Oxy Provider
@@ -35,6 +35,29 @@ export function WebOxyProvider({ children, baseURL, authWebUrl, onAuthStateChang
     const [crossDomainAuth] = useState(() => new CrossDomainAuth(oxyServices));
     const [authManager] = useState(() => createAuthManager(oxyServices, { autoRefresh: true }));
     const [queryClient] = useState(() => createQueryClient());
+    // Block first render until the persisted localStorage cache has been
+    // restored — mirrors the RN OxyProvider pattern. Without this gate the
+    // first paint observes an empty cache and any consumer reading
+    // `getQueryData(...)` synchronously (or using `placeholderData: 'previous'`
+    // gating) misses the persisted blob.
+    //
+    // Persistence is attached inside the same effect so we can hold a
+    // reference to the `restored` promise and only flip `isRestoring` to
+    // false once it settles (success OR failure). Detach on unmount so HMR
+    // doesn't leak subscriptions.
+    const [isRestoring, setIsRestoring] = useState(true);
+    useEffect(() => {
+        let mounted = true;
+        const { restored, unsubscribe } = attachQueryPersistence(queryClient);
+        restored.finally(() => {
+            if (mounted)
+                setIsRestoring(false);
+        });
+        return () => {
+            mounted = false;
+            unsubscribe();
+        };
+    }, [queryClient]);
     // Auth state
     const [user, setUser] = useState(null);
     const [isLoading, setIsLoading] = useState(!skipAutoCheck);
@@ -253,6 +276,20 @@ export function WebOxyProvider({ children, baseURL, authWebUrl, onAuthStateChang
         signIn, signInWithFedCM, signInWithPopup, signInWithRedirect,
         signOut, isFedCMSupported, switchSession, clearSessionState,
     ]);
+    // Mirror the RN OxyProvider pattern: don't expose the QueryClient (or
+    // mount children) until the persisted cache has been restored. On the
+    // web this prevents the first paint from observing an empty
+    // localStorage-backed cache, which would otherwise force every
+    // identity/session/auth query to refetch from the network even when a
+    // fresh blob was available on disk.
+    //
+    // The restored promise is wired with `.finally(...)` upstream, so this
+    // unblocks on both success and failure within typically <50ms (sync
+    // localStorage read + JSON.parse). A safety net is unnecessary: the
+    // restore promise always settles synchronously after one microtask.
+    if (isRestoring) {
+        return null;
+    }
     return (_jsx(QueryClientProvider, { client: queryClient, children: _jsx(WebOxyContext.Provider, { value: contextValue, children: children }) }));
 }
 /**

package/dist/esm/hooks/mutations/useAccountMutations.js

@@ -1,6 +1,6 @@
 import { useMutation, useQueryClient } from '@tanstack/react-query';
 import { authenticatedApiCall } from '@oxyhq/core';
-import { queryKeys, invalidateAccountQueries, invalidateUserQueries } from '../queries/queryKeys';
+import { queryKeys, invalidateAccountQueries, invalidateUserQueries, invalidateSessionQueries } from '../queries/queryKeys';
 import { useWebOxy } from '../../WebOxyProvider';
 import { toast } from 'sonner';
 import { refreshAvatarInStore } from '../../utils/avatarUtils';
@@ -9,7 +9,7 @@ import { useAuthStore } from '../../stores/authStore';
  * Update user profile with optimistic updates and offline queue support
  */
 export const useUpdateProfile = () => {
-    const { oxyServices, activeSessionId, user } = useWebOxy();
+    const { oxyServices, activeSessionId } = useWebOxy();
     const queryClient = useQueryClient();
     return useMutation({
         mutationFn: async (updates) => {
@@ -37,12 +37,30 @@ export const useUpdateProfile = () => {
             }
             return { previousUser };
         },
-        // On error, rollback
+        // On error, rollback ONLY the keys this mutation tried to change
         onError: (error, updates, context) => {
-            if (context?.previousUser) {
-                queryClient.setQueryData(queryKeys.accounts.current(), context.previousUser);
+            if (context?.previousUser && updates) {
+                const previousUser = context.previousUser;
+                const changedKeys = Object.keys(updates);
+                const partialRollback = changedKeys.reduce((acc, key) => {
+                    acc[key] = previousUser[key];
+                    return acc;
+                }, {});
+                const current = queryClient.getQueryData(queryKeys.accounts.current());
+                if (current) {
+                    queryClient.setQueryData(queryKeys.accounts.current(), {
+                        ...current,
+                        ...partialRollback,
+                    });
+                }
                 if (activeSessionId) {
-                    queryClient.setQueryData(queryKeys.users.profile(activeSessionId), context.previousUser);
+                    const currentProfile = queryClient.getQueryData(queryKeys.users.profile(activeSessionId));
+                    if (currentProfile) {
+                        queryClient.setQueryData(queryKeys.users.profile(activeSessionId), {
+                            ...currentProfile,
+                            ...partialRollback,
+                        });
+                    }
                 }
             }
             toast.error(error instanceof Error ? error.message : 'Failed to update profile');
@@ -60,9 +78,13 @@ export const useUpdateProfile = () => {
             if (updates.avatar && activeSessionId && oxyServices) {
                 refreshAvatarInStore(activeSessionId, updates.avatar, oxyServices);
             }
-            // Invalidate all related queries to refresh everywhere
+            // Invalidate all related queries so every consumer (AccountSwitcher,
+            // session lists, managed accounts, etc.) refetches the fresh profile.
+            // Critical right after `username` is set the first time, when every
+            // cached "session profile" still reports the user as unnamed.
             invalidateUserQueries(queryClient);
             invalidateAccountQueries(queryClient);
+            invalidateSessionQueries(queryClient);
         },
     });
 };
@@ -102,11 +124,25 @@ export const useUploadAvatar = () => {
             }
             return { previousUser };
         },
-        onError: (error, file, context) => {
+        onError: (error, _file, context) => {
+            // Avatar upload only mutates the `avatar` field — restore only that key
             if (context?.previousUser) {
-                queryClient.setQueryData(queryKeys.accounts.current(), context.previousUser);
+                const previousAvatar = context.previousUser.avatar;
+                const current = queryClient.getQueryData(queryKeys.accounts.current());
+                if (current) {
+                    queryClient.setQueryData(queryKeys.accounts.current(), {
+                        ...current,
+                        avatar: previousAvatar,
+                    });
+                }
                 if (activeSessionId) {
-                    queryClient.setQueryData(queryKeys.users.profile(activeSessionId), context.previousUser);
+                    const currentProfile = queryClient.getQueryData(queryKeys.users.profile(activeSessionId));
+                    if (currentProfile) {
+                        queryClient.setQueryData(queryKeys.users.profile(activeSessionId), {
+                            ...currentProfile,
+                            avatar: previousAvatar,
+                        });
+                    }
                 }
             }
             toast.error(error instanceof Error ? error.message : 'Failed to upload avatar');
@@ -122,24 +158,46 @@ export const useUploadAvatar = () => {
             if (data?.avatar && activeSessionId && oxyServices) {
                 refreshAvatarInStore(activeSessionId, data.avatar, oxyServices);
             }
-            // Invalidate all related queries to refresh everywhere
+            // Invalidate all related queries to refresh everywhere, including the
+            // sessions cache so other-account avatars update too.
             invalidateUserQueries(queryClient);
             invalidateAccountQueries(queryClient);
+            invalidateSessionQueries(queryClient);
             toast.success('Avatar updated successfully');
         },
     });
 };
 /**
- * Update account settings
+ * Update account settings (privacy preferences).
+ *
+ * Privacy settings are not part of the `PUT /users/me` allow-list; the API
+ * would silently drop them. Route through `updatePrivacySettings` so the
+ * dedicated `PATCH /privacy/:id/privacy` endpoint performs a dot-path merge
+ * and returns the updated `privacySettings` object.
+ *
+ * The returned object exposes the standard mutation surface PLUS a
+ * convenience `mutate(updates)` / `mutateAsync(updates)` that snapshots
+ * the current user from `useWebOxy()` at dispatch time.
  */
 export const useUpdateAccountSettings = () => {
-    const { oxyServices, activeSessionId } = useWebOxy();
+    const { oxyServices, activeSessionId, user } = useWebOxy();
     const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: async (settings) => {
-            return await oxyServices.updateProfile({ privacySettings: settings });
+    const mutation = useMutation({
+        mutationFn: async ({ updates, currentUser }) => {
+            const userId = currentUser.id;
+            if (!userId) {
+                throw new Error('User ID is required to update account settings');
+            }
+            const updatedPrivacy = await authenticatedApiCall(oxyServices, activeSessionId, () => oxyServices.updatePrivacySettings(updates, userId));
+            // Rebuild against the dispatch-time snapshot, NOT the live cache.
+            // The cache may have been mutated by a sibling write between
+            // dispatch and settle.
+            return {
+                ...currentUser,
+                privacySettings: updatedPrivacy,
+            };
         },
-        onMutate: async (settings) => {
+        onMutate: async ({ updates }) => {
             await queryClient.cancelQueries({ queryKey: queryKeys.accounts.settings() });
             const previousUser = queryClient.getQueryData(queryKeys.accounts.current());
             if (previousUser) {
@@ -147,15 +205,31 @@ export const useUpdateAccountSettings = () => {
                     ...previousUser,
                     privacySettings: {
                         ...previousUser.privacySettings,
-                        ...settings,
+                        ...updates,
                     },
                 });
             }
             return { previousUser };
         },
-        onError: (error, settings, context) => {
-            if (context?.previousUser) {
-                queryClient.setQueryData(queryKeys.accounts.current(), context.previousUser);
+        onError: (error, { updates }, context) => {
+            // Restore only the privacySettings keys this mutation tried to change
+            if (context?.previousUser && updates) {
+                const previousPrivacy = context.previousUser.privacySettings ?? {};
+                const changedKeys = Object.keys(updates);
+                const partialPrivacyRollback = changedKeys.reduce((acc, key) => {
+                    acc[key] = previousPrivacy[key];
+                    return acc;
+                }, {});
+                const current = queryClient.getQueryData(queryKeys.accounts.current());
+                if (current) {
+                    queryClient.setQueryData(queryKeys.accounts.current(), {
+                        ...current,
+                        privacySettings: {
+                            ...(current.privacySettings ?? {}),
+                            ...partialPrivacyRollback,
+                        },
+                    });
+                }
             }
             toast.error(error instanceof Error ? error.message : 'Failed to update settings');
         },
@@ -170,6 +244,26 @@ export const useUpdateAccountSettings = () => {
             queryClient.invalidateQueries({ queryKey: queryKeys.accounts.settings() });
         },
     });
+    // Wrap mutate/mutateAsync so call sites pass a plain settings object and
+    // the current user is captured at dispatch time.
+    return {
+        ...mutation,
+        mutate: (updates) => {
+            const currentUser = user ?? queryClient.getQueryData(queryKeys.accounts.current());
+            if (!currentUser) {
+                toast.error('Cannot update account settings: no current user');
+                return;
+            }
+            mutation.mutate({ updates, currentUser });
+        },
+        mutateAsync: async (updates) => {
+            const currentUser = user ?? queryClient.getQueryData(queryKeys.accounts.current());
+            if (!currentUser) {
+                throw new Error('Cannot update account settings: no current user');
+            }
+            return mutation.mutateAsync({ updates, currentUser });
+        },
+    };
 };
 /**
  * Update privacy settings with optimistic updates and authentication handling
@@ -215,43 +309,91 @@ export const useUpdatePrivacySettings = () => {
             }
             return { previousPrivacySettings, previousUser };
         },
-        // On error, rollback
-        onError: (error, { userId }, context) => {
+        // On error, rollback ONLY the privacy keys this mutation tried to change.
+        // Restoring the entire previous object would wipe out other concurrent
+        // optimistic updates (e.g. user toggles two privacy switches in quick
+        // succession; failure on one must not revert the other).
+        onError: (error, { settings, userId }, context) => {
             const targetUserId = userId || user?.id;
-            if (context?.previousPrivacySettings && targetUserId) {
-                queryClient.setQueryData(queryKeys.privacy.settings(targetUserId), context.previousPrivacySettings);
+            const changedKeys = settings ? Object.keys(settings) : [];
+            // Rollback the privacy.settings query (partial)
+            if (context?.previousPrivacySettings && targetUserId && changedKeys.length > 0) {
+                const previousPrivacy = context.previousPrivacySettings;
+                const partialPrivacyRollback = changedKeys.reduce((acc, key) => {
+                    acc[key] = previousPrivacy[key];
+                    return acc;
+                }, {});
+                const currentPrivacy = queryClient.getQueryData(queryKeys.privacy.settings(targetUserId));
+                if (currentPrivacy) {
+                    queryClient.setQueryData(queryKeys.privacy.settings(targetUserId), {
+                        ...currentPrivacy,
+                        ...partialPrivacyRollback,
+                    });
+                }
             }
-            if (context?.previousUser) {
-                queryClient.setQueryData(queryKeys.accounts.current(), context.previousUser);
+            // Rollback the accounts.current() user.privacySettings (partial)
+            if (context?.previousUser && changedKeys.length > 0) {
+                const previousPrivacy = (context.previousUser.privacySettings ?? {});
+                const partialPrivacyRollback = changedKeys.reduce((acc, key) => {
+                    acc[key] = previousPrivacy[key];
+                    return acc;
+                }, {});
+                const current = queryClient.getQueryData(queryKeys.accounts.current());
+                if (current) {
+                    queryClient.setQueryData(queryKeys.accounts.current(), {
+                        ...current,
+                        privacySettings: {
+                            ...(current.privacySettings ?? {}),
+                            ...partialPrivacyRollback,
+                        },
+                    });
+                }
+            }
+            // After partial rollback, reconcile against the server so the cache
+            // converges to the authoritative state for the failed keys.
+            if (targetUserId) {
+                queryClient.invalidateQueries({ queryKey: queryKeys.privacy.settings(targetUserId) });
             }
             toast.error(error instanceof Error ? error.message : 'Failed to update privacy settings');
         },
-        // On success, invalidate and refetch
-        onSuccess: (data, { userId }) => {
+        // On success, MERGE the server response into the cached state. Older
+        // API builds returned only the changed field (or wiped the privacySettings
+        // subdocument when handed a partial update), which would clobber every
+        // other toggle if we blindly replaced. Defensive merge means the UI stays
+        // consistent regardless of server behaviour.
+        //
+        // BOTH the privacy.settings query AND the accounts.current() user are
+        // gated on `targetUserId`. If it's missing (no userId param, no logged-in
+        // user) the optimistic update in onMutate would have early-returned too,
+        // so neither cache was ever touched — there's nothing to reconcile here.
+        onSuccess: (data, { userId, settings }) => {
             const targetUserId = userId || user?.id;
-            if (targetUserId) {
-                queryClient.setQueryData(queryKeys.privacy.settings(targetUserId), data);
-            }
-            // Also update account query if it contains privacy settings
+            if (!targetUserId)
+                return;
+            const incoming = (data ?? {});
+            const requested = (settings ?? {});
+            queryClient.setQueryData(queryKeys.privacy.settings(targetUserId), (previous) => ({
+                ...(previous ?? {}),
+                ...requested,
+                ...incoming, // server wins for fields it explicitly returned
+            }));
             const currentUser = queryClient.getQueryData(queryKeys.accounts.current());
             if (currentUser) {
                 const updatedUser = {
                     ...currentUser,
-                    privacySettings: data,
+                    privacySettings: {
+                        ...(currentUser.privacySettings ?? {}),
+                        ...requested,
+                        ...incoming,
+                    },
                 };
                 queryClient.setQueryData(queryKeys.accounts.current(), updatedUser);
-                // Update authStore so frontend components see the changes immediately
                 useAuthStore.getState().setUser(updatedUser);
             }
-            invalidateAccountQueries(queryClient);
-        },
-        // Always refetch after error or success
-        onSettled: (data, error, { userId }) => {
-            const targetUserId = userId || user?.id;
-            if (targetUserId) {
-                queryClient.invalidateQueries({ queryKey: queryKeys.privacy.settings(targetUserId) });
-            }
-            queryClient.invalidateQueries({ queryKey: queryKeys.accounts.current() });
+            // Deliberately NOT invalidating any queries here. invalidateAccountQueries
+            // invalidates accounts.all which is the prefix for accounts.current(),
+            // triggering a background refetch of useCurrentUser that would overwrite
+            // the merged state above. The onSuccess merge is the source of truth.
         },
     });
 };

package/dist/esm/hooks/queryClient.js

@@ -1,104 +1,147 @@
+/**
+ * Web QueryClient with offline-first defaults + localStorage persistence.
+ *
+ * Mirrors the persistence behaviour in `@oxyhq/services/queryClient` so
+ * web auth apps (FedCM, popup, redirect flows) survive a page reload with
+ * cached identity + paused mutations intact.
+ *
+ * Persistence is opt-in via `attachQueryPersistence(...)` so SSR callers
+ * (Next.js getServerSideProps, Vite SSR, tests) can create a stateless
+ * client without touching `window`.
+ */
 import { QueryClient } from '@tanstack/react-query';
-const QUERY_CACHE_KEY = 'oxy_query_cache';
-const QUERY_CACHE_VERSION = '1';
+import { persistQueryClient, } from '@tanstack/react-query-persist-client';
+import { createSyncStoragePersister } from '@tanstack/query-sync-storage-persister';
+const QUERY_CACHE_KEY = 'oxy_auth_query_cache_v2';
+const QUERY_CACHE_MAX_AGE = 30 * 24 * 60 * 60 * 1000;
+const QUERY_PERSIST_THROTTLE_MS = 1000;
 /**
- * Custom persistence adapter for TanStack Query using our StorageInterface
+ * Query-key prefixes whose data is safe to restore across reloads.
+ * Web auth surfaces are session/profile heavy — lists and history are not
+ * persisted to keep the localStorage footprint small.
  */
-export const createPersistenceAdapter = (storage) => {
-    return {
-        persistClient: async (client) => {
-            try {
-                const serialized = JSON.stringify({
-                    clientState: client,
-                    timestamp: Date.now(),
-                    version: QUERY_CACHE_VERSION,
-                });
-                await storage.setItem(QUERY_CACHE_KEY, serialized);
-            }
-            catch (error) {
-                if (process.env.NODE_ENV !== 'production') {
-                    console.warn('[QueryClient] Failed to persist cache:', error);
-                }
+const PERSISTED_QUERY_PREFIXES = [
+    'accounts',
+    'users',
+    'sessions',
+    'auth',
+];
+function shouldDehydrateQuery(query) {
+    if (query.state.status !== 'success')
+        return false;
+    const head = query.queryKey[0];
+    return typeof head === 'string' && PERSISTED_QUERY_PREFIXES.includes(head);
+}
+function shouldDehydrateMutation(_mutation) {
+    return true;
+}
+/**
+ * Best-effort detection — works in browsers, Node SSR, and React Server
+ * Components. `localStorage` is gated behind `window` because Node and edge
+ * runtimes may polyfill `globalThis.localStorage` inconsistently.
+ */
+function getBrowserLocalStorage() {
+    if (typeof window === 'undefined')
+        return null;
+    try {
+        if (!window.localStorage)
+            return null;
+        return window.localStorage;
+    }
+    catch {
+        // Access blocked (Safari Private Mode, sandboxed iframe, etc.)
+        return null;
+    }
+}
+export const createPersistenceAdapter = (storage) => ({
+    persistClient: async (client) => {
+        try {
+            await storage.setItem(QUERY_CACHE_KEY, JSON.stringify(client));
+        }
+        catch (error) {
+            if (process.env.NODE_ENV !== 'production') {
+                console.warn('[QueryClient] Failed to persist cache', error);
             }
-        },
-        restoreClient: async () => {
-            try {
-                const cached = await storage.getItem(QUERY_CACHE_KEY);
-                if (!cached)
-                    return undefined;
-                const parsed = JSON.parse(cached);
-                // Check version compatibility
-                if (parsed.version !== QUERY_CACHE_VERSION) {
-                    // Clear old cache on version mismatch
-                    await storage.removeItem(QUERY_CACHE_KEY);
-                    return undefined;
-                }
-                // Check if cache is too old (30 days)
-                const maxAge = 30 * 24 * 60 * 60 * 1000;
-                if (parsed.timestamp && Date.now() - parsed.timestamp > maxAge) {
-                    await storage.removeItem(QUERY_CACHE_KEY);
-                    return undefined;
-                }
-                return parsed.clientState;
+        }
+    },
+    restoreClient: async () => {
+        try {
+            const cached = await storage.getItem(QUERY_CACHE_KEY);
+            return cached ? JSON.parse(cached) : undefined;
+        }
+        catch (error) {
+            if (process.env.NODE_ENV !== 'production') {
+                console.warn('[QueryClient] Failed to restore cache', error);
             }
-            catch (error) {
-                if (process.env.NODE_ENV !== 'production') {
-                    console.warn('[QueryClient] Failed to restore cache:', error);
-                }
-                return undefined;
+            return undefined;
+        }
+    },
+    removeClient: async () => {
+        try {
+            await storage.removeItem(QUERY_CACHE_KEY);
+        }
+        catch (error) {
+            if (process.env.NODE_ENV !== 'production') {
+                console.warn('[QueryClient] Failed to remove cache', error);
             }
+        }
+    },
+});
+export const createQueryClient = () => new QueryClient({
+    defaultOptions: {
+        queries: {
+            staleTime: 5 * 60 * 1000,
+            gcTime: 30 * 60 * 1000,
+            retry: 3,
+            retryDelay: (attempt) => Math.min(1000 * 2 ** attempt, 30000),
+            refetchOnReconnect: true,
+            refetchOnWindowFocus: false,
+            networkMode: 'offlineFirst',
         },
-        removeClient: async () => {
-            try {
-                await storage.removeItem(QUERY_CACHE_KEY);
-            }
-            catch (error) {
-                if (process.env.NODE_ENV !== 'production') {
-                    console.warn('[QueryClient] Failed to remove cache:', error);
-                }
-            }
+        mutations: {
+            retry: 1,
+            networkMode: 'offlineFirst',
         },
-    };
-};
+    },
+});
 /**
- * Create a QueryClient with offline-first configuration
+ * Wire `persistQueryClient` to browser `localStorage` (or a no-op when not
+ * in a browser). Returns the restore promise so consumers can `await` it
+ * before exposing the client to <Suspense> boundaries.
  */
-export const createQueryClient = (storage) => {
-    const client = new QueryClient({
-        defaultOptions: {
-            queries: {
-                // Data is fresh for 5 minutes
-                staleTime: 5 * 60 * 1000,
-                // Keep unused data in cache for 10 minutes
-                gcTime: 10 * 60 * 1000,
-                // Retry 3 times with exponential backoff
-                retry: 3,
-                retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000),
-                // Refetch on reconnect
-                refetchOnReconnect: true,
-                // Don't refetch on window focus (better for mobile)
-                refetchOnWindowFocus: false,
-                // Offline-first: use cache when offline
-                networkMode: 'offlineFirst',
-            },
-            mutations: {
-                // Retry once for mutations
-                retry: 1,
-                // Offline-first: queue mutations when offline
-                networkMode: 'offlineFirst',
-            },
+export const attachQueryPersistence = (queryClient) => {
+    const localStorage = getBrowserLocalStorage();
+    if (!localStorage) {
+        return { restored: Promise.resolve(), unsubscribe: () => { } };
+    }
+    const persister = createSyncStoragePersister({
+        storage: localStorage,
+        key: QUERY_CACHE_KEY,
+        throttleTime: QUERY_PERSIST_THROTTLE_MS,
+    });
+    const [unsubscribe, restored] = persistQueryClient({
+        queryClient,
+        persister,
+        maxAge: QUERY_CACHE_MAX_AGE,
+        dehydrateOptions: {
+            shouldDehydrateQuery,
+            shouldDehydrateMutation,
         },
     });
-    // Note: Persistence is handled by TanStack Query's built-in persistence
-    // For now, we rely on the query client's default behavior with networkMode: 'offlineFirst'
-    // The cache will be available in memory and queries will use cached data when offline
-    // Full persistence to AsyncStorage can be added later with @tanstack/react-query-persist-client if needed
-    return client;
+    restored.catch((error) => {
+        if (process.env.NODE_ENV !== 'production') {
+            console.warn('[QueryClient] Failed to restore persisted cache', error);
+        }
+    });
+    return { unsubscribe, restored };
 };
-/**
- * Clear persisted query cache
- */
 export const clearQueryCache = async (storage) => {
-    const adapter = createPersistenceAdapter(storage);
-    await adapter.removeClient();
+    try {
+        await storage.removeItem(QUERY_CACHE_KEY);
+    }
+    catch (error) {
+        if (process.env.NODE_ENV !== 'production') {
+            console.warn('[QueryClient] Failed to remove cache', error);
+        }
+    }
 };