@fonderie/react-native-auth 0.5.0 → 0.6.0

package/dist/index.js

@@ -1,16 +1,100 @@
 // src/index.ts
-import { FonderieApiError as FonderieApiError8, isMfaRequired as isMfaRequired2 } from "@fonderie/client";
+import { FonderieApiError as FonderieApiError12, isMfaRequired as isMfaRequired2 } from "@fonderie/client";
 
-// src/hooks/useForgotPassword.ts
+// src/hooks/useAccountData.ts
 import { FonderieApiError } from "@fonderie/client";
 import { useFonderieSubClient } from "@fonderie/react";
 import { useCallback, useState } from "react";
-function useForgotPassword(client) {
-  const auth = useFonderieSubClient(client, (c) => c.auth, "useForgotPassword");
+
+// src/storage.ts
+import AsyncStorage from "@react-native-async-storage/async-storage";
+var TOKEN_KEY = "fonderie_access_token";
+function persistToken(token) {
+  return AsyncStorage.setItem(TOKEN_KEY, token);
+}
+function clearToken() {
+  return AsyncStorage.removeItem(TOKEN_KEY);
+}
+function readToken() {
+  return AsyncStorage.getItem(TOKEN_KEY);
+}
+
+// src/hooks/useAccountData.ts
+function useAccountData(client) {
+  const auth = useFonderieSubClient(client, (c) => c.auth, "useAccountData");
   const [isLoading, setIsLoading] = useState(false);
   const [error, setError] = useState(null);
-  const [sent, setSent] = useState(false);
-  const forgotPassword = useCallback(
+  const run = useCallback(async (op) => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      return await op();
+    } catch (err) {
+      const apiError = err instanceof FonderieApiError ? err : new FonderieApiError("unknown", String(err), 0);
+      setError(apiError);
+      throw apiError;
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const exportData = useCallback(
+    () => run(async () => {
+      const { result } = await auth.exportData();
+      return result;
+    }),
+    [auth, run]
+  );
+  const deleteUser = useCallback(
+    () => run(async () => {
+      await auth.deleteUser();
+      auth.setAccessToken(void 0);
+      await clearToken();
+    }),
+    [auth, run]
+  );
+  return { exportData, deleteUser, isLoading, error };
+}
+
+// src/hooks/useChangePassword.ts
+import { FonderieApiError as FonderieApiError2 } from "@fonderie/client";
+import { useFonderieSubClient as useFonderieSubClient2 } from "@fonderie/react";
+import { useCallback as useCallback2, useState as useState2 } from "react";
+function useChangePassword(client) {
+  const auth = useFonderieSubClient2(client, (c) => c.auth, "useChangePassword");
+  const [isLoading, setIsLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const [done, setDone] = useState2(false);
+  const changePassword = useCallback2(
+    async (input) => {
+      setIsLoading(true);
+      setError(null);
+      setDone(false);
+      try {
+        await auth.changePassword(input);
+        setDone(true);
+      } catch (err) {
+        const apiError = err instanceof FonderieApiError2 ? err : new FonderieApiError2("unknown", String(err), 0);
+        setError(apiError);
+        throw apiError;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [auth]
+  );
+  return { changePassword, isLoading, error, done };
+}
+
+// src/hooks/useForgotPassword.ts
+import { FonderieApiError as FonderieApiError3 } from "@fonderie/client";
+import { useFonderieSubClient as useFonderieSubClient3 } from "@fonderie/react";
+import { useCallback as useCallback3, useState as useState3 } from "react";
+function useForgotPassword(client) {
+  const auth = useFonderieSubClient3(client, (c) => c.auth, "useForgotPassword");
+  const [isLoading, setIsLoading] = useState3(false);
+  const [error, setError] = useState3(null);
+  const [sent, setSent] = useState3(false);
+  const forgotPassword = useCallback3(
     async (email) => {
       setIsLoading(true);
       setError(null);
@@ -18,7 +102,7 @@ function useForgotPassword(client) {
         await auth.forgotPassword(email);
         setSent(true);
       } catch (err) {
-        const apiError = err instanceof FonderieApiError ? err : new FonderieApiError("unknown", String(err), 0);
+        const apiError = err instanceof FonderieApiError3 ? err : new FonderieApiError3("unknown", String(err), 0);
         setError(apiError);
         throw apiError;
       } finally {
@@ -31,31 +115,16 @@ function useForgotPassword(client) {
 }
 
 // src/hooks/useLogin.ts
-import { FonderieApiError as FonderieApiError2, isMfaRequired } from "@fonderie/client";
-import { useFonderieSubClient as useFonderieSubClient2 } from "@fonderie/react";
-import { useCallback as useCallback2, useState as useState2 } from "react";
-
-// src/storage.ts
-import AsyncStorage from "@react-native-async-storage/async-storage";
-var TOKEN_KEY = "fonderie_access_token";
-function persistToken(token) {
-  return AsyncStorage.setItem(TOKEN_KEY, token);
-}
-function clearToken() {
-  return AsyncStorage.removeItem(TOKEN_KEY);
-}
-function readToken() {
-  return AsyncStorage.getItem(TOKEN_KEY);
-}
-
-// src/hooks/useLogin.ts
+import { FonderieApiError as FonderieApiError4, isMfaRequired } from "@fonderie/client";
+import { useFonderieSubClient as useFonderieSubClient4 } from "@fonderie/react";
+import { useCallback as useCallback4, useState as useState4 } from "react";
 function useLogin(client) {
-  const auth = useFonderieSubClient2(client, (c) => c.auth, "useLogin");
-  const [isLoading, setIsLoading] = useState2(false);
-  const [error, setError] = useState2(null);
-  const [data, setData] = useState2(null);
-  const [mfaPending, setMfaPending] = useState2(null);
-  const login = useCallback2(
+  const auth = useFonderieSubClient4(client, (c) => c.auth, "useLogin");
+  const [isLoading, setIsLoading] = useState4(false);
+  const [error, setError] = useState4(null);
+  const [data, setData] = useState4(null);
+  const [mfaPending, setMfaPending] = useState4(null);
+  const login = useCallback4(
     async (input) => {
       setIsLoading(true);
       setError(null);
@@ -71,7 +140,7 @@ function useLogin(client) {
         setData(result);
         return result;
       } catch (err) {
-        const apiError = err instanceof FonderieApiError2 ? err : new FonderieApiError2("unknown", String(err), 0);
+        const apiError = err instanceof FonderieApiError4 ? err : new FonderieApiError4("unknown", String(err), 0);
         setError(apiError);
         throw apiError;
       } finally {
@@ -84,15 +153,15 @@ function useLogin(client) {
 }
 
 // src/hooks/useMfaLogin.ts
-import { FonderieApiError as FonderieApiError3 } from "@fonderie/client";
-import { useFonderieSubClient as useFonderieSubClient3 } from "@fonderie/react";
-import { useCallback as useCallback3, useState as useState3 } from "react";
+import { FonderieApiError as FonderieApiError5 } from "@fonderie/client";
+import { useFonderieSubClient as useFonderieSubClient5 } from "@fonderie/react";
+import { useCallback as useCallback5, useState as useState5 } from "react";
 function useMfaLogin(client) {
-  const auth = useFonderieSubClient3(client, (c) => c.auth, "useMfaLogin");
-  const [isLoading, setIsLoading] = useState3(false);
-  const [error, setError] = useState3(null);
-  const [data, setData] = useState3(null);
-  const verifyLogin = useCallback3(
+  const auth = useFonderieSubClient5(client, (c) => c.auth, "useMfaLogin");
+  const [isLoading, setIsLoading] = useState5(false);
+  const [error, setError] = useState5(null);
+  const [data, setData] = useState5(null);
+  const verifyLogin = useCallback5(
     async (mfaToken, code) => {
       setIsLoading(true);
       setError(null);
@@ -103,7 +172,7 @@ function useMfaLogin(client) {
         setData(result);
         return result;
       } catch (err) {
-        const apiError = err instanceof FonderieApiError3 ? err : new FonderieApiError3("unknown", String(err), 0);
+        const apiError = err instanceof FonderieApiError5 ? err : new FonderieApiError5("unknown", String(err), 0);
         setError(apiError);
         throw apiError;
       } finally {
@@ -115,21 +184,147 @@ function useMfaLogin(client) {
   return { verifyLogin, isLoading, error, data };
 }
 
+// src/hooks/useMfaSetup.ts
+import { FonderieApiError as FonderieApiError6 } from "@fonderie/client";
+import { useFonderieSubClient as useFonderieSubClient6 } from "@fonderie/react";
+import { useCallback as useCallback6, useState as useState6 } from "react";
+function useMfaSetup(client) {
+  const auth = useFonderieSubClient6(client, (c) => c.auth, "useMfaSetup");
+  const [setupData, setSetupData] = useState6(null);
+  const [isLoading, setIsLoading] = useState6(false);
+  const [error, setError] = useState6(null);
+  const run = useCallback6(async (op) => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      return await op();
+    } catch (err) {
+      const apiError = err instanceof FonderieApiError6 ? err : new FonderieApiError6("unknown", String(err), 0);
+      setError(apiError);
+      throw apiError;
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const setup = useCallback6(
+    () => run(async () => {
+      const { result } = await auth.mfa.setup();
+      setSetupData(result);
+      return result;
+    }),
+    [auth, run]
+  );
+  const verify = useCallback6(
+    (code) => run(async () => {
+      const { result } = await auth.mfa.verify(code);
+      auth.setAccessToken(result.tokens.access);
+      await persistToken(result.tokens.access);
+      return result;
+    }),
+    [auth, run]
+  );
+  const disable = useCallback6(
+    (code) => run(async () => {
+      await auth.mfa.disable(code);
+    }),
+    [auth, run]
+  );
+  const regenerateBackupCodes = useCallback6(
+    (code) => run(async () => {
+      const { result } = await auth.mfa.regenerateBackupCodes(code);
+      return result.backupCodes;
+    }),
+    [auth, run]
+  );
+  return { setup, setupData, verify, disable, regenerateBackupCodes, isLoading, error };
+}
+
+// src/hooks/useProfile.ts
+import { FonderieApiError as FonderieApiError7 } from "@fonderie/client";
+import { useFonderieSubClient as useFonderieSubClient7 } from "@fonderie/react";
+import { useCallback as useCallback7, useEffect, useState as useState7 } from "react";
+function useProfile(client) {
+  const auth = useFonderieSubClient7(client, (c) => c.auth, "useProfile");
+  const [user, setUser] = useState7(null);
+  const [isLoading, setIsLoading] = useState7(true);
+  const [error, setError] = useState7(null);
+  const refresh = useCallback7(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const { result } = await auth.getUser();
+      setUser(result.user);
+    } catch (err) {
+      const apiError = err instanceof FonderieApiError7 ? err : new FonderieApiError7("unknown", String(err), 0);
+      setError(apiError);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [auth]);
+  const mutate = useCallback7(
+    async (op) => {
+      setError(null);
+      try {
+        return await op();
+      } catch (err) {
+        const apiError = err instanceof FonderieApiError7 ? err : new FonderieApiError7("unknown", String(err), 0);
+        setError(apiError);
+        throw apiError;
+      }
+    },
+    []
+  );
+  const updateProfile = useCallback7(
+    (input) => mutate(async () => {
+      const { result } = await auth.updateProfile(input);
+      setUser(result.user);
+      return result.user;
+    }),
+    [auth, mutate]
+  );
+  const updatePreferences = useCallback7(
+    (input) => mutate(async () => {
+      const { result } = await auth.updatePreferences(input);
+      setUser(result.user);
+      return result.user;
+    }),
+    [auth, mutate]
+  );
+  const updateEmail = useCallback7(
+    (email) => mutate(async () => {
+      await auth.updateEmail(email);
+      await refresh();
+    }),
+    [auth, mutate, refresh]
+  );
+  const updatePhone = useCallback7(
+    (phone) => mutate(async () => {
+      await auth.updatePhone(phone);
+      await refresh();
+    }),
+    [auth, mutate, refresh]
+  );
+  useEffect(() => {
+    void refresh();
+  }, [refresh]);
+  return { user, refresh, updateProfile, updatePreferences, updateEmail, updatePhone, isLoading, error };
+}
+
 // src/hooks/useLogout.ts
-import { FonderieApiError as FonderieApiError4 } from "@fonderie/client";
-import { useFonderieSubClient as useFonderieSubClient4 } from "@fonderie/react";
-import { useCallback as useCallback4, useState as useState4 } from "react";
+import { FonderieApiError as FonderieApiError8 } from "@fonderie/client";
+import { useFonderieSubClient as useFonderieSubClient8 } from "@fonderie/react";
+import { useCallback as useCallback8, useState as useState8 } from "react";
 function useLogout(client) {
-  const auth = useFonderieSubClient4(client, (c) => c.auth, "useLogout");
-  const [isLoading, setIsLoading] = useState4(false);
-  const [error, setError] = useState4(null);
-  const logout = useCallback4(async (refreshToken) => {
+  const auth = useFonderieSubClient8(client, (c) => c.auth, "useLogout");
+  const [isLoading, setIsLoading] = useState8(false);
+  const [error, setError] = useState8(null);
+  const logout = useCallback8(async (refreshToken) => {
     setIsLoading(true);
     setError(null);
     try {
       await auth.logout(refreshToken);
     } catch (err) {
-      const apiError = err instanceof FonderieApiError4 ? err : new FonderieApiError4("unknown", String(err), 0);
+      const apiError = err instanceof FonderieApiError8 ? err : new FonderieApiError8("unknown", String(err), 0);
       setError(apiError);
     } finally {
       auth.setAccessToken(void 0);
@@ -141,15 +336,15 @@ function useLogout(client) {
 }
 
 // src/hooks/useRegister.ts
-import { FonderieApiError as FonderieApiError5 } from "@fonderie/client";
-import { useFonderieSubClient as useFonderieSubClient5 } from "@fonderie/react";
-import { useCallback as useCallback5, useState as useState5 } from "react";
+import { FonderieApiError as FonderieApiError9 } from "@fonderie/client";
+import { useFonderieSubClient as useFonderieSubClient9 } from "@fonderie/react";
+import { useCallback as useCallback9, useState as useState9 } from "react";
 function useRegister(client) {
-  const auth = useFonderieSubClient5(client, (c) => c.auth, "useRegister");
-  const [isLoading, setIsLoading] = useState5(false);
-  const [error, setError] = useState5(null);
-  const [data, setData] = useState5(null);
-  const register = useCallback5(
+  const auth = useFonderieSubClient9(client, (c) => c.auth, "useRegister");
+  const [isLoading, setIsLoading] = useState9(false);
+  const [error, setError] = useState9(null);
+  const [data, setData] = useState9(null);
+  const register = useCallback9(
     async (input) => {
       setIsLoading(true);
       setError(null);
@@ -160,7 +355,7 @@ function useRegister(client) {
         setData(result);
         return result;
       } catch (err) {
-        const apiError = err instanceof FonderieApiError5 ? err : new FonderieApiError5("unknown", String(err), 0);
+        const apiError = err instanceof FonderieApiError9 ? err : new FonderieApiError9("unknown", String(err), 0);
         setError(apiError);
         throw apiError;
       } finally {
@@ -173,15 +368,15 @@ function useRegister(client) {
 }
 
 // src/hooks/useResetPassword.ts
-import { FonderieApiError as FonderieApiError6 } from "@fonderie/client";
-import { useFonderieSubClient as useFonderieSubClient6 } from "@fonderie/react";
-import { useCallback as useCallback6, useState as useState6 } from "react";
+import { FonderieApiError as FonderieApiError10 } from "@fonderie/client";
+import { useFonderieSubClient as useFonderieSubClient10 } from "@fonderie/react";
+import { useCallback as useCallback10, useState as useState10 } from "react";
 function useResetPassword(client) {
-  const auth = useFonderieSubClient6(client, (c) => c.auth, "useResetPassword");
-  const [isLoading, setIsLoading] = useState6(false);
-  const [error, setError] = useState6(null);
-  const [done, setDone] = useState6(false);
-  const resetPassword = useCallback6(
+  const auth = useFonderieSubClient10(client, (c) => c.auth, "useResetPassword");
+  const [isLoading, setIsLoading] = useState10(false);
+  const [error, setError] = useState10(null);
+  const [done, setDone] = useState10(false);
+  const resetPassword = useCallback10(
     async (input) => {
       setIsLoading(true);
       setError(null);
@@ -189,7 +384,7 @@ function useResetPassword(client) {
         await auth.resetPassword(input);
         setDone(true);
       } catch (err) {
-        const apiError = err instanceof FonderieApiError6 ? err : new FonderieApiError6("unknown", String(err), 0);
+        const apiError = err instanceof FonderieApiError10 ? err : new FonderieApiError10("unknown", String(err), 0);
         setError(apiError);
         throw apiError;
       } finally {
@@ -202,14 +397,14 @@ function useResetPassword(client) {
 }
 
 // src/hooks/useSession.ts
-import { useFonderieSubClient as useFonderieSubClient7 } from "@fonderie/react";
-import { useCallback as useCallback7, useEffect, useState as useState7 } from "react";
+import { useFonderieSubClient as useFonderieSubClient11 } from "@fonderie/react";
+import { useCallback as useCallback11, useEffect as useEffect2, useState as useState11 } from "react";
 function useSession(client) {
-  const auth = useFonderieSubClient7(client, (c) => c.auth, "useSession");
-  const [user, setUser] = useState7(null);
-  const [isLoading, setIsLoading] = useState7(true);
-  const [isAuthenticated, setIsAuthenticated] = useState7(false);
-  const refresh = useCallback7(async () => {
+  const auth = useFonderieSubClient11(client, (c) => c.auth, "useSession");
+  const [user, setUser] = useState11(null);
+  const [isLoading, setIsLoading] = useState11(true);
+  const [isAuthenticated, setIsAuthenticated] = useState11(false);
+  const refresh = useCallback11(async () => {
     setIsLoading(true);
     try {
       const { result } = await auth.getUser();
@@ -224,7 +419,7 @@ function useSession(client) {
       setIsLoading(false);
     }
   }, [auth]);
-  const logout = useCallback7(async (refreshToken) => {
+  const logout = useCallback11(async (refreshToken) => {
     try {
       await auth.logout(refreshToken);
     } catch {
@@ -234,7 +429,7 @@ function useSession(client) {
     setUser(null);
     setIsAuthenticated(false);
   }, [auth]);
-  useEffect(() => {
+  useEffect2(() => {
     readToken().then((token) => {
       if (token) auth.setAccessToken(token);
       void refresh();
@@ -244,15 +439,31 @@ function useSession(client) {
 }
 
 // src/hooks/useVerifyEmail.ts
-import { FonderieApiError as FonderieApiError7 } from "@fonderie/client";
-import { useFonderieSubClient as useFonderieSubClient8 } from "@fonderie/react";
-import { useCallback as useCallback8, useState as useState8 } from "react";
+import { FonderieApiError as FonderieApiError11 } from "@fonderie/client";
+import { useFonderieSubClient as useFonderieSubClient12 } from "@fonderie/react";
+import { useCallback as useCallback12, useState as useState12 } from "react";
 function useVerifyEmail(client) {
-  const auth = useFonderieSubClient8(client, (c) => c.auth, "useVerifyEmail");
-  const [isLoading, setIsLoading] = useState8(false);
-  const [error, setError] = useState8(null);
-  const [data, setData] = useState8(null);
-  const verifyEmail = useCallback8(
+  const auth = useFonderieSubClient12(client, (c) => c.auth, "useVerifyEmail");
+  const [isLoading, setIsLoading] = useState12(false);
+  const [error, setError] = useState12(null);
+  const [data, setData] = useState12(null);
+  const [resent, setResent] = useState12(false);
+  const resend = useCallback12(async () => {
+    setIsLoading(true);
+    setError(null);
+    setResent(false);
+    try {
+      await auth.sendVerificationEmail();
+      setResent(true);
+    } catch (err) {
+      const apiError = err instanceof FonderieApiError11 ? err : new FonderieApiError11("unknown", String(err), 0);
+      setError(apiError);
+      throw apiError;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [auth]);
+  const verifyEmail = useCallback12(
     async (pin) => {
       setIsLoading(true);
       setError(null);
@@ -261,7 +472,7 @@ function useVerifyEmail(client) {
         setData(result);
         return result;
       } catch (err) {
-        const apiError = err instanceof FonderieApiError7 ? err : new FonderieApiError7("unknown", String(err), 0);
+        const apiError = err instanceof FonderieApiError11 ? err : new FonderieApiError11("unknown", String(err), 0);
         setError(apiError);
         throw apiError;
       } finally {
@@ -270,19 +481,23 @@ function useVerifyEmail(client) {
     },
     [auth]
   );
-  return { verifyEmail, isLoading, error, data };
+  return { verifyEmail, resend, resent, isLoading, error, data };
 }
 export {
-  FonderieApiError8 as FonderieApiError,
+  FonderieApiError12 as FonderieApiError,
   TOKEN_KEY,
   clearToken,
   isMfaRequired2 as isMfaRequired,
   persistToken,
   readToken,
+  useAccountData,
+  useChangePassword,
   useForgotPassword,
   useLogin,
   useLogout,
   useMfaLogin,
+  useMfaSetup,
+  useProfile,
   useRegister,
   useResetPassword,
   useSession,