@umituz/react-native-auth 4.3.1 → 4.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-auth",
-  "version": "4.3.1",
+  "version": "4.3.3",
   "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",

package/src/application/services/ValidationService.ts

@@ -0,0 +1,44 @@
+/**
+ * Validation Service (Application Layer)
+ * Facade for validation functions to be used by presentation layer
+ * Follows DDD architecture - presentation imports from application, not infrastructure
+ */
+
+// Validation functions
+export {
+  validateEmail,
+  validatePasswordForLogin,
+  validatePasswordForRegister,
+  validatePasswordConfirmation,
+  validateDisplayName,
+} from "../../infrastructure/utils/AuthValidation";
+
+// validation types
+export type {
+  ValidationResult,
+  PasswordStrengthResult,
+  PasswordRequirements,
+  BaseValidationResult,
+  FormValidationError,
+  FormValidationResult,
+} from "../../infrastructure/utils/validation/types";
+
+// validation helpers
+export {
+  isEmpty,
+  isEmptyEmail,
+  isEmptyPassword,
+  isEmptyName,
+  isNotEmpty,
+  hasContent,
+} from "../../infrastructure/utils/validation/validationHelpers";
+
+// Sanitization functions
+export {
+  sanitizeEmail,
+  sanitizePassword,
+  sanitizeName,
+  SECURITY_LIMITS,
+} from "../../infrastructure/utils/validation/sanitization";
+
+export type { SecurityLimitKey } from "../../infrastructure/utils/validation/sanitization";

package/src/index.ts

@@ -32,8 +32,11 @@ export { initializeAuth, isAuthInitialized, resetAuthInitialization } from './in
 export type { InitializeAuthOptions } from './infrastructure/services/initializeAuth';
 export { validateEmail, validatePasswordForLogin, validatePasswordForRegister, validatePasswordConfirmation, validateDisplayName } from './infrastructure/utils/AuthValidation';
 export type { ValidationResult, PasswordStrengthResult, PasswordRequirements } from './infrastructure/utils/AuthValidation';
-export { SECURITY_LIMITS, sanitizeWhitespace, sanitizeEmail, sanitizePassword, sanitizeName, sanitizeText, containsDangerousChars, isWithinLengthLimit } from './infrastructure/utils/validation/sanitization';
+export type { BaseValidationResult, FormValidationError, FormValidationResult } from './infrastructure/utils/validation/types';
+export { SECURITY_LIMITS, sanitizeEmail, sanitizePassword, sanitizeName } from './infrastructure/utils/validation/sanitization';
 export type { SecurityLimitKey } from './infrastructure/utils/validation/sanitization';
+export { isEmpty, isEmptyEmail, isEmptyPassword, isEmptyName, isNotEmpty, hasContent } from './infrastructure/utils/validation/validationHelpers';
+export { safeCallback, safeCallbackSync } from './infrastructure/utils/safeCallback';
 export { getEffectiveUserId } from './infrastructure/utils/getEffectiveUserId';
 
 // =============================================================================
@@ -66,6 +69,10 @@ export { useAuthHandlers } from './presentation/hooks/useAuthHandlers';
 export type { AuthHandlersAppInfo, AuthHandlersTranslations } from './presentation/hooks/useAuthHandlers';
 export { usePasswordPromptNavigation } from './presentation/hooks/usePasswordPromptNavigation';
 export type { UsePasswordPromptNavigationOptions, UsePasswordPromptNavigationReturn } from './presentation/hooks/usePasswordPromptNavigation';
+export { useAuthErrorHandler } from './presentation/hooks/useAuthErrorHandler';
+export type { UseAuthErrorHandlerConfig, UseAuthErrorHandlerResult } from './presentation/hooks/useAuthErrorHandler';
+export { useLocalError } from './presentation/hooks/useLocalError';
+export type { UseLocalErrorResult } from './presentation/hooks/useLocalError';
 
 // =============================================================================
 // PRESENTATION LAYER - Components

package/src/infrastructure/utils/AuthValidation.ts

@@ -1,14 +1,17 @@
 import type { PasswordConfig } from "../../domain/value-objects/AuthConfig";
+import { isEmptyEmail, isEmptyPassword, isEmptyName } from "./validation/validationHelpers";
+import type {
+  ValidationResult,
+  PasswordStrengthResult,
+  PasswordRequirements,
+} from "./validation/types";
 
-export interface ValidationResult {
-  isValid: boolean;
-  error?: string;
-}
-
-export interface PasswordStrengthResult extends ValidationResult { requirements: PasswordRequirements; }
-export interface PasswordRequirements {
-  hasMinLength: boolean;
-}
+// Export validation types
+export type {
+  ValidationResult,
+  PasswordStrengthResult,
+  PasswordRequirements,
+};
 
 export interface ValidationConfig {
   emailRegex: RegExp;
@@ -28,14 +31,14 @@ export function validateEmail(
   email: string,
   config: ValidationConfig = DEFAULT_VAL_CONFIG
 ): ValidationResult {
-  if (!email || email.trim() === "") return { isValid: false, error: "auth.validation.emailRequired" };
+  if (isEmptyEmail(email)) return { isValid: false, error: "auth.validation.emailRequired" };
   if (!config.emailRegex.test(email.trim())) return { isValid: false, error: "auth.validation.invalidEmail" };
   return { isValid: true };
 }
 
 export function validatePasswordForLogin(password: string): ValidationResult {
   // Don't trim passwords - whitespace may be intentional
-  if (!password || password.length === 0) return { isValid: false, error: "auth.validation.passwordRequired" };
+  if (isEmptyPassword(password)) return { isValid: false, error: "auth.validation.passwordRequired" };
   return { isValid: true };
 }
 
@@ -44,7 +47,7 @@ export function validatePasswordForRegister(
   config: PasswordConfig,
 ): PasswordStrengthResult {
   // Don't trim passwords - whitespace may be intentional
-  if (!password || password.length === 0) {
+  if (isEmptyPassword(password)) {
     return { isValid: false, error: "auth.validation.passwordRequired", requirements: { hasMinLength: false } };
   }
 
@@ -59,7 +62,7 @@ export function validatePasswordForRegister(
 
 export function validatePasswordConfirmation(password: string, confirm: string): ValidationResult {
   // Don't trim passwords - whitespace may be intentional
-  if (!confirm || confirm.length === 0) return { isValid: false, error: "auth.validation.confirmPasswordRequired" };
+  if (isEmptyPassword(confirm)) return { isValid: false, error: "auth.validation.confirmPasswordRequired" };
   if (password !== confirm) return { isValid: false, error: "auth.validation.passwordsDoNotMatch" };
   return { isValid: true };
 }
@@ -68,7 +71,7 @@ export function validateDisplayName(
   name: string,
   minLength: number = DEFAULT_VAL_CONFIG.displayNameMinLength
 ): ValidationResult {
-  if (!name || name.trim() === "") return { isValid: false, error: "auth.validation.nameRequired" };
+  if (isEmptyName(name)) return { isValid: false, error: "auth.validation.nameRequired" };
   if (name.trim().length < minLength) return { isValid: false, error: "auth.validation.nameTooShort" };
   return { isValid: true };
 }

package/src/infrastructure/utils/authConversionDetector.ts

@@ -29,7 +29,7 @@ export function detectConversion(
   const isSameUser =
     previousUserId === currentUserId && wasAnonymous && !isCurrentlyAnonymous;
 
-  // Different UID after anonymous (legacy flow)
+  // Different UID after anonymous (account creation with new credentials)
   const isNewUser =
     !!previousUserId &&
     previousUserId !== currentUserId &&

package/src/infrastructure/utils/authStateHandler.ts

@@ -6,6 +6,7 @@
 import type { User } from "firebase/auth";
 import { ensureUserDocument } from "@umituz/react-native-firebase";
 import { detectConversion, type ConversionState } from "./authConversionDetector";
+import { safeCallback } from "./safeCallback";
 
 export interface AuthStateHandlerOptions {
   onUserConverted?: (anonymousId: string, authenticatedId: string) => void | Promise<void>;
@@ -24,7 +25,7 @@ export function createAuthStateHandler(
 
     if (!user) {
       state.current = { previousUserId: null, wasAnonymous: false };
-      await onAuthStateChange?.(null);
+      await safeCallback(onAuthStateChange, [null], '[AuthStateHandler]');
       return;
     }
 
@@ -34,11 +35,11 @@ export function createAuthStateHandler(
     const conversion = detectConversion(state.current, currentUserId, isCurrentlyAnonymous);
 
     if (conversion.isConversion && onUserConverted && state.current.previousUserId) {
-      try {
-        await onUserConverted(state.current.previousUserId, currentUserId);
-      } catch {
-        // Silently fail - conversion callback errors are handled elsewhere
-      }
+      await safeCallback(
+        onUserConverted,
+        [state.current.previousUserId, currentUserId],
+        '[AuthStateHandler]'
+      );
     }
 
     const extras = conversion.isConversion && state.current.previousUserId
@@ -58,13 +59,6 @@ export function createAuthStateHandler(
     };
 
     // Call user callback with error handling
-    if (onAuthStateChange) {
-      try {
-        await onAuthStateChange(user);
-      } catch (error) {
-        console.error('[AuthStateHandler] User callback error:', error);
-        // Don't propagate user callback errors
-      }
-    }
+    await safeCallback(onAuthStateChange, [user], '[AuthStateHandler]');
   };
 }

package/src/infrastructure/utils/error/errorCodeMapping.constants.ts

@@ -9,8 +9,8 @@ import { CONFIG_ERROR_MAPPINGS } from "./mappings/configErrorMappings";
 import { NETWORK_ERROR_MAPPINGS } from "./mappings/networkErrorMappings";
 import { ACTION_CODE_ERROR_MAPPINGS } from "./mappings/actionCodeErrorMappings";
 
-// Re-export types for backward compatibility
-export type { ErrorConstructor, ErrorFactory, ErrorMapping } from "./mappings/errorMapping.types";
+// Export types needed by AuthErrorMapper
+export type { ErrorConstructor, ErrorFactory } from "./mappings/errorMapping.types";
 
 /**
  * Combined Firebase error code to domain error mapping

package/src/infrastructure/utils/listener/{authStateHandler.ts → authListenerStateHandler.ts}

@@ -7,6 +7,7 @@ import type { Auth, User } from "firebase/auth";
 import type { AuthActions } from "../../../types/auth-store.types";
 import { completeInitialization } from "./listenerState.util";
 import { handleAnonymousMode } from "./anonymousHandler";
+import { safeCallbackSync } from "../safeCallback";
 
 type Store = AuthActions & { isAnonymous: boolean };
 
@@ -38,19 +39,7 @@ export function handleAuthStateChange(
     }
 
     // Call user callback with proper error handling for async callbacks
-    if (onAuthStateChange) {
-      try {
-        const result = onAuthStateChange(user);
-        // If callback returns a promise, catch rejections
-        if (result && typeof result.then === 'function') {
-          result.catch((error) => {
-            console.error("[AuthListener] User callback promise rejected:", error);
-          });
-        }
-      } catch (error) {
-        console.error("[AuthListener] User callback error:", error);
-      }
-    }
+    safeCallbackSync(onAuthStateChange, [user], '[AuthListener]');
   } catch (error) {
     console.error("[AuthListener] Error handling auth state change:", error);
     // Ensure we don't leave the app in a bad state

package/src/infrastructure/utils/listener/listenerLifecycle.util.ts

@@ -1,6 +1,6 @@
 /**
  * Auth Listener Lifecycle - Main Export
- * Re-exports all listener lifecycle utilities from modular files
+ * Exports all listener lifecycle utilities from modular files
  */
 
 // Cleanup handlers
@@ -14,7 +14,7 @@ export {
 export { setupAuthListener } from "./setupListener";
 
 // Auth state handler
-export { handleAuthStateChange } from "./authStateHandler";
+export { handleAuthStateChange } from "./authListenerStateHandler";
 
 // Anonymous mode handler
 export { handleAnonymousMode } from "./anonymousHandler";

package/src/infrastructure/utils/listener/setupListener.ts

@@ -8,7 +8,7 @@ import { onIdTokenChanged } from "firebase/auth";
 import type { AuthActions } from "../../../types/auth-store.types";
 import { getAuthService } from "../../services/AuthService";
 import { completeInitialization, setUnsubscribe } from "./listenerState.util";
-import { handleAuthStateChange } from "./authStateHandler";
+import { handleAuthStateChange } from "./authListenerStateHandler";
 
 type Store = AuthActions & { isAnonymous: boolean };
 

package/src/infrastructure/utils/safeCallback.ts

@@ -0,0 +1,80 @@
+/**
+ * Safe Callback Wrapper
+ * Standardized error handling for user-provided callbacks
+ */
+
+/**
+ * Safely executes a user-provided callback with comprehensive error handling
+ * Handles both synchronous errors and promise rejections
+ *
+ * @param callback - The callback to execute (can be sync or async)
+ * @param args - Arguments to pass to the callback
+ * @param errorPrefix - Prefix for error logging (for debugging)
+ * @returns Promise that resolves when callback completes (or fails safely)
+ *
+ * @example
+ * ```typescript
+ * // With async callback
+ * await safeCallback(onAuthStateChange, [user], '[AuthListener]');
+ *
+ * // With sync callback
+ * await safeCallback(onUserConverted, [anonymousId, authenticatedId], '[AuthStateHandler]');
+ * ```
+ */
+export async function safeCallback<T extends unknown[]>(
+  callback: ((...args: T) => void | Promise<void>) | undefined,
+  args: T,
+  errorPrefix: string = '[Callback]'
+): Promise<void> {
+  if (!callback) return;
+
+  try {
+    const result = callback(...args);
+
+    // If callback returns a promise, await it and catch rejections
+    if (result && typeof result.then === 'function') {
+      await result.catch((error) => {
+        console.error(`${errorPrefix} User callback promise rejected:`, error);
+      });
+    }
+  } catch (error) {
+    // Catch synchronous errors
+    console.error(`${errorPrefix} User callback error:`, error);
+  }
+}
+
+/**
+ * Synchronously executes a user-provided callback with error handling
+ * Use this when you don't want to await the callback (fire-and-forget)
+ *
+ * @param callback - The callback to execute (can be sync or async)
+ * @param args - Arguments to pass to the callback
+ * @param errorPrefix - Prefix for error logging (for debugging)
+ *
+ * @example
+ * ```typescript
+ * // Fire-and-forget pattern
+ * safeCallbackSync(onAuthStateChange, [user], '[AuthListener]');
+ * ```
+ */
+export function safeCallbackSync<T extends unknown[]>(
+  callback: ((...args: T) => void | Promise<void>) | undefined,
+  args: T,
+  errorPrefix: string = '[Callback]'
+): void {
+  if (!callback) return;
+
+  try {
+    const result = callback(...args);
+
+    // If callback returns a promise, catch rejections but don't await
+    if (result && typeof result.then === 'function') {
+      result.catch((error) => {
+        console.error(`${errorPrefix} User callback promise rejected:`, error);
+      });
+    }
+  } catch (error) {
+    // Catch synchronous errors
+    console.error(`${errorPrefix} User callback error:`, error);
+  }
+}

package/src/infrastructure/utils/validation/sanitization.ts

@@ -13,7 +13,11 @@ export const SECURITY_LIMITS = {
 
 export type SecurityLimitKey = keyof typeof SECURITY_LIMITS;
 
-export const sanitizeWhitespace = (input: string): string => {
+/**
+ * Internal helper to sanitize whitespace
+ * Used by sanitizeName
+ */
+const sanitizeWhitespace = (input: string): string => {
   if (!input) return '';
   return input.trim().replace(/\s+/g, ' ');
 };
@@ -37,32 +41,3 @@ export const sanitizeName = (name: string): string => {
   const noTags = trimmed.replace(/<[^>]*>/g, '');
   return noTags.substring(0, SECURITY_LIMITS.NAME_MAX_LENGTH);
 };
-
-export const sanitizeText = (text: string): string => {
-  if (!text) return '';
-  const trimmed = sanitizeWhitespace(text);
-  const noTags = trimmed.replace(/<[^>]*>/g, '');
-  return noTags.substring(0, SECURITY_LIMITS.GENERAL_TEXT_MAX_LENGTH);
-};
-
-export const containsDangerousChars = (input: string): boolean => {
-  if (!input) return false;
-  const dangerousPatterns = [
-    /<script/i,
-    /javascript:/i,
-    /on\w+\s*=/i,
-    /<iframe/i,
-    /eval\(/i,
-  ];
-  return dangerousPatterns.some(pattern => pattern.test(input));
-};
-
-export const isWithinLengthLimit = (
-  input: string,
-  maxLength: number,
-  minLength = 0
-): boolean => {
-  if (!input) return minLength === 0;
-  const length = input.trim().length;
-  return length >= minLength && length <= maxLength;
-};

package/src/infrastructure/utils/validation/types.ts

@@ -0,0 +1,53 @@
+/**
+ * Validation Types
+ * Shared type definitions for validation results across the application
+ */
+
+/**
+ * Base validation result
+ * Common interface for all validation results
+ */
+export interface BaseValidationResult {
+  isValid: boolean;
+}
+
+/**
+ * Single field validation result
+ * Used for validating individual fields (email, password, etc.)
+ */
+export interface ValidationResult extends BaseValidationResult {
+  error?: string;
+}
+
+/**
+ * Form validation error
+ * Represents an error for a specific form field
+ */
+export interface FormValidationError {
+  field: string;
+  message: string;
+}
+
+/**
+ * Multi-field form validation result
+ * Used for validating entire forms with multiple fields
+ */
+export interface FormValidationResult extends BaseValidationResult {
+  errors: FormValidationError[];
+}
+
+/**
+ * Password requirements
+ * Tracks which password requirements are met
+ */
+export interface PasswordRequirements {
+  hasMinLength: boolean;
+}
+
+/**
+ * Password strength validation result
+ * Extends ValidationResult with password-specific requirements
+ */
+export interface PasswordStrengthResult extends ValidationResult {
+  requirements: PasswordRequirements;
+}

package/src/infrastructure/utils/validation/validationHelpers.ts

@@ -0,0 +1,70 @@
+/**
+ * Validation Helpers
+ * Standardized helper functions for common validation checks
+ */
+
+/**
+ * Check if a string is empty or null/undefined
+ * Handles null/undefined gracefully
+ *
+ * @param value - String to check
+ * @returns true if empty, null, or undefined
+ */
+export function isEmpty(value: string | null | undefined): boolean {
+  return !value || value.trim() === '';
+}
+
+/**
+ * Check if an email is empty or null/undefined
+ * Email-specific validation that checks for empty after trimming
+ *
+ * @param email - Email to check
+ * @returns true if empty, null, or undefined
+ */
+export function isEmptyEmail(email: string | null | undefined): boolean {
+  return !email || email.trim() === '';
+}
+
+/**
+ * Check if a password is empty or null/undefined
+ * Password-specific validation - does NOT trim (whitespace may be intentional)
+ *
+ * @param password - Password to check
+ * @returns true if empty, null, or undefined
+ */
+export function isEmptyPassword(password: string | null | undefined): boolean {
+  return !password || password.length === 0;
+}
+
+/**
+ * Check if a name is empty or null/undefined
+ * Name-specific validation that checks for empty after trimming
+ *
+ * @param name - Name to check
+ * @returns true if empty, null, or undefined
+ */
+export function isEmptyName(name: string | null | undefined): boolean {
+  return !name || name.trim() === '';
+}
+
+/**
+ * Check if a value is not empty
+ * Convenience function - inverse of isEmpty
+ *
+ * @param value - String to check
+ * @returns true if not empty
+ */
+export function isNotEmpty(value: string | null | undefined): boolean {
+  return !isEmpty(value);
+}
+
+/**
+ * Check if a value has content (not empty and has non-whitespace characters)
+ * Stricter than isNotEmpty - ensures actual content exists
+ *
+ * @param value - String to check
+ * @returns true if has actual content
+ */
+export function hasContent(value: string | null | undefined): boolean {
+  return !!value && value.trim().length > 0;
+}

package/src/presentation/components/PasswordStrengthIndicator.tsx

@@ -1,7 +1,7 @@
 import React from "react";
 import { View, StyleSheet } from "react-native";
 import { useAppDesignTokens, AtomicText, type ColorVariant } from "@umituz/react-native-design-system";
-import type { PasswordRequirements } from "../../infrastructure/utils/AuthValidation";
+import type { PasswordRequirements } from "../../application/services/ValidationService";
 
 export interface PasswordStrengthTranslations {
   minLength: string;

package/src/presentation/hooks/registerForm/registerFormHandlers.ts

@@ -4,11 +4,9 @@
  */
 
 import { useCallback } from "react";
-import type { FieldErrors } from "./useRegisterForm.types";
+import type { FieldErrors, RegisterFieldKey } from "./useRegisterForm.types";
 import { clearFieldError, clearFieldErrors } from "../../utils/form/formErrorUtils";
 
-type RegisterFieldKey = "displayName" | "email" | "password" | "confirmPassword";
-
 export function useRegisterFormHandlers(
   updateField: (field: RegisterFieldKey, value: string) => void,
   setFieldErrors: React.Dispatch<React.SetStateAction<FieldErrors>>,

package/src/presentation/hooks/registerForm/registerFormSubmit.ts

@@ -10,8 +10,8 @@ import {
   validateRegisterForm,
   errorsToFieldErrors,
 } from "../../utils/form/formValidation.util";
-import { getAuthErrorLocalizationKey } from "../../utils/getAuthErrorMessage";
 import type { FieldErrors, RegisterFormTranslations } from "./useRegisterForm.types";
+import { sanitizeEmail, sanitizeName } from "../../../infrastructure/utils/validation/sanitization";
 
 interface RegisterFormFields {
   displayName: string;
@@ -27,6 +27,7 @@ export function useRegisterFormSubmit(
   setLocalError: React.Dispatch<React.SetStateAction<string | null>>,
   clearFormErrors: () => void,
   getErrorMessage: (key: string) => string,
+  handleAuthError: (error: unknown) => string,
   translations?: RegisterFormTranslations
 ) {
   const handleSignUp = useCallback(async () => {
@@ -34,8 +35,8 @@ export function useRegisterFormSubmit(
 
     const validation = validateRegisterForm(
       {
-        displayName: fields.displayName.trim() || undefined,
-        email: fields.email.trim(),
+        displayName: sanitizeName(fields.displayName) || undefined,
+        email: sanitizeEmail(fields.email),
         password: fields.password,
         confirmPassword: fields.confirmPassword,
       },
@@ -49,16 +50,15 @@ export function useRegisterFormSubmit(
     }
 
     try {
-      await signUp(fields.email.trim(), fields.password, fields.displayName.trim() || undefined);
+      await signUp(sanitizeEmail(fields.email), fields.password, sanitizeName(fields.displayName) || undefined);
 
       if (translations) {
         alertService.success(translations.successTitle, translations.signUpSuccess);
       }
     } catch (err: unknown) {
-      const localizationKey = getAuthErrorLocalizationKey(err);
-      setLocalError(getErrorMessage(localizationKey));
+      setLocalError(handleAuthError(err));
     }
-  }, [fields, signUp, translations, getErrorMessage, clearFormErrors, setFieldErrors, setLocalError]);
+  }, [fields, signUp, translations, handleAuthError, getErrorMessage, clearFormErrors, setFieldErrors, setLocalError]);
 
   return { handleSignUp };
 }

package/src/presentation/hooks/registerForm/useRegisterForm.types.ts

@@ -3,12 +3,10 @@
  * Type definitions for register form hook
  */
 
-export type FieldErrors = {
-  displayName?: string;
-  email?: string;
-  password?: string;
-  confirmPassword?: string;
-};
+import type { FieldErrors as GenericFieldErrors } from "../../utils/form/formErrorUtils";
+
+export type RegisterFieldKey = "displayName" | "email" | "password" | "confirmPassword";
+export type FieldErrors = GenericFieldErrors<RegisterFieldKey>;
 
 export interface RegisterFormTranslations {
   successTitle: string;

package/src/presentation/hooks/useAuthErrorHandler.ts

@@ -0,0 +1,59 @@
+/**
+ * Auth Error Handler Hook
+ * Shared hook for handling auth errors with localization
+ */
+
+import { useCallback } from "react";
+import { getAuthErrorLocalizationKey, resolveErrorMessage } from "../utils/getAuthErrorMessage";
+
+export interface UseAuthErrorHandlerConfig {
+  translations?: Record<string, string>;
+}
+
+export interface UseAuthErrorHandlerResult {
+  handleAuthError: (error: unknown) => string;
+  getErrorMessage: (key: string) => string;
+}
+
+/**
+ * Hook to handle auth errors with localization
+ * Provides consistent error handling across form hooks
+ *
+ * @param config - Optional translations configuration
+ * @returns Error handler function and error message getter
+ *
+ * @example
+ * ```typescript
+ * const { handleAuthError } = useAuthErrorHandler({ translations });
+ *
+ * try {
+ *   await signIn(email, password);
+ * } catch (err) {
+ *   const errorMessage = handleAuthError(err);
+ *   setLocalError(errorMessage);
+ * }
+ * ```
+ */
+export function useAuthErrorHandler(
+  config?: UseAuthErrorHandlerConfig
+): UseAuthErrorHandlerResult {
+  const getErrorMessage = useCallback(
+    (key: string): string => {
+      return resolveErrorMessage(key, config?.translations);
+    },
+    [config?.translations]
+  );
+
+  const handleAuthError = useCallback(
+    (error: unknown): string => {
+      const localizationKey = getAuthErrorLocalizationKey(error);
+      return getErrorMessage(localizationKey);
+    },
+    [getErrorMessage]
+  );
+
+  return {
+    handleAuthError,
+    getErrorMessage,
+  };
+}

package/src/presentation/hooks/useGoogleAuth.ts

@@ -1,14 +1,10 @@
 /**
  * useGoogleAuth Hook
  * Handles Google Sign-In using Firebase auth
- *
- * This is a re-export wrapper around useGoogleOAuth from Firebase package
- * for consistency with the auth package API.
  */
 
 import { useGoogleOAuth } from "@umituz/react-native-firebase";
 
-// Re-export types from firebase
 export type {
   GoogleOAuthConfig as GoogleAuthConfig,
   UseGoogleOAuthResult as UseGoogleAuthResult,
@@ -17,8 +13,6 @@ export type {
 
 /**
  * Hook for Google authentication
- * This is a direct re-export of useGoogleOAuth from firebase package
  */
-// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 export const useGoogleAuth = useGoogleOAuth;
 

package/src/presentation/hooks/useLocalError.ts

@@ -0,0 +1,43 @@
+/**
+ * Local Error Hook
+ * Shared hook for managing local error state in form components
+ */
+
+import { useState, useCallback, type Dispatch, type SetStateAction } from "react";
+
+export interface UseLocalErrorResult {
+  localError: string | null;
+  setLocalError: Dispatch<SetStateAction<string | null>>;
+  clearLocalError: () => void;
+}
+
+/**
+ * Hook to manage local error state
+ * Provides consistent error state management across form hooks
+ *
+ * @returns Local error state and handlers
+ *
+ * @example
+ * ```typescript
+ * const { localError, setLocalError, clearLocalError } = useLocalError();
+ *
+ * // Set error
+ * setLocalError("Invalid email");
+ *
+ * // Clear error
+ * clearLocalError();
+ * ```
+ */
+export function useLocalError(): UseLocalErrorResult {
+  const [localError, setLocalError] = useState<string | null>(null);
+
+  const clearLocalError = useCallback(() => {
+    setLocalError(null);
+  }, []);
+
+  return {
+    localError,
+    setLocalError,
+    clearLocalError,
+  };
+}

package/src/presentation/hooks/useLoginForm.ts

@@ -1,9 +1,11 @@
 import { useState, useCallback } from "react";
 import { useAuth } from "./useAuth";
-import { getAuthErrorLocalizationKey, resolveErrorMessage } from "../utils/getAuthErrorMessage";
 import { validateLoginForm } from "../utils/form/formValidation.util";
 import { alertService } from "@umituz/react-native-design-system";
 import { useFormFields } from "../utils/form/useFormField.hook";
+import { sanitizeEmail } from "../../infrastructure/utils/validation/sanitization";
+import { useAuthErrorHandler } from "./useAuthErrorHandler";
+import { useLocalError } from "./useLocalError";
 
 export interface LoginFormTranslations {
   successTitle: string;
@@ -32,14 +34,11 @@ export interface UseLoginFormResult {
 export function useLoginForm(config?: UseLoginFormConfig): UseLoginFormResult {
   const { signIn, loading, error, continueAnonymously } = useAuth();
   const translations = config?.translations;
+  const { handleAuthError, getErrorMessage } = useAuthErrorHandler({ translations: translations?.errors });
+  const { localError, setLocalError, clearLocalError } = useLocalError();
 
   const [emailError, setEmailError] = useState<string | null>(null);
   const [passwordError, setPasswordError] = useState<string | null>(null);
-  const [localError, setLocalError] = useState<string | null>(null);
-
-  const clearLocalError = useCallback(() => {
-    setLocalError(null);
-  }, []);
 
   const clearFieldErrorsState = useCallback(() => {
     setEmailError(null);
@@ -53,10 +52,6 @@ export function useLoginForm(config?: UseLoginFormConfig): UseLoginFormResult {
     { clearLocalError }
   );
 
-  const getErrorMessage = useCallback((key: string) => {
-    return resolveErrorMessage(key, translations?.errors);
-  }, [translations]);
-
   const clearErrors = useCallback(() => {
     clearFieldErrorsState();
   }, [clearFieldErrorsState]);
@@ -81,7 +76,7 @@ export function useLoginForm(config?: UseLoginFormConfig): UseLoginFormResult {
     clearErrors();
 
     const validation = validateLoginForm(
-      { email: fields.email.trim(), password: fields.password },
+      { email: sanitizeEmail(fields.email), password: fields.password },
       getErrorMessage
     );
 
@@ -94,7 +89,7 @@ export function useLoginForm(config?: UseLoginFormConfig): UseLoginFormResult {
     }
 
     try {
-      await signIn(fields.email.trim(), fields.password);
+      await signIn(sanitizeEmail(fields.email), fields.password);
 
       if (translations) {
         alertService.success(
@@ -103,10 +98,9 @@ export function useLoginForm(config?: UseLoginFormConfig): UseLoginFormResult {
         );
       }
     } catch (err: unknown) {
-      const localizationKey = getAuthErrorLocalizationKey(err);
-      setLocalError(getErrorMessage(localizationKey));
+      setLocalError(handleAuthError(err));
     }
-  }, [fields, signIn, translations, getErrorMessage, clearErrors]);
+  }, [fields, signIn, translations, handleAuthError, getErrorMessage, clearErrors]);
 
   const handleContinueAnonymously = useCallback(async () => {
     try {

package/src/presentation/hooks/useRegisterForm.ts

@@ -6,31 +6,29 @@
 import { useState, useCallback } from "react";
 import { DEFAULT_PASSWORD_CONFIG } from "../../domain/value-objects/AuthConfig";
 import { useAuth } from "./useAuth";
-import { resolveErrorMessage } from "../utils/getAuthErrorMessage";
 import { useFormFields } from "../utils/form/useFormField.hook";
 import { usePasswordValidation } from "../utils/form/usePasswordValidation.hook";
 import { useRegisterFormHandlers } from "./registerForm/registerFormHandlers";
 import { useRegisterFormSubmit } from "./registerForm/registerFormSubmit";
+import { useAuthErrorHandler } from "./useAuthErrorHandler";
+import { useLocalError } from "./useLocalError";
 import type {
   FieldErrors,
   UseRegisterFormConfig,
   UseRegisterFormResult,
 } from "./registerForm/useRegisterForm.types";
 
-// Re-export types for backward compatibility
-export type { FieldErrors, RegisterFormTranslations, UseRegisterFormConfig, UseRegisterFormResult } from "./registerForm/useRegisterForm.types";
+// Export types for public API
+export type { UseRegisterFormConfig, UseRegisterFormResult } from "./registerForm/useRegisterForm.types";
 
 export function useRegisterForm(config?: UseRegisterFormConfig): UseRegisterFormResult {
   const { signUp, loading, error } = useAuth();
   const translations = config?.translations;
+  const { handleAuthError, getErrorMessage } = useAuthErrorHandler({ translations: translations?.errors });
+  const { localError, setLocalError, clearLocalError } = useLocalError();
 
-  const [localError, setLocalError] = useState<string | null>(null);
   const [fieldErrors, setFieldErrors] = useState<FieldErrors>({});
 
-  const clearLocalError = useCallback(() => {
-    setLocalError(null);
-  }, []);
-
   const clearFormErrors = useCallback(() => {
     setLocalError(null);
     setFieldErrors({});
@@ -47,13 +45,6 @@ export function useRegisterForm(config?: UseRegisterFormConfig): UseRegisterForm
     { clearLocalError }
   );
 
-  const getErrorMessage = useCallback(
-    (key: string) => {
-      return resolveErrorMessage(key, translations?.errors);
-    },
-    [translations]
-  );
-
   const { passwordRequirements, passwordsMatch } = usePasswordValidation(
     fields.password,
     fields.confirmPassword,
@@ -69,6 +60,7 @@ export function useRegisterForm(config?: UseRegisterFormConfig): UseRegisterForm
     setLocalError,
     clearFormErrors,
     getErrorMessage,
+    handleAuthError,
     translations
   );
 

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

@@ -1,6 +1,6 @@
 /**
  * Form Validation - Main Export
- * Re-exports all form validation utilities
+ * Exports all form validation utilities
  */
 
 // Types

package/src/presentation/utils/form/usePasswordValidation.hook.ts

@@ -9,7 +9,7 @@ import {
   validatePasswordConfirmation,
   type PasswordRequirements,
   type ValidationResult,
-} from "../../../infrastructure/utils/AuthValidation";
+} from "../../../application/services/ValidationService";
 import type { PasswordConfig } from "../../../domain/value-objects/AuthConfig";
 
 export interface UsePasswordValidationResult {

package/src/presentation/utils/form/validation/formValidation.types.ts

@@ -3,15 +3,11 @@
  * Type definitions for form validation
  */
 
-export interface FormValidationError {
-  field: string;
-  message: string;
-}
-
-export interface FormValidationResult {
-  isValid: boolean;
-  errors: FormValidationError[];
-}
+// Export shared validation types
+export type {
+  FormValidationError,
+  FormValidationResult,
+} from "../../../../infrastructure/utils/validation/types";
 
 export interface LoginFormValues {
   email: string;

package/src/presentation/utils/form/validation/formValidators.ts

@@ -8,7 +8,7 @@ import {
   validatePasswordForLogin,
   validatePasswordForRegister,
   validatePasswordConfirmation,
-} from "../../../../infrastructure/utils/AuthValidation";
+} from "../../../../application/services/ValidationService";
 import type { PasswordConfig } from "../../../../domain/value-objects/AuthConfig";
 import type {
   FormValidationResult,
@@ -17,6 +17,7 @@ import type {
   ProfileFormValues,
   FormValidationError,
 } from "./formValidation.types";
+import { sanitizeEmail, sanitizeName } from "../../../../infrastructure/utils/validation/sanitization";
 
 export function validateLoginForm(
   values: LoginFormValues,
@@ -24,7 +25,7 @@ export function validateLoginForm(
 ): FormValidationResult {
   const errors: FormValidationError[] = [];
 
-  const emailResult = validateEmail(values.email.trim());
+  const emailResult = validateEmail(sanitizeEmail(values.email));
   if (!emailResult.isValid && emailResult.error) {
     errors.push({ field: "email", message: getErrorMessage(emailResult.error) });
   }
@@ -44,7 +45,7 @@ export function validateRegisterForm(
 ): FormValidationResult {
   const errors: FormValidationError[] = [];
 
-  const emailResult = validateEmail(values.email.trim());
+  const emailResult = validateEmail(sanitizeEmail(values.email));
   if (!emailResult.isValid && emailResult.error) {
     errors.push({ field: "email", message: getErrorMessage(emailResult.error) });
   }
@@ -68,7 +69,7 @@ export function validateProfileForm(
 ): FormValidationResult {
   const errors: FormValidationError[] = [];
 
-  if (!values.displayName || !values.displayName.trim()) {
+  if (!values.displayName || !sanitizeName(values.displayName)) {
     errors.push({
       field: "displayName",
       message: getErrorMessage("auth.validation.displayNameRequired"),
@@ -76,7 +77,7 @@ export function validateProfileForm(
   }
 
   if (values.email) {
-    const emailResult = validateEmail(values.email.trim());
+    const emailResult = validateEmail(sanitizeEmail(values.email));
     if (!emailResult.isValid && emailResult.error) {
       errors.push({ field: "email", message: getErrorMessage(emailResult.error) });
     }