@oxyhq/auth 2.0.4 → 2.0.6

package/dist/cjs/hooks/queries/useAppData.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * App-Data Query Hooks
+ *
+ * Read side of the `/users/me/app-data/...` per-user JSON KV store. Gated on
+ * `isAuthenticated` — when signed out the query stays `enabled: false` and
+ * `data` is `null`, so consumers can fall back to localStorage without ever
+ * issuing a doomed request.
+ *
+ * Errors from the network (404 because the endpoint isn't deployed yet,
+ * 401 because the session lapsed, etc.) are not user-facing here. Hooks
+ * return `data: null` on error so the calling component renders the
+ * "nothing yet" state and the consuming app can quietly fall back to local
+ * persistence. Mutations still propagate errors so write attempts surface
+ * a toast — only reads are silent.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAppDataNamespace = exports.useAppData = void 0;
+const react_query_1 = require("@tanstack/react-query");
+const core_1 = require("@oxyhq/core");
+const WebOxyProvider_1 = require("../../WebOxyProvider");
+const appDataQueryKeys_1 = require("./appDataQueryKeys");
+/**
+ * Read a single per-user JSON value.
+ *
+ * @param namespace - kebab/snake-case identifier (e.g. `"academy"`).
+ * @param key       - kebab/snake-case identifier (e.g. course slug).
+ * @param options   - optional `enabled`/`staleTime`/`gcTime` overrides.
+ *
+ * @returns A `useQuery` result with `data` of type `T | null`. The query
+ *   stays disabled when the user is signed out; when enabled but the server
+ *   has no stored value, `data` is `null`. Reads that fail because the
+ *   endpoint isn't reachable also resolve to `null` so the consumer can
+ *   fall back to local persistence.
+ */
+const useAppData = (namespace, key, options) => {
+    const { oxyServices, activeSessionId, isAuthenticated } = (0, WebOxyProvider_1.useWebOxy)();
+    return (0, react_query_1.useQuery)({
+        queryKey: appDataQueryKeys_1.appDataQueryKeys.value(namespace, key),
+        queryFn: async () => {
+            try {
+                return await (0, core_1.authenticatedApiCall)(oxyServices, activeSessionId, () => oxyServices.getAppData(namespace, key));
+            }
+            catch (error) {
+                // Endpoint not deployed yet, no network, etc. — return null so the
+                // consumer falls back to localStorage rather than rendering a broken
+                // UI state. Authentication errors still bubble up so the auth retry
+                // pipeline can surface them at the provider level.
+                if ((0, appDataQueryKeys_1.isMissingAppDataEndpointError)(error)) {
+                    return null;
+                }
+                throw error;
+            }
+        },
+        enabled: (options?.enabled !== false) && isAuthenticated,
+        staleTime: options?.staleTime ?? 60 * 1000,
+        gcTime: options?.gcTime ?? 30 * 60 * 1000,
+    });
+};
+exports.useAppData = useAppData;
+/**
+ * Read every value in a namespace.
+ *
+ * @returns A `useQuery` result with `data` as a `Record<string, T>`. Empty
+ *   object when the namespace contains nothing (or when fetching failed).
+ */
+const useAppDataNamespace = (namespace, options) => {
+    const { oxyServices, activeSessionId, isAuthenticated } = (0, WebOxyProvider_1.useWebOxy)();
+    return (0, react_query_1.useQuery)({
+        queryKey: appDataQueryKeys_1.appDataQueryKeys.namespace(namespace),
+        queryFn: async () => {
+            try {
+                return await (0, core_1.authenticatedApiCall)(oxyServices, activeSessionId, () => oxyServices.listAppData(namespace));
+            }
+            catch (error) {
+                if ((0, appDataQueryKeys_1.isMissingAppDataEndpointError)(error)) {
+                    return {};
+                }
+                throw error;
+            }
+        },
+        enabled: (options?.enabled !== false) && isAuthenticated,
+        staleTime: options?.staleTime ?? 60 * 1000,
+        gcTime: options?.gcTime ?? 30 * 60 * 1000,
+    });
+};
+exports.useAppDataNamespace = useAppDataNamespace;

package/dist/cjs/hooks/queryClient.js

@@ -1,110 +1,154 @@
 "use strict";
+/**
+ * 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`.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearQueryCache = exports.createQueryClient = exports.createPersistenceAdapter = void 0;
+exports.clearQueryCache = exports.attachQueryPersistence = exports.createQueryClient = exports.createPersistenceAdapter = void 0;
 const react_query_1 = require("@tanstack/react-query");
-const QUERY_CACHE_KEY = 'oxy_query_cache';
-const QUERY_CACHE_VERSION = '1';
+const react_query_persist_client_1 = require("@tanstack/react-query-persist-client");
+const query_sync_storage_persister_1 = require("@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.
  */
-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);
+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;
+    }
+}
+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);
             }
-            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);
+            return cached ? JSON.parse(cached) : undefined;
+        }
+        catch (error) {
+            if (process.env.NODE_ENV !== 'production') {
+                console.warn('[QueryClient] Failed to restore 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;
-            }
-            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);
             }
+        }
+    },
+});
+exports.createPersistenceAdapter = createPersistenceAdapter;
+const createQueryClient = () => new react_query_1.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',
         },
-    };
-};
-exports.createPersistenceAdapter = createPersistenceAdapter;
+    },
+});
+exports.createQueryClient = createQueryClient;
 /**
- * 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.
  */
-const createQueryClient = (storage) => {
-    const client = new react_query_1.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',
-            },
+const attachQueryPersistence = (queryClient) => {
+    const localStorage = getBrowserLocalStorage();
+    if (!localStorage) {
+        return { restored: Promise.resolve(), unsubscribe: () => { } };
+    }
+    const persister = (0, query_sync_storage_persister_1.createSyncStoragePersister)({
+        storage: localStorage,
+        key: QUERY_CACHE_KEY,
+        throttleTime: QUERY_PERSIST_THROTTLE_MS,
+    });
+    const [unsubscribe, restored] = (0, react_query_persist_client_1.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 };
 };
-exports.createQueryClient = createQueryClient;
-/**
- * Clear persisted query cache
- */
+exports.attachQueryPersistence = attachQueryPersistence;
 const clearQueryCache = async (storage) => {
-    const adapter = (0, exports.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);
+        }
+    }
 };
 exports.clearQueryCache = clearQueryCache;

package/dist/cjs/hooks/useFileDownloadUrl.js

@@ -1,42 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useFileDownloadUrl = exports.setOxyFileUrlInstance = void 0;
+exports.useFileDownloadUrl = void 0;
 const react_1 = require("react");
-const core_1 = require("@oxyhq/core");
-let oxyInstance = null;
-const setOxyFileUrlInstance = (instance) => {
-    oxyInstance = instance;
-};
-exports.setOxyFileUrlInstance = setOxyFileUrlInstance;
 /**
  * Hook to resolve a file's download URL asynchronously.
  *
- * Prefers the provided `oxyServices` instance, falls back to the module-level
- * singleton set via `setOxyFileUrlInstance`.
- *
  * Uses `getFileDownloadUrlAsync` first, falling back to the synchronous
  * `getFileDownloadUrl` if the async call fails.
  */
-const useFileDownloadUrl = (fileIdOrServices, fileIdOrOptions, maybeOptions) => {
-    // Support two call signatures:
-    // 1. useFileDownloadUrl(oxyServices, fileId, options)  — preferred
-    // 2. useFileDownloadUrl(fileId, options)               — legacy (uses singleton)
-    let services;
-    let fileId;
-    let options;
-    if (fileIdOrServices instanceof core_1.OxyServices) {
-        services = fileIdOrServices;
-        fileId = typeof fileIdOrOptions === 'string' ? fileIdOrOptions : null;
-        options = maybeOptions;
-    }
-    else {
-        services = oxyInstance;
-        fileId = typeof fileIdOrServices === 'string' ? fileIdOrServices : null;
-        options = typeof fileIdOrOptions === 'object' && fileIdOrOptions !== null ? fileIdOrOptions : undefined;
-    }
+const useFileDownloadUrl = (oxyServices, fileId, options) => {
     const [url, setUrl] = (0, react_1.useState)(null);
     const [loading, setLoading] = (0, react_1.useState)(false);
     const [error, setError] = (0, react_1.useState)(null);
+    const variant = options?.variant;
+    const expiresIn = options?.expiresIn;
     (0, react_1.useEffect)(() => {
         if (!fileId) {
             setUrl(null);
@@ -44,25 +21,25 @@ const useFileDownloadUrl = (fileIdOrServices, fileIdOrOptions, maybeOptions) =>
             setError(null);
             return;
         }
-        if (!services) {
+        if (!oxyServices) {
             setUrl(null);
             setLoading(false);
             setError(new Error('OxyServices instance not configured for useFileDownloadUrl'));
             return;
         }
         let cancelled = false;
-        const instance = services;
+        const instance = oxyServices;
+        const targetFileId = fileId;
         const load = async () => {
             setLoading(true);
             setError(null);
             try {
-                const { variant, expiresIn } = options || {};
                 let resolvedUrl = null;
                 if (typeof instance.getFileDownloadUrlAsync === 'function') {
-                    resolvedUrl = await instance.getFileDownloadUrlAsync(fileId, variant, expiresIn);
+                    resolvedUrl = await instance.getFileDownloadUrlAsync(targetFileId, variant, expiresIn);
                 }
                 if (!resolvedUrl && typeof instance.getFileDownloadUrl === 'function') {
-                    resolvedUrl = instance.getFileDownloadUrl(fileId, variant, expiresIn);
+                    resolvedUrl = instance.getFileDownloadUrl(targetFileId, variant, expiresIn);
                 }
                 if (!cancelled) {
                     setUrl(resolvedUrl || null);
@@ -72,8 +49,7 @@ const useFileDownloadUrl = (fileIdOrServices, fileIdOrOptions, maybeOptions) =>
                 // Fallback to sync URL on error where possible
                 try {
                     if (typeof instance.getFileDownloadUrl === 'function') {
-                        const { variant, expiresIn } = options || {};
-                        const fallbackUrl = instance.getFileDownloadUrl(fileId, variant, expiresIn);
+                        const fallbackUrl = instance.getFileDownloadUrl(targetFileId, variant, expiresIn);
                         if (!cancelled) {
                             setUrl(fallbackUrl || null);
                             setError(err instanceof Error ? err : new Error(String(err)));
@@ -82,7 +58,7 @@ const useFileDownloadUrl = (fileIdOrServices, fileIdOrOptions, maybeOptions) =>
                     }
                 }
                 catch {
-                    // ignore secondary failure
+                    // Secondary failure: surface the original error below.
                 }
                 if (!cancelled) {
                     setError(err instanceof Error ? err : new Error(String(err)));
@@ -98,7 +74,7 @@ const useFileDownloadUrl = (fileIdOrServices, fileIdOrOptions, maybeOptions) =>
         return () => {
             cancelled = true;
         };
-    }, [fileId, services, options?.variant, options?.expiresIn]);
+    }, [fileId, oxyServices, variant, expiresIn]);
     return { url, loading, error };
 };
 exports.useFileDownloadUrl = useFileDownloadUrl;