@umituz/react-native-auth 3.6.74 → 3.6.76

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-auth",
-  "version": "3.6.74",
+  "version": "3.6.76",
   "description": "Authentication service for React Native apps - Secure, type-safe, and production-ready. Provider-agnostic design with dependency injection, configurable validation, and comprehensive error handling.",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -93,7 +93,9 @@
     "react-native-safe-area-context": "^5.6.2",
     "react-native-svg": "^15.15.1",
     "typescript": "^5.3.0",
-    "zustand": "^4.0.0"
+    "zustand": "^4.0.0",
+    "@react-native-community/datetimepicker": "^8.2.0",
+    "rn-emoji-keyboard": "^1.7.0"
   },
   "publishConfig": {
     "access": "public"

package/src/infrastructure/providers/FirebaseAuthProvider.ts

@@ -13,12 +13,7 @@ import {
   linkWithCredential,
   type Auth,
 } from "firebase/auth";
-
-import type {
-  IAuthProvider,
-  AuthCredentials,
-  SignUpCredentials,
-} from "../../application/ports/IAuthProvider";
+import type { IAuthProvider, AuthCredentials, SignUpCredentials } from "../../application/ports/IAuthProvider";
 import type { AuthUser } from "../../domain/entities/AuthUser";
 import { mapFirebaseAuthError } from "../utils/AuthErrorMapper";
 import { mapToAuthUser } from "../utils/UserMapper";
@@ -27,15 +22,11 @@ export class FirebaseAuthProvider implements IAuthProvider {
   private auth: Auth | null = null;
 
   constructor(auth?: Auth) {
-    if (auth) {
-      this.auth = auth;
-    }
+    if (auth) this.auth = auth;
   }
 
   initialize(): Promise<void> {
-    if (!this.auth) {
-      throw new Error("Firebase Auth instance must be provided");
-    }
+    if (!this.auth) throw new Error("Firebase Auth instance must be provided");
     return Promise.resolve();
   }
 
@@ -48,20 +39,12 @@ export class FirebaseAuthProvider implements IAuthProvider {
   }
 
   async signIn(credentials: AuthCredentials): Promise<AuthUser> {
-    if (!this.auth) {
-      throw new Error("Firebase Auth is not initialized");
-    }
+    if (!this.auth) throw new Error("Firebase Auth is not initialized");
 
     try {
-      const userCredential = await signInWithEmailAndPassword(
-        this.auth,
-        credentials.email.trim(),
-        credentials.password
-      );
+      const userCredential = await signInWithEmailAndPassword(this.auth, credentials.email.trim(), credentials.password);
       const user = mapToAuthUser(userCredential.user);
-      if (!user) {
-        throw new Error("Failed to sign in");
-      }
+      if (!user) throw new Error("Failed to sign in");
       return user;
     } catch (error: unknown) {
       throw mapFirebaseAuthError(error);
@@ -69,55 +52,31 @@ export class FirebaseAuthProvider implements IAuthProvider {
   }
 
   async signUp(credentials: SignUpCredentials): Promise<AuthUser> {
-    if (!this.auth) {
-      throw new Error("Firebase Auth is not initialized");
-    }
+    if (!this.auth) throw new Error("Firebase Auth is not initialized");
 
     try {
       const currentUser = this.auth.currentUser;
       const isAnonymous = currentUser?.isAnonymous ?? false;
-
       let userCredential;
 
-      // Convert anonymous user to permanent account
       if (currentUser && isAnonymous) {
-        // Reload user to refresh token before linking (prevents token-expired errors)
-        try {
-          await currentUser.reload();
-        } catch {
-          // Reload failed, proceed with link anyway
-        }
-
-        const credential = EmailAuthProvider.credential(
-          credentials.email.trim(),
-          credentials.password
-        );
-
+        try { await currentUser.reload(); } catch { /* Reload failed, proceed */ }
+        const credential = EmailAuthProvider.credential(credentials.email.trim(), credentials.password);
         userCredential = await linkWithCredential(currentUser, credential);
       } else {
-        // Create new user
-        userCredential = await createUserWithEmailAndPassword(
-          this.auth,
-          credentials.email.trim(),
-          credentials.password
-        );
+        userCredential = await createUserWithEmailAndPassword(this.auth, credentials.email.trim(), credentials.password);
       }
 
       if (credentials.displayName && userCredential.user) {
         try {
-          await updateProfile(userCredential.user, {
-            displayName: credentials.displayName.trim(),
-          });
+          await updateProfile(userCredential.user, { displayName: credentials.displayName.trim() });
         } catch {
-          // Silently fail - the account was created successfully,
-          // only the display name update failed. User can update it later.
+          /* Display name update failed, account created successfully */
         }
       }
 
       const user = mapToAuthUser(userCredential.user);
-      if (!user) {
-        throw new Error("Failed to create user account");
-      }
+      if (!user) throw new Error("Failed to create user account");
       return user;
     } catch (error: unknown) {
       throw mapFirebaseAuthError(error);
@@ -125,10 +84,7 @@ export class FirebaseAuthProvider implements IAuthProvider {
   }
 
   async signOut(): Promise<void> {
-    if (!this.auth) {
-      return;
-    }
-
+    if (!this.auth) return;
     try {
       await firebaseSignOut(this.auth);
     } catch (error: unknown) {
@@ -137,13 +93,9 @@ export class FirebaseAuthProvider implements IAuthProvider {
   }
 
   getCurrentUser(): AuthUser | null {
-    if (!this.auth) {
-      return null;
-    }
+    if (!this.auth) return null;
     const currentUser = this.auth.currentUser;
-    if (!currentUser) {
-      return null;
-    }
+    if (!currentUser) return null;
     return mapToAuthUser(currentUser);
   }
 
@@ -152,9 +104,6 @@ export class FirebaseAuthProvider implements IAuthProvider {
       callback(null);
       return () => {};
     }
-
-    return onAuthStateChanged(this.auth, (user) => {
-      callback(mapToAuthUser(user));
-    });
+    return onAuthStateChanged(this.auth, (user) => callback(mapToAuthUser(user)));
   }
 }

package/src/infrastructure/services/AuthService.ts

@@ -23,9 +23,7 @@ export class AuthService {
   private config: AuthConfig;
 
   constructor(config: Partial<AuthConfig> = {}, storageProvider?: IStorageProvider) {
-    // Validate and sanitize configuration
     this.config = sanitizeAuthConfig(config);
-
     this.anonymousModeService = new AnonymousModeService();
     this.storageProvider = storageProvider;
   }
@@ -87,17 +85,12 @@ export class AuthService {
   }
 
   async setAnonymousMode(): Promise<void> {
-    if (!this.storageProvider) {
-      throw new Error("Storage provider is required for anonymous mode");
-    }
+    if (!this.storageProvider) throw new Error("Storage provider is required for anonymous mode");
     await this.anonymousModeService.enable(this.storageProvider);
   }
 
   getCurrentUser(): AuthUser | null {
     if (!this.initialized) return null;
-    // Return the actual Firebase user regardless of anonymous mode
-    // The caller should check the user's isAnonymous property if needed
-    // This ensures proper anonymous to registered user conversion
     return this.repositoryInstance.getCurrentUser();
   }
 

package/src/presentation/hooks/useAuth.ts

@@ -1,9 +1,6 @@
 /**
  * useAuth Hook
  * React hook for authentication state management
- *
- * Uses centralized Zustand store for auth state.
- * Single source of truth - no duplicate subscriptions.
  */
 
 import { useCallback } from "react";
@@ -32,44 +29,23 @@ import {
 import type { AuthUser } from "../../domain/entities/AuthUser";
 
 export interface UseAuthResult {
-  /** Current authenticated user */
   user: AuthUser | null;
-  /** Current user ID (uid) */
   userId: string | null;
-  /** Current user type */
   userType: UserType;
-  /** Whether auth state is loading */
   loading: boolean;
-  /** Whether auth is ready (initialized and not loading) */
   isAuthReady: boolean;
-  /** Whether user is anonymous */
   isAnonymous: boolean;
-  /** Whether user is authenticated (not anonymous) */
   isAuthenticated: boolean;
-  /** Whether user is a registered user (authenticated AND not anonymous) */
   isRegisteredUser: boolean;
-  /** Current error message */
   error: string | null;
-  /** Sign up function */
   signUp: (email: string, password: string, displayName?: string) => Promise<void>;
-  /** Sign in function */
   signIn: (email: string, password: string) => Promise<void>;
-  /** Sign out function */
   signOut: () => Promise<void>;
-  /** Continue anonymously function */
   continueAnonymously: () => Promise<void>;
-  /** Set error manually (for form validation, etc.) */
   setError: (error: string | null) => void;
 }
 
-/**
- * Hook for authentication state management
- *
- * Uses centralized Zustand store - all components share the same state.
- * Must call initializeAuthListener() once in app root.
- */
 export function useAuth(): UseAuthResult {
-  // State from store - using typed selectors
   const user = useAuthStore(selectUser);
   const loading = useAuthStore(selectLoading);
   const error = useAuthStore(selectError);
@@ -79,13 +55,10 @@ export function useAuth(): UseAuthResult {
   const isAnonymous = useAuthStore(selectIsAnonymous);
   const isAuthReady = useAuthStore(selectIsAuthReady);
   const isRegisteredUser = useAuthStore(selectIsRegisteredUser);
-
-  // Actions from store - using typed selectors
   const setLoading = useAuthStore(selectSetLoading);
   const setError = useAuthStore(selectSetError);
   const setIsAnonymous = useAuthStore(selectSetIsAnonymous);
 
-  // Mutations
   const signInMutation = useSignInMutation();
   const signUpMutation = useSignUpMutation();
   const signOutMutation = useSignOutMutation();
@@ -99,8 +72,7 @@ export function useAuth(): UseAuthResult {
         await signUpMutation.mutateAsync({ email, password, displayName });
         setIsAnonymous(false);
       } catch (err: unknown) {
-        const errorMessage = err instanceof Error ? err.message : "Sign up failed";
-        setError(errorMessage);
+        setError(err instanceof Error ? err.message : "Sign up failed");
         throw err;
       } finally {
         setLoading(false);
@@ -117,8 +89,7 @@ export function useAuth(): UseAuthResult {
         await signInMutation.mutateAsync({ email, password });
         setIsAnonymous(false);
       } catch (err: unknown) {
-        const errorMessage = err instanceof Error ? err.message : "Sign in failed";
-        setError(errorMessage);
+        setError(err instanceof Error ? err.message : "Sign in failed");
         throw err;
       } finally {
         setLoading(false);
@@ -133,8 +104,7 @@ export function useAuth(): UseAuthResult {
       setError(null);
       await signOutMutation.mutateAsync();
     } catch (err: unknown) {
-      const errorMessage = err instanceof Error ? err.message : "Sign out failed";
-      setError(errorMessage);
+      setError(err instanceof Error ? err.message : "Sign out failed");
       throw err;
     } finally {
       setLoading(false);
@@ -147,7 +117,6 @@ export function useAuth(): UseAuthResult {
       await anonymousModeMutation.mutateAsync();
       setIsAnonymous(true);
     } catch {
-      // Silently fail - anonymous mode is optional
       setIsAnonymous(true);
     } finally {
       setLoading(false);
@@ -155,19 +124,7 @@ export function useAuth(): UseAuthResult {
   }, [setIsAnonymous, setLoading, anonymousModeMutation]);
 
   return {
-    user,
-    userId,
-    userType,
-    loading,
-    isAuthReady,
-    isAnonymous,
-    isAuthenticated,
-    isRegisteredUser,
-    error,
-    signUp,
-    signIn,
-    signOut,
-    continueAnonymously,
-    setError,
+    user, userId, userType, loading, isAuthReady, isAnonymous, isAuthenticated, isRegisteredUser, error,
+    signUp, signIn, signOut, continueAnonymously, setError,
   };
 }

package/src/presentation/hooks/useGoogleAuth.ts

@@ -1,19 +1,10 @@
 /**
  * useGoogleAuth Hook
  * Handles Google OAuth flow using expo-auth-session and Firebase auth
- *
- * This hook provides complete Google sign-in flow:
- * 1. OAuth flow via expo-auth-session
- * 2. Firebase authentication with the obtained token
  */
 
 import { useState, useCallback, useEffect } from "react";
-import {
-  useSocialAuth,
-  type SocialAuthConfig,
-  type SocialAuthResult,
-} from "@umituz/react-native-firebase";
-
+import { useSocialAuth, type SocialAuthConfig, type SocialAuthResult } from "@umituz/react-native-firebase";
 import * as Google from "expo-auth-session/providers/google";
 import * as WebBrowser from "expo-web-browser";
 
@@ -34,38 +25,25 @@ export interface UseGoogleAuthResult {
 
 const PLACEHOLDER_CLIENT_ID = "000000000000-placeholder.apps.googleusercontent.com";
 
-/**
- * Validate Google auth config
- */
 function validateGoogleConfig(config?: GoogleAuthConfig): boolean {
   if (!config) return false;
-
-  const hasValidClientId =
-    !!(config.iosClientId && config.iosClientId !== PLACEHOLDER_CLIENT_ID) ||
-    !!(config.webClientId && config.webClientId !== PLACEHOLDER_CLIENT_ID) ||
-    !!(config.androidClientId && config.androidClientId !== PLACEHOLDER_CLIENT_ID);
-
-  return hasValidClientId;
+  return !!(
+    (config.iosClientId && config.iosClientId !== PLACEHOLDER_CLIENT_ID) ||
+    (config.webClientId && config.webClientId !== PLACEHOLDER_CLIENT_ID) ||
+    (config.androidClientId && config.androidClientId !== PLACEHOLDER_CLIENT_ID)
+  );
 }
 
-/**
- * Hook for Google authentication with expo-auth-session
- */
 export function useGoogleAuth(config?: GoogleAuthConfig): UseGoogleAuthResult {
   const [isLoading, setIsLoading] = useState(false);
   const [googleError, setGoogleError] = useState<string | null>(null);
-
   const googleConfigured = validateGoogleConfig(config);
 
-  const socialAuthConfig: SocialAuthConfig = {
+  const { signInWithGoogleToken, googleLoading: firebaseLoading } = useSocialAuth({
     google: config,
     apple: { enabled: false },
-  };
-
-  const { signInWithGoogleToken, googleLoading: firebaseLoading } =
-    useSocialAuth(socialAuthConfig);
+  } as SocialAuthConfig);
 
-  // Use Google auth request if available
   const authRequest = Google?.useAuthRequest({
     iosClientId: config?.iosClientId || PLACEHOLDER_CLIENT_ID,
     webClientId: config?.webClientId || PLACEHOLDER_CLIENT_ID,
@@ -76,7 +54,6 @@ export function useGoogleAuth(config?: GoogleAuthConfig): UseGoogleAuthResult {
   const googleResponse = authRequest?.[1] ?? null;
   const promptGoogleAsync = authRequest?.[2];
 
-  // Handle Google OAuth response
   useEffect(() => {
     if (googleResponse?.type === "success") {
       const idToken = googleResponse.authentication?.idToken;
@@ -84,13 +61,8 @@ export function useGoogleAuth(config?: GoogleAuthConfig): UseGoogleAuthResult {
         setIsLoading(true);
         setGoogleError(null);
         signInWithGoogleToken(idToken)
-          .catch((error) => {
-            const errorMessage = error instanceof Error ? error.message : "Firebase sign-in failed";
-            setGoogleError(errorMessage);
-          })
-          .finally(() => {
-            setIsLoading(false);
-          });
+          .catch((error) => { setGoogleError(error instanceof Error ? error.message : "Firebase sign-in failed"); })
+          .finally(() => { setIsLoading(false); });
       }
     } else if (googleResponse?.type === "error") {
       setGoogleError("Google authentication failed");
@@ -123,10 +95,7 @@ export function useGoogleAuth(config?: GoogleAuthConfig): UseGoogleAuthResult {
       const result = await promptGoogleAsync();
 
       if (result.type === "success" && result.authentication?.idToken) {
-        const firebaseResult = await signInWithGoogleToken(
-          result.authentication.idToken,
-        );
-        return firebaseResult;
+        return await signInWithGoogleToken(result.authentication.idToken);
       }
 
       if (result.type === "cancel") {
@@ -141,10 +110,7 @@ export function useGoogleAuth(config?: GoogleAuthConfig): UseGoogleAuthResult {
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Google sign-in failed";
       setGoogleError(errorMessage);
-      return {
-        success: false,
-        error: errorMessage,
-      };
+      return { success: false, error: errorMessage };
     } finally {
       setIsLoading(false);
     }

package/src/presentation/utils/authOperation.util.ts

@@ -0,0 +1,67 @@
+/**
+ * Auth Operation Utilities
+ * Shared error handling for authentication operations
+ */
+
+import { useCallback } from "react";
+
+export interface AuthOperationOptions {
+  setLoading: (loading: boolean) => void;
+  setError: (error: string | null) => void;
+  onSuccess?: () => void;
+}
+
+/**
+ * Create an auth operation wrapper with consistent error handling
+ */
+export function createAuthOperation<T>(
+  mutation: (params: T) => Promise<unknown>,
+  options: AuthOperationOptions
+) {
+  const { setLoading, setError, onSuccess } = options;
+
+  return useCallback(
+    async (params: T) => {
+      try {
+        setLoading(true);
+        setError(null);
+        await mutation(params);
+        onSuccess?.();
+      } catch (err: unknown) {
+        const errorMessage = err instanceof Error ? err.message : "Operation failed";
+        setError(errorMessage);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [setLoading, setError, onSuccess, mutation]
+  );
+}
+
+/**
+ * Create auth operation that doesn't throw on failure
+ */
+export function createSilentAuthOperation<T>(
+  mutation: (params: T) => Promise<unknown>,
+  options: AuthOperationOptions
+) {
+  const { setLoading, setError, onSuccess } = options;
+
+  return useCallback(
+    async (params?: T) => {
+      try {
+        setLoading(true);
+        setError(null);
+        await mutation(params as T);
+        onSuccess?.();
+      } catch {
+        // Silently fail
+        onSuccess?.();
+      } finally {
+        setLoading(false);
+      }
+    },
+    [setLoading, setError, onSuccess, mutation]
+  );
+}

package/src/presentation/utils/form/formValidation.util.ts

@@ -39,16 +39,7 @@ export interface ProfileFormValues {
   email: string;
 }
 
-/**
- * Validate login form fields
- * @param values - Form values to validate
- * @param getErrorMessage - Function to get localized error messages
- * @returns Validation result
- */
-export function validateLoginForm(
-  values: LoginFormValues,
-  getErrorMessage: (key: string) => string
-): FormValidationResult {
+export function validateLoginForm(values: LoginFormValues, getErrorMessage: (key: string) => string): FormValidationResult {
   const errors: FormValidationError[] = [];
 
   const emailResult = validateEmail(values.email.trim());
@@ -61,19 +52,9 @@ export function validateLoginForm(
     errors.push({ field: "password", message: getErrorMessage(passwordResult.error) });
   }
 
-  return {
-    isValid: errors.length === 0,
-    errors,
-  };
+  return { isValid: errors.length === 0, errors };
 }
 
-/**
- * Validate register form fields
- * @param values - Form values to validate
- * @param getErrorMessage - Function to get localized error messages
- * @param passwordConfig - Password configuration
- * @returns Validation result
- */
 export function validateRegisterForm(
   values: RegisterFormValues,
   getErrorMessage: (key: string) => string,
@@ -96,17 +77,9 @@ export function validateRegisterForm(
     errors.push({ field: "confirmPassword", message: getErrorMessage(confirmResult.error) });
   }
 
-  return {
-    isValid: errors.length === 0,
-    errors,
-  };
+  return { isValid: errors.length === 0, errors };
 }
 
-/**
- * Validate profile form fields
- * @param values - Form values to validate
- * @returns Validation result
- */
 export function validateProfileForm(values: ProfileFormValues): FormValidationResult {
   const errors: FormValidationError[] = [];
 
@@ -121,20 +94,10 @@ export function validateProfileForm(values: ProfileFormValues): FormValidationRe
     }
   }
 
-  return {
-    isValid: errors.length === 0,
-    errors,
-  };
+  return { isValid: errors.length === 0, errors };
 }
 
-/**
- * Convert validation errors to field error object
- * @param errors - Validation errors
- * @returns Object mapping field names to error messages
- */
-export function errorsToFieldErrors(
-  errors: FormValidationError[]
-): Record<string, string> {
+export function errorsToFieldErrors(errors: FormValidationError[]): Record<string, string> {
   const result: Record<string, string> = {};
   for (const error of errors) {
     result[error.field] = error.message;
@@ -142,32 +105,13 @@ export function errorsToFieldErrors(
   return result;
 }
 
-/**
- * Hook for form validation with error message resolution
- * @param getErrorMessage - Function to get localized error messages
- * @returns Validation functions
- */
 export function useFormValidation(getErrorMessage: (key: string) => string) {
-  const validateLogin = useCallback(
-    (values: LoginFormValues) => validateLoginForm(values, getErrorMessage),
-    [getErrorMessage]
-  );
-
+  const validateLogin = useCallback((values: LoginFormValues) => validateLoginForm(values, getErrorMessage), [getErrorMessage]);
   const validateRegister = useCallback(
-    (values: RegisterFormValues, passwordConfig: PasswordConfig) =>
-      validateRegisterForm(values, getErrorMessage, passwordConfig),
+    (values: RegisterFormValues, passwordConfig: PasswordConfig) => validateRegisterForm(values, getErrorMessage, passwordConfig),
     [getErrorMessage]
   );
+  const validateProfile = useCallback((values: ProfileFormValues) => validateProfileForm(values), []);
 
-  const validateProfile = useCallback(
-    (values: ProfileFormValues) => validateProfileForm(values),
-    []
-  );
-
-  return {
-    validateLogin,
-    validateRegister,
-    validateProfile,
-    errorsToFieldErrors,
-  };
+  return { validateLogin, validateRegister, validateProfile, errorsToFieldErrors };
 }