authera 2.0.6 → 2.2.0

package/dist/helper/axios.d.ts

@@ -0,0 +1,10 @@
+import { type AxiosInstance } from "axios";
+import type { customeFunc } from "./storage";
+import type { AuthHookSettings } from "./types";
+/**
+ * Create a preconfigured Axios instance that:
+ * - Attaches Authorization header from storage on each request
+ * - On 401 responses, attempts token refresh and retries the original request
+ * - If refresh fails, redirects to fallback_401_url
+ */
+export default function createAxios<T extends string>(storage: customeFunc, settings: AuthHookSettings<T>): AxiosInstance;

package/dist/helper/axios.js

@@ -0,0 +1,105 @@
+"use client";
+import axios from "axios";
+/**
+ * Create a preconfigured Axios instance that:
+ * - Attaches Authorization header from storage on each request
+ * - On 401 responses, attempts token refresh and retries the original request
+ * - If refresh fails, redirects to fallback_401_url
+ */
+export default function createAxios(storage, settings) {
+    const instance = axios.create({
+        baseURL: settings.backendUrl,
+    });
+    // Single-flight refresh across concurrent 401s
+    let refreshPromise = null;
+    const readAccessToken = () => {
+        try {
+            const token = storage.get("access_token");
+            return token || null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const readRefreshToken = () => {
+        try {
+            const token = storage.get("refresh_token");
+            return token || null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const writeTokens = (access, refresh) => {
+        if (access)
+            storage.set("access_token", access);
+        if (refresh)
+            storage.set("refresh_token", refresh);
+    };
+    const resolveAccessFromResponse = (data) => {
+        return data?.access_token ?? data?.accessToken ?? data?.token ?? null;
+    };
+    const resolveRefreshFromResponse = (data) => {
+        return data?.refresh_token ?? data?.refreshToken ?? null;
+    };
+    const doRefresh = async () => {
+        const token = readRefreshToken();
+        if (!token)
+            return null;
+        try {
+            // Use a bare client to avoid interceptor recursion
+            const client = axios.create({ baseURL: settings.backendUrl });
+            const resp = await client.post("auth/refresh/", { refresh_token: token });
+            const newAccess = resolveAccessFromResponse(resp.data);
+            const newRefresh = resolveRefreshFromResponse(resp.data);
+            writeTokens(newAccess, newRefresh);
+            return newAccess;
+        }
+        catch {
+            return null;
+        }
+    };
+    const getOrStartRefresh = () => {
+        if (!refreshPromise) {
+            refreshPromise = doRefresh().finally(() => {
+                // allow subsequent refreshes
+                refreshPromise = null;
+            });
+        }
+        return refreshPromise;
+    };
+    // Attach Authorization header on each request
+    instance.interceptors.request.use((config) => {
+        const access = readAccessToken();
+        if (access) {
+            config.headers = {
+                ...config.headers,
+                Authorization: `Bearer ${access}`,
+            };
+        }
+        return config;
+    });
+    // Handle 401 responses with token refresh
+    instance.interceptors.response.use((response) => response, async (error) => {
+        const responseStatus = error.response?.status;
+        const originalConfig = (error.config || {});
+        if (responseStatus === 401 && !originalConfig._retry) {
+            originalConfig._retry = true;
+            const newAccess = await getOrStartRefresh();
+            if (newAccess) {
+                originalConfig.headers = {
+                    ...(originalConfig.headers || {}),
+                    Authorization: `Bearer ${newAccess}`,
+                };
+                // retry original request with new token
+                return instance.request(originalConfig);
+            }
+            // refresh failed: redirect to login/fallback
+            if (typeof window !== "undefined" && settings.fallback_401_url) {
+                window.location.href = settings.fallback_401_url;
+            }
+        }
+        return Promise.reject(error);
+    });
+    return instance;
+}

package/dist/index.d.ts

@@ -26,6 +26,10 @@ export default function AuthHook<T extends string>(props: AuthHookSettings<T>):
         setRefreshToken: (token: string) => void;
         logout: () => void;
     };
-    LoginScenario: () => import("react/jsx-runtime").JSX.Element;
+    axios: import("axios").AxiosInstance;
+    LoginScenario: (prop: {
+        submitButtonClassName?: string;
+        submitButtonText?: string;
+    }) => import("react/jsx-runtime").JSX.Element;
 };
 export { default as AuthGuard } from "./web/guard";

package/dist/index.js

@@ -4,16 +4,19 @@ import { name2storage } from "./helper/storage";
 import AuthProvider from "./web";
 import { useAuth } from "./hooks/useAuth";
 import LoginForm from "./web/login";
+import createAxios from "./helper/axios";
 export default function AuthHook(props) {
     // set storage functions
     let storage = props.storage;
     if (typeof storage === "string")
         storage = name2storage(storage);
     // create backend data
+    const axios = createAxios(storage, props);
     return {
         createAuthProvider: (children) => (_jsx(AuthProvider, { storage: storage, authera_props: props, children: children })),
         useAuth: () => useAuth(),
-        LoginScenario: () => (_jsx(LoginForm, { on_after_login: props.on_after_login, on_after_step: props.on_after_step, backendUrl: props.backendUrl })),
+        axios,
+        LoginScenario: (prop) => (_jsx(LoginForm, { on_after_login: props.on_after_login, on_after_step: props.on_after_step, backendUrl: props.backendUrl, submitButtonClassName: prop.submitButtonClassName, submitButtonText: prop.submitButtonText })),
     };
 }
 export { default as AuthGuard } from "./web/guard";

package/dist/web/login.d.ts

@@ -2,6 +2,8 @@ interface LoginFormProps {
     on_after_login?: (response_data: any) => void;
     on_after_step?: (step_key: string) => void;
     backendUrl: string;
+    submitButtonClassName?: string;
+    submitButtonText?: string;
 }
-export default function LoginForm({ on_after_login, on_after_step, backendUrl, }: LoginFormProps): import("react/jsx-runtime").JSX.Element;
+export default function LoginForm({ on_after_login, on_after_step, backendUrl, submitButtonClassName, submitButtonText, }: LoginFormProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/web/login.js

@@ -2,11 +2,12 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import axios from "axios";
 import { convertFromSchema } from "minimal-form";
-import EasyForm from "minimal-form";
 import { useEffect, useState } from "react";
 import { useForm } from "react-hook-form";
 import { useAuth } from "../hooks/useAuth";
-export default function LoginForm({ on_after_login, on_after_step, backendUrl, }) {
+import EasyFormModule from "minimal-form";
+const EasyForm = EasyFormModule.default || EasyFormModule;
+export default function LoginForm({ on_after_login, on_after_step, backendUrl, submitButtonClassName, submitButtonText, }) {
     const [steps, stepsHnadler] = useState();
     const [activeStep, activeStepHandler] = useState();
     const [loading, loadingHandler] = useState(true);
@@ -15,7 +16,7 @@ export default function LoginForm({ on_after_login, on_after_step, backendUrl, }
     const { handleSubmit, control } = useForm();
     const { setUserData, setPermits } = useAuth();
     const request = axios.create({
-        baseURL: backendUrl,
+        baseURL: backendUrl + "/auth",
     });
     // fetch data from steps
     useEffect(() => {
@@ -63,5 +64,5 @@ export default function LoginForm({ on_after_login, on_after_step, backendUrl, }
     if (loading)
         return _jsx("p", { children: "loading ..." });
     // show forms from steps
-    return (_jsxs("form", { onSubmit: handleSubmit(onSubmit), children: [_jsx(EasyForm, { control: control, structure: activeStep.structure }), _jsx("button", { type: "submit", children: "Submit" })] }));
+    return (_jsxs("form", { onSubmit: handleSubmit(onSubmit), children: [_jsx(EasyForm, { control: control, structure: activeStep?.structure || {} }), _jsx("button", { type: "submit", className: submitButtonClassName, children: submitButtonText })] }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "authera",
-  "version": "2.0.6",
+  "version": "2.2.0",
   "description": "this project is a simple auth hook for react",
   "type": "module",
   "main": "dist/index.js",