@fluoce/auth-react 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,276 +1,371 @@
-// src/FluoceAuthProvider.tsx
+// src/provider/auth_provider.tsx
 import {
-  useCallback,
-  useEffect,
-  useMemo,
-  useRef,
-  useState
+  useMemo as use_memo,
+  useState as use_state,
+  useEffect as use_effect
 } from "react";
 
-// src/AuthContext.tsx
-import { createContext, useContext } from "react";
-var FluoceAuthContext = createContext(
-  null
-);
-function useFluoceAuth() {
-  const ctx = useContext(FluoceAuthContext);
-  if (!ctx)
-    throw new Error("useFluoceAuth must be used within <FluoceAuthProvider>");
-  return ctx;
-}
+// src/const/api_endpoint.ts
+var base_url = "https://auth-service.fluoce.com";
+var api_endpoint = {
+  me: "/me",
+  exchange: "/exchange",
+  refresh: "/refresh",
+  logout: "/logout"
+};
+
+// src/const/route.ts
+var route = {
+  fluoce_auth: (ref) => `https://auth.fluoce.com/auth?ref=${ref}`
+};
 
-// src/cookies.ts
-function setCookie(name, value, days) {
+// src/func/func_cookies.ts
+function func_set_cookie(name, value, days) {
   const expires = new Date(Date.now() + days * 864e5).toUTCString();
   document.cookie = `${name}=${encodeURIComponent(value)}; expires=${expires}; path=/; SameSite=Lax`;
 }
-function getCookie(name) {
+function func_get_cookie(name) {
   const escaped = name.replace(/([.$?*|{}()[\]\\/+^])/g, "\\$1");
-  const match = document.cookie.match(new RegExp("(?:^|; )" + escaped + "=([^;]*)"));
+  const match = document.cookie.match(
+    new RegExp("(?:^|; )" + escaped + "=([^;]*)")
+  );
   return match ? decodeURIComponent(match[1]) : null;
 }
-function deleteCookie(name) {
-  document.cookie = `${name}=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/`;
+function func_delete_cookie(name) {
+  document.cookie = `${name}=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/; SameSite=Lax`;
+}
+
+// src/func/func_try_catch.ts
+async function func_try_catch({
+  fn,
+  onError
+}) {
+  try {
+    return await fn();
+  } catch (error) {
+    if (onError) {
+      onError(error);
+      return null;
+    }
+    if (error instanceof Error) {
+      throw error;
+    } else {
+      throw new Error(String(error));
+    }
+  }
 }
 
-// src/apiClient.ts
-var FluoceApiClient = class {
-  constructor(config) {
-    this.refreshPromise = null;
-    /** set by the Provider — called once refresh fails and there's no session left */
-    this.onAuthFailure = () => {
+// src/api/api_service.ts
+var Api_service = class {
+  constructor({
+    app_url,
+    on_error,
+    redirect
+  }, http = fetch) {
+    this.http = http;
+    this.base_url = base_url;
+    this.api_endpoint = api_endpoint;
+    this.redirect = {
+      type: "fluoce"
     };
-    this.config = {
-      accessTokenCookie: "fluoce_access_token",
-      refreshTokenCookie: "fluoce_refresh_token",
-      accessTokenExpiryDays: 1,
-      refreshTokenExpiryDays: 30,
-      ...config
+    this.redirect_at_fluoce_auth = (error) => {
+      console.warn(error);
+      window.location.replace(route.fluoce_auth(this.app_url));
     };
+    this.handle_redirect = (error) => {
+      var _a;
+      switch ((_a = this.redirect) == null ? void 0 : _a.type) {
+        case "fluoce":
+          this.redirect_at_fluoce_auth(error);
+          break;
+        case "custom":
+          this.redirect.redirect(error);
+          break;
+        case "none":
+          break;
+      }
+    };
+    this.handle_error = (error) => {
+      if (this.on_error) {
+        this.on_error(error);
+        return;
+      }
+      this.handle_redirect(error);
+    };
+    this.get_access_token = () => {
+      return func_get_cookie("accessToken");
+    };
+    this.get_refresh_token = () => {
+      return func_get_cookie("refreshToken");
+    };
+    this.delete_cookie = () => {
+      func_delete_cookie("accessToken");
+      func_delete_cookie("refreshToken");
+    };
+    this.app_url = app_url;
+    this.on_error = on_error;
+    if (redirect) {
+      this.redirect = redirect;
+    }
   }
-  getAccessToken() {
-    return getCookie(this.config.accessTokenCookie);
-  }
-  getRefreshToken() {
-    return getCookie(this.config.refreshTokenCookie);
-  }
-  setTokens(tokens) {
-    setCookie(
-      this.config.accessTokenCookie,
-      tokens.accessToken,
-      this.config.accessTokenExpiryDays
-    );
-    setCookie(
-      this.config.refreshTokenCookie,
-      tokens.refreshToken,
-      this.config.refreshTokenExpiryDays
+  async me({ accessToken }) {
+    const data = await func_try_catch(
+      {
+        fn: async () => {
+          const res = await this.http(this.base_url + this.api_endpoint.me, {
+            method: "GET",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${accessToken ? accessToken : this.get_access_token()}`
+            }
+          });
+          return await res.json();
+        },
+        onError: (error) => {
+          this.handle_error(error);
+        }
+      }
     );
+    if (data == null ? void 0 : data.success) {
+      return data;
+    } else {
+      return null;
+    }
   }
-  clearTokens() {
-    deleteCookie(this.config.accessTokenCookie);
-    deleteCookie(this.config.refreshTokenCookie);
-  }
-  buildLoginUrl() {
-    const ref = encodeURIComponent(this.config.appUrl);
-    return `${this.config.authUrl}/auth?ref=${ref}`;
-  }
-  async exchangeCode(code) {
-    const res = await fetch(`${this.config.apiUrl}/exchange`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ code })
-    });
-    if (!res.ok) throw new Error(`exchange failed: ${res.status}`);
-    const data = await res.json();
-    this.setTokens(data);
-    return data;
-  }
-  async getMe() {
-    return this.authFetch("/me");
+  async safe_me({ accessToken }) {
+    const data = await func_try_catch(
+      {
+        fn: async () => {
+          const res = await this.http(this.base_url + this.api_endpoint.me, {
+            method: "GET",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${accessToken ? accessToken : this.get_access_token()}`
+            }
+          });
+          return await res.json();
+        }
+      }
+    );
+    if (data == null ? void 0 : data.success) {
+      return data;
+    } else {
+      return null;
+    }
   }
-  async updateMe(payload) {
-    return this.authFetch("/me", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(payload)
+  async exchange({ code }) {
+    var _a, _b;
+    const data = await func_try_catch({
+      fn: async () => {
+        const res = await this.http(
+          this.base_url + this.api_endpoint.exchange,
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({ code })
+          }
+        );
+        return await res.json();
+      },
+      onError: () => {
+        this.handle_error();
+      }
     });
+    const refreshToken = (_a = data == null ? void 0 : data.data) == null ? void 0 : _a.refreshToken;
+    const accessToken = (_b = data == null ? void 0 : data.data) == null ? void 0 : _b.accessToken;
+    if (refreshToken && accessToken) {
+      func_set_cookie("refreshToken", refreshToken, 59);
+      func_set_cookie("accessToken", accessToken, 14 / (24 * 60));
+    }
+    if (data == null ? void 0 : data.success) {
+      return data;
+    } else {
+      return null;
+    }
   }
   async refresh() {
-    if (this.refreshPromise) return this.refreshPromise;
-    const refreshToken = this.getRefreshToken();
-    if (!refreshToken) return null;
-    this.refreshPromise = (async () => {
-      try {
-        const res = await fetch(`${this.config.apiUrl}/refresh`, {
+    var _a, _b;
+    const data = await func_try_catch({
+      fn: async () => {
+        const res = await this.http(this.base_url + this.api_endpoint.refresh, {
           method: "POST",
           headers: {
             "Content-Type": "application/json",
-            Authorization: `Bearer ${refreshToken}`
+            Authorization: `Bearer ${this.get_refresh_token()}`
           }
         });
-        if (!res.ok) {
-          this.clearTokens();
-          return null;
-        }
-        const data = await res.json();
-        this.setTokens(data);
-        return data;
-      } catch {
-        this.clearTokens();
-        return null;
-      } finally {
-        this.refreshPromise = null;
+        return await res.json();
+      },
+      onError: () => {
+        this.handle_error();
       }
-    })();
-    return this.refreshPromise;
+    });
+    const refreshToken = (_a = data == null ? void 0 : data.data) == null ? void 0 : _a.refreshToken;
+    const accessToken = (_b = data == null ? void 0 : data.data) == null ? void 0 : _b.accessToken;
+    if (refreshToken && accessToken) {
+      document.cookie = `refreshToken=${encodeURIComponent(refreshToken)}; path=/;`;
+      document.cookie = `accessToken=${encodeURIComponent(accessToken)}; path=/;`;
+    }
+    if (data == null ? void 0 : data.success) {
+      return data;
+    } else {
+      return null;
+    }
   }
-  async logout(allDevices = false) {
-    const refreshToken = this.getRefreshToken();
-    if (refreshToken) {
-      try {
-        await fetch(
-          `${this.config.apiUrl}${allDevices ? "/logout/all" : "/logout"}`,
-          {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-              Authorization: `Bearer ${refreshToken}`
-            }
+  async logout() {
+    this.delete_cookie();
+    await func_try_catch({
+      fn: async () => {
+        const res = await this.http(this.base_url + this.api_endpoint.logout, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.get_refresh_token()}`
           }
-        );
-      } catch {
+        });
+        return await res.json();
+      },
+      onError: () => {
+        this.handle_error();
       }
-    }
-    this.clearTokens();
+    });
   }
-  /**
-   * Authenticated fetch. Attaches access token, retries once through /refresh
-   * on 401, and calls onAuthFailure (-> redirect to auth frontend) if that
-   * fails too. Use this for /me, /me updates, and any endpoint you add later.
-   */
-  async authFetch(path, init = {}) {
-    const doFetch = (token) => fetch(`${this.config.apiUrl}${path}`, {
-      ...init,
-      headers: {
-        ...init.headers || {},
-        ...token ? { Authorization: `Bearer ${token}` } : {}
-      }
+  async auth_flow({ code }) {
+    var _a;
+    const exchange_data = await this.exchange({
+      code
     });
-    let res = await doFetch(this.getAccessToken());
-    if (res.status === 401) {
-      const refreshed = await this.refresh();
-      if (!refreshed) {
-        this.onAuthFailure();
-        throw new Error("unauthenticated");
-      }
-      res = await doFetch(refreshed.accessToken);
-      if (res.status === 401) {
-        this.clearTokens();
-        this.onAuthFailure();
-        throw new Error("unauthenticated");
-      }
+    if (exchange_data == null ? void 0 : exchange_data.success) {
+      const me_data = await this.me({
+        accessToken: (_a = exchange_data == null ? void 0 : exchange_data.data) == null ? void 0 : _a.accessToken
+      });
+      return me_data;
+    } else {
+      return null;
     }
-    if (!res.ok) throw new Error(`request failed: ${res.status}`);
-    return res.json();
   }
 };
 
-// src/FluoceAuthProvider.tsx
+// src/context/auth_context.tsx
+import { createContext as create_context } from "react";
+var auth_context = create_context(null);
+
+// src/provider/auth_provider.tsx
 import { jsx } from "react/jsx-runtime";
-function FluoceAuthProvider({
+var auth_provider = ({
   children,
-  ...config
-}) {
-  const clientRef = useRef();
-  if (!clientRef.current) clientRef.current = new FluoceApiClient(config);
-  const client = clientRef.current;
-  const [user, setUser] = useState(null);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState(null);
-  const redirectToLogin = useCallback(() => {
-    window.location.href = client.buildLoginUrl();
-  }, [client]);
-  client.onAuthFailure = redirectToLogin;
-  const refreshUser = useCallback(async () => {
+  app_url,
+  on_error,
+  redirect
+}) => {
+  const auth_api = use_memo(() => {
+    return new Api_service({
+      app_url,
+      on_error,
+      redirect
+    });
+  }, [app_url, on_error, redirect]);
+  const [user, set_user] = use_state(null);
+  const [safe_loading, set_safe_loading] = use_state(false);
+  const [auth_flow_loading, set_auth_flow_loading] = use_state(false);
+  const refresh = async () => {
+    var _a;
+    const response = await auth_api.refresh();
+    return (_a = response == null ? void 0 : response.success) != null ? _a : false;
+  };
+  const logout = async () => {
+    await auth_api.logout();
+    set_user(null);
+    return true;
+  };
+  const auth_flow = async ({ code }) => {
+    set_auth_flow_loading(true);
     try {
-      const me = await client.getMe();
-      setUser(me);
-      setError(null);
-    } catch (e) {
-      setUser(null);
-      setError(e);
+      const data = await auth_api.auth_flow({
+        code
+      });
+      if ((data == null ? void 0 : data.success) && (data == null ? void 0 : data.data)) {
+        set_user(data == null ? void 0 : data.data);
+        return true;
+      } else {
+        return false;
+      }
+    } catch (error) {
+      return false;
+    } finally {
+      set_auth_flow_loading(false);
     }
-  }, [client]);
-  const logout = useCallback(
-    async (allDevices = false) => {
-      await client.logout(allDevices);
-      setUser(null);
-      redirectToLogin();
-    },
-    [client, redirectToLogin]
-  );
-  useEffect(() => {
-    let cancelled = false;
-    async function init() {
-      const params = new URLSearchParams(window.location.search);
-      const code = params.get("code");
-      try {
-        if (code) {
-          await client.exchangeCode(code);
-          params.delete("code");
-          const query = params.toString();
-          const cleanUrl = window.location.pathname + (query ? `?${query}` : "") + window.location.hash;
-          window.history.replaceState({}, "", cleanUrl);
-        }
-        if (client.getAccessToken() || client.getRefreshToken()) {
-          const me = await client.getMe();
-          if (!cancelled) setUser(me);
-        }
-      } catch (e) {
-        if (!cancelled) setError(e);
-      } finally {
-        if (!cancelled) setLoading(false);
+  };
+  const get_safe_user = async () => {
+    set_safe_loading(true);
+    try {
+      if (user) {
+        return user;
+      }
+      const data = await auth_api.safe_me({});
+      if ((data == null ? void 0 : data.success) && (data == null ? void 0 : data.data)) {
+        set_user(data == null ? void 0 : data.data);
+        return data.data;
+      } else {
+        return null;
       }
+    } catch (error) {
+      return null;
+    } finally {
+      set_safe_loading(false);
     }
-    init();
-    return () => {
-      cancelled = true;
-    };
+  };
+  use_effect(() => {
+    void get_safe_user();
   }, []);
-  const value = useMemo(
-    () => ({
-      user,
-      loading,
-      isAuthenticated: !!user,
-      error,
-      refreshUser,
-      logout,
-      redirectToLogin
-    }),
-    [user, loading, error, refreshUser, logout, redirectToLogin]
-  );
-  return /* @__PURE__ */ jsx(FluoceAuthContext.Provider, { value, children });
-}
+  const value = {
+    user,
+    safe_loading,
+    auth_flow_loading,
+    refresh,
+    logout,
+    auth_flow,
+    get_safe_user,
+    get access_token() {
+      return auth_api.get_access_token();
+    },
+    get refresh_token() {
+      return auth_api.get_refresh_token();
+    }
+  };
+  return /* @__PURE__ */ jsx(auth_context.Provider, { value, children });
+};
+
+// src/hook/use_auth.ts
+import { useContext as use_context } from "react";
+var use_auth = () => {
+  const context = use_context(auth_context);
+  if (!context) {
+    throw new Error("use_auth must be used within an auth_provider");
+  }
+  return context;
+};
 
-// src/AuthGuard.tsx
-import { useEffect as useEffect2 } from "react";
+// src/guard/auth_guard.tsx
 import { Fragment, jsx as jsx2 } from "react/jsx-runtime";
-function AuthGuard({ children, fallback = null }) {
-  const { loading, isAuthenticated, redirectToLogin } = useFluoceAuth();
-  useEffect2(() => {
-    if (!loading && !isAuthenticated) {
-      redirectToLogin();
-    }
-  }, [loading, isAuthenticated, redirectToLogin]);
-  if (loading || !isAuthenticated) {
+var auth_guard = ({
+  children,
+  fallback = null
+}) => {
+  const { user, safe_loading } = use_auth();
+  if (safe_loading && !user) {
     return /* @__PURE__ */ jsx2(Fragment, { children: fallback });
   }
+  if (!user && !safe_loading) {
+    return null;
+  }
   return /* @__PURE__ */ jsx2(Fragment, { children });
-}
+};
 export {
-  AuthGuard,
-  FluoceApiClient,
-  FluoceAuthProvider,
-  useFluoceAuth
+  auth_guard as FluoceAuthGuard,
+  auth_provider as FluoceAuthProvider,
+  use_auth as useFluoceAuth
 };
 //# sourceMappingURL=index.js.map