@umituz/react-native-auth 1.6.9 → 1.7.0

package/src/presentation/hooks/useAuthState.ts

@@ -0,0 +1,99 @@
+/**
+ * useAuthState Hook
+ * Single Responsibility: Manage authentication state
+ */
+
+import { useState, useEffect } from "react";
+import type { User } from "firebase/auth";
+import { DeviceEventEmitter } from "react-native";
+import { getAuthService } from "../../infrastructure/services/AuthService";
+import { useFirebaseAuth } from "@umituz/react-native-firebase-auth";
+
+export interface UseAuthStateResult {
+  user: User | null;
+  isAuthenticated: boolean;
+  isGuest: boolean;
+  loading: boolean;
+  error: string | null;
+  setError: (error: string | null) => void;
+  setIsGuest: (isGuest: boolean) => void;
+  setLoading: (loading: boolean) => void;
+}
+
+/**
+ * Hook for managing authentication state
+ */
+export function useAuthState(): UseAuthStateResult {
+  const { user: firebaseUser, loading: firebaseLoading } = useFirebaseAuth();
+  const [isGuest, setIsGuest] = useState(() => {
+    const service = getAuthService();
+    return service ? service.getIsGuestMode() : false;
+  });
+  const [error, setError] = useState<string | null>(null);
+  const [loading, setLoading] = useState(false);
+
+  const user = isGuest ? null : firebaseUser;
+  const isAuthenticated = !!user && !isGuest;
+
+  // Reset guest mode when user signs in
+  useEffect(() => {
+    if (firebaseUser && isGuest) {
+      setIsGuest(false);
+    }
+  }, [firebaseUser, isGuest]);
+
+  // Sync isGuest state with service on mount
+  useEffect(() => {
+    const service = getAuthService();
+    if (service) {
+      const serviceIsGuest = service.getIsGuestMode();
+      if (serviceIsGuest !== isGuest) {
+        setIsGuest(serviceIsGuest);
+      }
+    }
+  }, []);
+
+  // Listen for guest-mode-enabled event
+  useEffect(() => {
+    const guestSubscription = DeviceEventEmitter.addListener(
+      "guest-mode-enabled",
+      () => {
+        /* eslint-disable-next-line no-console */
+        if (__DEV__) {
+          console.log("[useAuthState] Guest mode enabled event received");
+        }
+        setIsGuest(true);
+      }
+    );
+
+    const authSubscription = DeviceEventEmitter.addListener(
+      "user-authenticated",
+      () => {
+        /* eslint-disable-next-line no-console */
+        if (__DEV__) {
+          console.log("[useAuthState] User authenticated event received");
+        }
+        if (isGuest) {
+          setIsGuest(false);
+        }
+      }
+    );
+
+    return () => {
+      guestSubscription.remove();
+      authSubscription.remove();
+    };
+  }, [isGuest]);
+
+  return {
+    user,
+    isAuthenticated,
+    isGuest,
+    loading: loading || firebaseLoading,
+    error,
+    setError,
+    setIsGuest,
+    setLoading,
+  };
+}
+

package/src/presentation/hooks/useLoginForm.ts

@@ -0,0 +1,165 @@
+/**
+ * useLoginForm Hook
+ * Single Responsibility: Handle login form logic
+ */
+
+import { useState, useCallback } from "react";
+import { useLocalization } from "@umituz/react-native-localization";
+import { useAuth } from "./useAuth";
+import { getAuthErrorLocalizationKey } from "../utils/getAuthErrorMessage";
+
+/**
+ * Validate email format
+ */
+function validateEmail(emailValue: string): boolean {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(emailValue);
+}
+
+export interface UseLoginFormResult {
+  email: string;
+  password: string;
+  emailError: string | null;
+  passwordError: string | null;
+  localError: string | null;
+  loading: boolean;
+  handleEmailChange: (text: string) => void;
+  handlePasswordChange: (text: string) => void;
+  handleSignIn: () => Promise<void>;
+  handleContinueAsGuest: () => Promise<void>;
+  displayError: string | null;
+}
+
+/**
+ * Hook for login form logic
+ */
+export function useLoginForm(): UseLoginFormResult {
+  const { t } = useLocalization();
+  const { signIn, loading, error, continueAsGuest } = useAuth();
+
+  const [email, setEmail] = useState("");
+  const [password, setPassword] = useState("");
+  const [emailError, setEmailError] = useState<string | null>(null);
+  const [passwordError, setPasswordError] = useState<string | null>(null);
+  const [localError, setLocalError] = useState<string | null>(null);
+
+  const handleEmailChange = useCallback((text: string) => {
+    setEmail(text);
+    if (emailError) setEmailError(null);
+    if (localError) setLocalError(null);
+  }, [emailError, localError]);
+
+  const handlePasswordChange = useCallback((text: string) => {
+    setPassword(text);
+    if (passwordError) setPasswordError(null);
+    if (localError) setLocalError(null);
+  }, [passwordError, localError]);
+
+  const handleSignIn = useCallback(async () => {
+    /* eslint-disable-next-line no-console */
+    if (__DEV__) {
+      console.log("[useLoginForm] handleSignIn called");
+    }
+    setEmailError(null);
+    setPasswordError(null);
+    setLocalError(null);
+
+    let hasError = false;
+
+    if (!email.trim()) {
+      setEmailError(t("auth.errors.invalidEmail"));
+      hasError = true;
+    } else if (!validateEmail(email.trim())) {
+      setEmailError(t("auth.errors.invalidEmail"));
+      hasError = true;
+    }
+
+    if (!password.trim()) {
+      setPasswordError(t("auth.errors.weakPassword"));
+      hasError = true;
+    } else if (password.length < 6) {
+      setPasswordError(t("auth.errors.weakPassword"));
+      hasError = true;
+    }
+
+    if (hasError) {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.log("[useLoginForm] Validation errors, returning early");
+      }
+      return;
+    }
+
+    try {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.log("[useLoginForm] Calling signIn with email:", email.trim());
+      }
+      await signIn(email.trim(), password);
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.log("[useLoginForm] signIn completed successfully");
+      }
+    } catch (err: any) {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.error("[useLoginForm] signIn error:", err);
+      }
+      const localizationKey = getAuthErrorLocalizationKey(err);
+      const errorMessage = t(localizationKey);
+      setLocalError(errorMessage);
+    }
+  }, [email, password, t, signIn]);
+
+  const handleContinueAsGuest = useCallback(async () => {
+    /* eslint-disable-next-line no-console */
+    if (__DEV__) {
+      console.log("========================================");
+      console.log("[useLoginForm] 🎯 Continue as Guest button PRESSED");
+      console.log("[useLoginForm] Current loading state:", loading);
+      console.log("[useLoginForm] Current error state:", error);
+      console.log("========================================");
+    }
+    
+    try {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.log("[useLoginForm] Calling continueAsGuest() function...");
+      }
+      
+      await continueAsGuest();
+      
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.log("[useLoginForm] ✅ continueAsGuest() completed successfully");
+        console.log("[useLoginForm] Current loading state after:", loading);
+      }
+    } catch (err) {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.error("[useLoginForm] ❌ ERROR in continueAsGuest:", err);
+        console.error("[useLoginForm] Error details:", {
+          message: err instanceof Error ? err.message : String(err),
+          stack: err instanceof Error ? err.stack : undefined,
+        });
+      }
+    }
+  }, [continueAsGuest, loading, error]);
+
+  const displayError = localError || error;
+
+  return {
+    email,
+    password,
+    emailError,
+    passwordError,
+    localError,
+    loading,
+    handleEmailChange,
+    handlePasswordChange,
+    handleSignIn,
+    handleContinueAsGuest,
+    displayError,
+  };
+}
+

package/src/presentation/hooks/useRegisterForm.ts

@@ -0,0 +1,170 @@
+/**
+ * useRegisterForm Hook
+ * Single Responsibility: Handle register form logic
+ */
+
+import { useState, useCallback } from "react";
+import { useLocalization } from "@umituz/react-native-localization";
+import {
+  validateEmail,
+  validatePassword,
+  validatePasswordConfirmation,
+  batchValidate,
+} from "@umituz/react-native-validation";
+import { useAuth } from "./useAuth";
+import { getAuthErrorLocalizationKey } from "../utils/getAuthErrorMessage";
+
+export interface UseRegisterFormResult {
+  displayName: string;
+  email: string;
+  password: string;
+  confirmPassword: string;
+  fieldErrors: {
+    displayName?: string;
+    email?: string;
+    password?: string;
+    confirmPassword?: string;
+  };
+  localError: string | null;
+  loading: boolean;
+  handleDisplayNameChange: (text: string) => void;
+  handleEmailChange: (text: string) => void;
+  handlePasswordChange: (text: string) => void;
+  handleConfirmPasswordChange: (text: string) => void;
+  handleSignUp: () => Promise<void>;
+  displayError: string | null;
+}
+
+/**
+ * Hook for register form logic
+ */
+export function useRegisterForm(): UseRegisterFormResult {
+  const { t } = useLocalization();
+  const { signUp, loading, error } = useAuth();
+
+  const [displayName, setDisplayName] = useState("");
+  const [email, setEmail] = useState("");
+  const [password, setPassword] = useState("");
+  const [confirmPassword, setConfirmPassword] = useState("");
+  const [localError, setLocalError] = useState<string | null>(null);
+  const [fieldErrors, setFieldErrors] = useState<{
+    displayName?: string;
+    email?: string;
+    password?: string;
+    confirmPassword?: string;
+  }>({});
+
+  const handleDisplayNameChange = useCallback((text: string) => {
+    setDisplayName(text);
+    setFieldErrors((prev) => {
+      const next = { ...prev };
+      if (next.displayName) {
+        delete next.displayName;
+      }
+      return next;
+    });
+    if (localError) setLocalError(null);
+  }, [localError]);
+
+  const handleEmailChange = useCallback((text: string) => {
+    setEmail(text);
+    setFieldErrors((prev) => {
+      const next = { ...prev };
+      if (next.email) {
+        delete next.email;
+      }
+      return next;
+    });
+    if (localError) setLocalError(null);
+  }, [localError]);
+
+  const handlePasswordChange = useCallback((text: string) => {
+    setPassword(text);
+    setFieldErrors((prev) => {
+      const next = { ...prev };
+      if (next.password) {
+        delete next.password;
+      }
+      if (next.confirmPassword) {
+        delete next.confirmPassword;
+      }
+      return next;
+    });
+    if (localError) setLocalError(null);
+  }, [localError]);
+
+  const handleConfirmPasswordChange = useCallback((text: string) => {
+    setConfirmPassword(text);
+    setFieldErrors((prev) => {
+      const next = { ...prev };
+      if (next.confirmPassword) {
+        delete next.confirmPassword;
+      }
+      return next;
+    });
+    if (localError) setLocalError(null);
+  }, [localError]);
+
+  const handleSignUp = useCallback(async () => {
+    setLocalError(null);
+    setFieldErrors({});
+
+    const validationResult = batchValidate([
+      {
+        field: "email",
+        validator: () => validateEmail(email.trim()),
+      },
+      {
+        field: "password",
+        validator: () =>
+          validatePassword(password, {
+            minLength: 6,
+            requireUppercase: false,
+            requireLowercase: false,
+            requireNumber: false,
+          }),
+      },
+      {
+        field: "confirmPassword",
+        validator: () =>
+          validatePasswordConfirmation(password, confirmPassword),
+      },
+    ]);
+
+    if (!validationResult.isValid) {
+      setFieldErrors(validationResult.errors);
+      return;
+    }
+
+    try {
+      await signUp(
+        email.trim(),
+        password,
+        displayName.trim() || undefined,
+      );
+    } catch (err: any) {
+      const localizationKey = getAuthErrorLocalizationKey(err);
+      const errorMessage = t(localizationKey);
+      setLocalError(errorMessage);
+    }
+  }, [displayName, email, password, confirmPassword, signUp, t]);
+
+  const displayError = localError || error;
+
+  return {
+    displayName,
+    email,
+    password,
+    confirmPassword,
+    fieldErrors,
+    localError,
+    loading,
+    handleDisplayNameChange,
+    handleEmailChange,
+    handlePasswordChange,
+    handleConfirmPasswordChange,
+    handleSignUp,
+    displayError,
+  };
+}
+