@kawaiininja/fetch 1.0.59 → 1.0.60

package/dist/hooks/useCsrf.d.ts

@@ -1,4 +1,8 @@
-export declare function useCsrf(): {
-    fetchCSRF: () => Promise<string>;
+export interface CsrfOptions {
+    force?: boolean;
+}
+export interface CsrfResult {
+    fetchCSRF: (options?: CsrfOptions) => Promise<string>;
     clearCsrf: () => Promise<void>;
-};
+}
+export declare function useCsrf(): CsrfResult;

package/dist/hooks/useCsrf.js

@@ -2,80 +2,100 @@ import { useCallback, useRef } from "react";
 import { INTERNAL_HEADER } from "../context/ApiContext";
 import { isNative } from "./platform";
 import { useApiConfig } from "./useApiConfig";
+// --- Helpers ---
+const getFromStorage = (debug) => {
+    if (typeof window === "undefined")
+        return null;
+    const stored = localStorage.getItem("csrf_token");
+    if (stored && debug)
+        console.log("[useCsrf] Retrieved from localStorage.");
+    return stored || null;
+};
+const saveToStorage = (token) => {
+    if (typeof window !== "undefined") {
+        localStorage.setItem("csrf_token", token);
+    }
+};
+const fetchFromNetwork = async (apiUrl, debug) => {
+    if (debug)
+        console.log("[useCsrf] Fetching new CSRF token from server...");
+    const csrfUrl = apiUrl("auth/csrf-token");
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 15000);
+    try {
+        const res = await fetch(csrfUrl, {
+            method: "GET",
+            headers: INTERNAL_HEADER,
+            credentials: "include",
+            signal: controller.signal,
+        });
+        if (!res.ok)
+            throw new Error(`CSRF HTTP Error: ${res.status}`);
+        const json = await res.json();
+        const token = json?.csrfToken;
+        if (!token)
+            throw new Error("Missing CSRF token in response");
+        return token;
+    }
+    catch (error) {
+        if (debug)
+            console.error("[useCsrf] Network Error:", error);
+        throw error;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+};
+// --- Hook ---
 export function useCsrf() {
     const { apiUrl, debug, disableCsrf } = useApiConfig();
     const csrfRef = useRef(null);
+    const csrfPromiseRef = useRef(null);
     const clearCsrf = useCallback(async () => {
         if (isNative() || disableCsrf)
             return;
         if (debug)
             console.log("[useCsrf] Clearing CSRF token...");
         csrfRef.current = null;
-        if (typeof window !== "undefined") {
+        if (typeof window !== "undefined")
             localStorage.removeItem("csrf_token");
-        }
     }, [debug, disableCsrf]);
-    const csrfPromiseRef = useRef(null);
-    const fetchCSRF = useCallback(async () => {
-        console.log(`[useCsrf] fetchCSRF invoked. disableCsrf: ${disableCsrf}`);
+    const fetchCSRF = useCallback(async (options) => {
+        const { force = false } = options || {};
         if (isNative() || disableCsrf) {
-            console.log(`[useCsrf] Skipping CSRF. Platform: ${isNative() ? "Native" : "Web"}, Disabled: ${disableCsrf}`);
+            if (debug)
+                console.log(`[useCsrf] Skipped (Platform/Config)`);
             return "";
         }
-        if (csrfRef.current)
+        // 1. Memory Cache
+        if (!force && csrfRef.current)
             return csrfRef.current;
-        if (csrfPromiseRef.current)
+        if (!force && csrfPromiseRef.current)
             return csrfPromiseRef.current;
-        csrfPromiseRef.current = (async () => {
-            // Try to get from storage first
-            if (typeof window !== "undefined") {
-                const storedCsrf = localStorage.getItem("csrf_token");
-                if (storedCsrf) {
-                    if (debug)
-                        console.log("[useCsrf] Retrieved from localStorage.");
-                    csrfRef.current = storedCsrf;
-                    return storedCsrf;
+        const task = async () => {
+            // 2. Storage Cache
+            if (!force) {
+                const stored = getFromStorage(debug);
+                if (stored) {
+                    csrfRef.current = stored;
+                    return stored;
                 }
             }
-            // Construct CSRF URL using the context's baseUrl
-            if (debug)
-                console.log("[useCsrf] Fetching new CSRF token from server...");
-            const csrfUrl = apiUrl("auth/csrf-token");
-            const CSRF_TIMEOUT_MS = 15000;
-            const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), CSRF_TIMEOUT_MS);
-            try {
-                const res = await fetch(csrfUrl, {
-                    method: "GET",
-                    headers: INTERNAL_HEADER,
-                    credentials: "include",
-                    signal: controller.signal,
-                });
-                clearTimeout(timeoutId);
-                if (!res.ok) {
-                    throw new Error(`CSRF Fetch failed with status: ${res.status}`);
-                }
-                const json = await res.json();
-                const token = json?.csrfToken;
-                if (!token)
-                    throw new Error("Missing CSRF token in response");
-                csrfRef.current = token;
-                // Store in storage
-                if (typeof window !== "undefined") {
-                    localStorage.setItem("csrf_token", token);
-                }
-                return token;
-            }
-            catch (error) {
-                clearTimeout(timeoutId);
-                console.error("[useCsrf] CSRF Fetch Failed/Timed-out:", error);
-                throw error;
-            }
-            finally {
+            // 3. Network Fetch
+            const newToken = await fetchFromNetwork(apiUrl, debug);
+            csrfRef.current = newToken;
+            saveToStorage(newToken);
+            return newToken;
+        };
+        const promise = task();
+        // Cleanup ref on completion
+        const chained = promise.finally(() => {
+            if (csrfPromiseRef.current === chained) {
                 csrfPromiseRef.current = null;
             }
-        })();
-        return csrfPromiseRef.current;
+        });
+        csrfPromiseRef.current = chained;
+        return chained;
     }, [apiUrl, debug, disableCsrf]);
     return { fetchCSRF, clearCsrf };
 }

package/dist/hooks/useFetch.js

@@ -70,7 +70,7 @@ export const useFetch = (endpoint, baseOptions = {}) => {
                     if (debug)
                         console.log(`[useFetch] 🔄 CSRF Error on ${reqId}. Retrying with fresh token...`);
                     await clearCsrf();
-                    token = await fetchCSRF();
+                    token = await fetchCSRF({ force: true });
                     res = await performFetch(finalUrl, params.method || "GET", token, params.body, params.headers, { ...stableOptions, ...params }, debug, abortRef.current.signal, apiUrl);
                     parsed = await parseResponse(res, params.parseAs || "auto");
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kawaiininja/fetch",
-    "version": "1.0.59",
+    "version": "1.0.60",
     "description": "Core fetch utility for Onyx Framework",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",