@umituz/react-native-auth 3.6.85 → 3.6.87

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-auth",
-  "version": "3.6.85",
+  "version": "3.6.87",
   "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/infrastructure/repositories/UserDocumentRepository.ts

@@ -0,0 +1,85 @@
+/**
+ * User Document Repository
+ * Manages Firestore user documents using Firebase Auth UID
+ */
+
+import { doc, setDoc, getDoc, serverTimestamp, getFirestore } from "firebase/firestore";
+import type { Firestore } from "firebase/firestore";
+import type { User } from "firebase/auth";
+import type { UserProfile } from "../../domain/entities/UserProfile";
+
+const USERS_COLLECTION = "users";
+
+/**
+ * Create or update user document in Firestore
+ * Uses Firebase Auth UID as document ID (best practice)
+ */
+export async function createOrUpdateUserDocument(
+  firestore: Firestore,
+  user: User
+): Promise<void> {
+  try {
+    const userRef = doc(firestore, USERS_COLLECTION, user.uid);
+    const userDoc = await getDoc(userRef);
+
+    const userData: Partial<UserProfile> = {
+      uid: user.uid,
+      email: user.email,
+      displayName: user.displayName,
+      photoURL: user.photoURL,
+      isAnonymous: user.isAnonymous,
+      lastLoginAt: new Date(),
+    };
+
+    if (!userDoc.exists()) {
+      // New user - create document with createdAt
+      await setDoc(userRef, {
+        ...userData,
+        createdAt: serverTimestamp(),
+        lastLoginAt: serverTimestamp(),
+      });
+    } else {
+      // Existing user - update lastLoginAt only
+      await setDoc(
+        userRef,
+        {
+          lastLoginAt: serverTimestamp(),
+          // Update these in case they changed (e.g., anonymous → registered)
+          email: userData.email,
+          displayName: userData.displayName,
+          photoURL: userData.photoURL,
+          isAnonymous: userData.isAnonymous,
+        },
+        { merge: true }
+      );
+    }
+  } catch (error) {
+    console.error("[UserDocumentRepository] Failed to create/update user document:", error);
+    // Don't throw - allow auth to continue even if Firestore fails
+  }
+}
+
+/**
+ * Check if user document exists
+ */
+export async function userDocumentExists(
+  firestore: Firestore,
+  uid: string
+): Promise<boolean> {
+  try {
+    const userRef = doc(firestore, USERS_COLLECTION, uid);
+    const userDoc = await getDoc(userRef);
+    return userDoc.exists();
+  } catch (error) {
+    console.error("[UserDocumentRepository] Failed to check user document:", error);
+    return false;
+  }
+}
+
+/**
+ * Get Firestore instance
+ * Exported for testing and external use
+ */
+export function getFirestoreInstance(): Firestore {
+  return getFirestore();
+}

package/src/infrastructure/services/AnonymousModeService.ts

@@ -51,8 +51,11 @@ export class AnonymousModeService {
     if (provider?.getCurrentUser()) {
       try {
         await provider.signOut();
-      } catch {
-        // Silently fail - sign out errors are handled elsewhere
+      } catch (error) {
+        // Log error but don't throw - allow anonymous mode to be enabled
+        // even if sign-out fails (user might be in inconsistent state but
+        // subsequent auth operations will resolve it)
+        console.warn("[AnonymousModeService] Sign-out failed during anonymous mode enable:", error);
       }
     }
 

package/src/infrastructure/services/AuthService.ts

@@ -33,12 +33,24 @@ export class AuthService {
     return this.repository;
   }
 
+  private isFirebaseAuth(obj: IAuthProvider | Auth): obj is Auth {
+    return (
+      typeof obj === "object" &&
+      obj !== null &&
+      "currentUser" in obj &&
+      "onAuthStateChanged" in obj &&
+      "signInWithEmailAndPassword" in obj &&
+      "createUserWithEmailAndPassword" in obj &&
+      typeof obj.onAuthStateChanged === "function"
+    );
+  }
+
   async initialize(providerOrAuth: IAuthProvider | Auth): Promise<void> {
     if (this.initialized) return;
 
     let provider: IAuthProvider;
 
-    if ("currentUser" in providerOrAuth) {
+    if (this.isFirebaseAuth(providerOrAuth)) {
       const firebaseProvider = new FirebaseAuthProvider(providerOrAuth);
       await firebaseProvider.initialize();
       provider = firebaseProvider;

package/src/infrastructure/utils/AuthValidation.ts

@@ -16,7 +16,11 @@ export interface ValidationConfig {
 }
 
 export const DEFAULT_VAL_CONFIG: ValidationConfig = {
-  emailRegex: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+  // More robust email validation:
+  // - Local part: alphanumeric, dots (not consecutive), hyphens, underscores, plus
+  // - Domain: alphanumeric and hyphens
+  // - TLD: at least 2 characters
+  emailRegex: /^[a-zA-Z0-9]([a-zA-Z0-9._+-]*[a-zA-Z0-9])?@[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?)*\.[a-zA-Z]{2,}$/,
   displayNameMinLength: 2,
 };
 
@@ -30,7 +34,7 @@ export function validateEmail(
 }
 
 export function validatePasswordForLogin(password: string): ValidationResult {
-  if (!password || password.length === 0) return { isValid: false, error: "auth.validation.passwordRequired" };
+  if (!password || password.trim().length === 0) return { isValid: false, error: "auth.validation.passwordRequired" };
   return { isValid: true };
 }
 
@@ -38,7 +42,7 @@ export function validatePasswordForRegister(
   password: string,
   config: PasswordConfig,
 ): PasswordStrengthResult {
-  if (!password) {
+  if (!password || password.trim().length === 0) {
     return { isValid: false, error: "auth.validation.passwordRequired", requirements: { hasMinLength: false } };
   }
 
@@ -52,7 +56,7 @@ export function validatePasswordForRegister(
 }
 
 export function validatePasswordConfirmation(password: string, confirm: string): ValidationResult {
-  if (!confirm) return { isValid: false, error: "auth.validation.confirmPasswordRequired" };
+  if (!confirm || confirm.trim().length === 0) return { isValid: false, error: "auth.validation.confirmPasswordRequired" };
   if (password !== confirm) return { isValid: false, error: "auth.validation.passwordsDoNotMatch" };
   return { isValid: true };
 }

package/src/infrastructure/utils/UserMapper.ts

@@ -35,14 +35,18 @@ export function extractProvider(user: FirebaseUserLike): AuthProviderType {
   // Filter out null providers and find the first valid one
   const validProviders = providerData.filter((p): p is ProviderData => p != null);
 
+  if (validProviders.length === 0) {
+    return "unknown";
+  }
+
   const googleProvider = validProviders.find((p) => p.providerId === "google.com");
-  if (googleProvider && googleProvider.providerId) return "google.com";
+  if (googleProvider) return "google.com";
 
   const appleProvider = validProviders.find((p) => p.providerId === "apple.com");
-  if (appleProvider && appleProvider.providerId) return "apple.com";
+  if (appleProvider) return "apple.com";
 
   const passwordProvider = validProviders.find((p) => p.providerId === "password");
-  if (passwordProvider && passwordProvider.providerId) return "password";
+  if (passwordProvider) return "password";
 
   return "unknown";
 }

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

@@ -3,118 +3,21 @@
  * Centralized configuration for mapping Firebase error codes to domain errors
  */
 
-import {
-  AuthError,
-  AuthConfigurationError,
-  AuthEmailAlreadyInUseError,
-  AuthInvalidEmailError,
-  AuthWeakPasswordError,
-  AuthUserNotFoundError,
-  AuthWrongPasswordError,
-  AuthNetworkError,
-} from "../../../domain/errors/AuthError";
+import type { ErrorMapping } from "./mappings/errorMapping.types";
+import { AUTH_ERROR_MAPPINGS } from "./mappings/authErrorMappings";
+import { CONFIG_ERROR_MAPPINGS } from "./mappings/configErrorMappings";
+import { NETWORK_ERROR_MAPPINGS } from "./mappings/networkErrorMappings";
+import { ACTION_CODE_ERROR_MAPPINGS } from "./mappings/actionCodeErrorMappings";
 
-export type ErrorConstructor = new (message?: string) => Error;
-export type ErrorFactory = () => Error;
-
-export interface ErrorMapping {
-  type: "class" | "factory";
-  create: ErrorConstructor | ErrorFactory;
-}
+// Re-export types for backward compatibility
+export type { ErrorConstructor, ErrorFactory, ErrorMapping } from "./mappings/errorMapping.types";
 
 /**
- * Firebase error code to domain error mapping
+ * Combined Firebase error code to domain error mapping
  */
 export const ERROR_CODE_MAP: Record<string, ErrorMapping> = {
-  "auth/email-already-in-use": {
-    type: "class",
-    create: AuthEmailAlreadyInUseError,
-  },
-  "auth/invalid-email": {
-    type: "class",
-    create: AuthInvalidEmailError,
-  },
-  "auth/weak-password": {
-    type: "class",
-    create: AuthWeakPasswordError,
-  },
-  "auth/user-disabled": {
-    type: "factory",
-    create: () => new AuthError(
-      "Your account has been disabled. Please contact support.",
-      "AUTH_USER_DISABLED"
-    ),
-  },
-  "auth/user-not-found": {
-    type: "class",
-    create: AuthUserNotFoundError,
-  },
-  "auth/wrong-password": {
-    type: "class",
-    create: AuthWrongPasswordError,
-  },
-  "auth/invalid-credential": {
-    type: "factory",
-    create: () => new AuthError(
-      "Invalid email or password. Please check your credentials.",
-      "AUTH_INVALID_CREDENTIAL"
-    ),
-  },
-  "auth/invalid-login-credentials": {
-    type: "factory",
-    create: () => new AuthError(
-      "Invalid email or password. Please check your credentials.",
-      "AUTH_INVALID_CREDENTIAL"
-    ),
-  },
-  "auth/network-request-failed": {
-    type: "class",
-    create: AuthNetworkError,
-  },
-  "auth/too-many-requests": {
-    type: "factory",
-    create: () => new AuthError(
-      "Too many failed attempts. Please wait a few minutes and try again.",
-      "AUTH_TOO_MANY_REQUESTS"
-    ),
-  },
-  "auth/configuration-not-found": {
-    type: "factory",
-    create: () => new AuthConfigurationError(
-      "Authentication is not properly configured. Please contact support."
-    ),
-  },
-  "auth/app-not-authorized": {
-    type: "factory",
-    create: () => new AuthConfigurationError(
-      "Authentication is not properly configured. Please contact support."
-    ),
-  },
-  "auth/operation-not-allowed": {
-    type: "factory",
-    create: () => new AuthConfigurationError(
-      "Email/password authentication is not enabled. Please contact support."
-    ),
-  },
-  "auth/requires-recent-login": {
-    type: "factory",
-    create: () => new AuthError(
-      "Please sign in again to complete this action.",
-      "AUTH_REQUIRES_RECENT_LOGIN"
-    ),
-  },
-  "auth/expired-action-code": {
-    type: "factory",
-    create: () => new AuthError(
-      "This link has expired. Please request a new one.",
-      "AUTH_EXPIRED_ACTION_CODE"
-    ),
-  },
-  "auth/invalid-action-code": {
-    type: "factory",
-    create: () => new AuthError(
-      "This link is invalid. Please request a new one.",
-      "AUTH_INVALID_ACTION_CODE"
-    ),
-  },
+  ...AUTH_ERROR_MAPPINGS,
+  ...CONFIG_ERROR_MAPPINGS,
+  ...NETWORK_ERROR_MAPPINGS,
+  ...ACTION_CODE_ERROR_MAPPINGS,
 };

package/src/infrastructure/utils/error/mappings/actionCodeErrorMappings.ts

@@ -0,0 +1,26 @@
+/**
+ * Action Code Error Mappings
+ * Email verification, password reset link errors
+ */
+
+import { AuthError } from "../../../../domain/errors/AuthError";
+import type { ErrorMapping } from "./errorMapping.types";
+
+export const ACTION_CODE_ERROR_MAPPINGS: Record<string, ErrorMapping> = {
+  "auth/expired-action-code": {
+    type: "factory",
+    create: () =>
+      new AuthError(
+        "This link has expired. Please request a new one.",
+        "AUTH_EXPIRED_ACTION_CODE"
+      ),
+  },
+  "auth/invalid-action-code": {
+    type: "factory",
+    create: () =>
+      new AuthError(
+        "This link is invalid. Please request a new one.",
+        "AUTH_INVALID_ACTION_CODE"
+      ),
+  },
+};

package/src/infrastructure/utils/error/mappings/authErrorMappings.ts

@@ -0,0 +1,69 @@
+/**
+ * Authentication Error Mappings
+ * Email, password, and credential related errors
+ */
+
+import {
+  AuthError,
+  AuthEmailAlreadyInUseError,
+  AuthInvalidEmailError,
+  AuthWeakPasswordError,
+  AuthUserNotFoundError,
+  AuthWrongPasswordError,
+} from "../../../../domain/errors/AuthError";
+import type { ErrorMapping } from "./errorMapping.types";
+
+export const AUTH_ERROR_MAPPINGS: Record<string, ErrorMapping> = {
+  "auth/email-already-in-use": {
+    type: "class",
+    create: AuthEmailAlreadyInUseError,
+  },
+  "auth/invalid-email": {
+    type: "class",
+    create: AuthInvalidEmailError,
+  },
+  "auth/weak-password": {
+    type: "class",
+    create: AuthWeakPasswordError,
+  },
+  "auth/user-disabled": {
+    type: "factory",
+    create: () =>
+      new AuthError(
+        "Your account has been disabled. Please contact support.",
+        "AUTH_USER_DISABLED"
+      ),
+  },
+  "auth/user-not-found": {
+    type: "class",
+    create: AuthUserNotFoundError,
+  },
+  "auth/wrong-password": {
+    type: "class",
+    create: AuthWrongPasswordError,
+  },
+  "auth/invalid-credential": {
+    type: "factory",
+    create: () =>
+      new AuthError(
+        "Invalid email or password. Please check your credentials.",
+        "AUTH_INVALID_CREDENTIAL"
+      ),
+  },
+  "auth/invalid-login-credentials": {
+    type: "factory",
+    create: () =>
+      new AuthError(
+        "Invalid email or password. Please check your credentials.",
+        "AUTH_INVALID_CREDENTIAL"
+      ),
+  },
+  "auth/requires-recent-login": {
+    type: "factory",
+    create: () =>
+      new AuthError(
+        "Please sign in again to complete this action.",
+        "AUTH_REQUIRES_RECENT_LOGIN"
+      ),
+  },
+};

package/src/infrastructure/utils/error/mappings/configErrorMappings.ts

@@ -0,0 +1,31 @@
+/**
+ * Configuration Error Mappings
+ * Firebase configuration and setup errors
+ */
+
+import { AuthConfigurationError } from "../../../../domain/errors/AuthError";
+import type { ErrorMapping } from "./errorMapping.types";
+
+export const CONFIG_ERROR_MAPPINGS: Record<string, ErrorMapping> = {
+  "auth/configuration-not-found": {
+    type: "factory",
+    create: () =>
+      new AuthConfigurationError(
+        "Authentication is not properly configured. Please contact support."
+      ),
+  },
+  "auth/app-not-authorized": {
+    type: "factory",
+    create: () =>
+      new AuthConfigurationError(
+        "Authentication is not properly configured. Please contact support."
+      ),
+  },
+  "auth/operation-not-allowed": {
+    type: "factory",
+    create: () =>
+      new AuthConfigurationError(
+        "Email/password authentication is not enabled. Please contact support."
+      ),
+  },
+};

package/src/infrastructure/utils/error/mappings/errorMapping.types.ts

@@ -0,0 +1,12 @@
+/**
+ * Error Mapping Types
+ * Shared types for error code mappings
+ */
+
+export type ErrorConstructor = new (message?: string) => Error;
+export type ErrorFactory = () => Error;
+
+export interface ErrorMapping {
+  type: "class" | "factory";
+  create: ErrorConstructor | ErrorFactory;
+}

package/src/infrastructure/utils/error/mappings/networkErrorMappings.ts

@@ -0,0 +1,22 @@
+/**
+ * Network Error Mappings
+ * Network and rate limit errors
+ */
+
+import { AuthError, AuthNetworkError } from "../../../../domain/errors/AuthError";
+import type { ErrorMapping } from "./errorMapping.types";
+
+export const NETWORK_ERROR_MAPPINGS: Record<string, ErrorMapping> = {
+  "auth/network-request-failed": {
+    type: "class",
+    create: AuthNetworkError,
+  },
+  "auth/too-many-requests": {
+    type: "factory",
+    create: () =>
+      new AuthError(
+        "Too many failed attempts. Please wait a few minutes and try again.",
+        "AUTH_TOO_MANY_REQUESTS"
+      ),
+  },
+};

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

@@ -0,0 +1,31 @@
+/**
+ * Anonymous Mode Handler
+ * Handles anonymous sign-in flow
+ */
+
+import type { Auth } from "firebase/auth";
+import type { AuthActions } from "../../../types/auth-store.types";
+import { createAnonymousSignInHandler } from "./anonymousSignInHandler";
+import {
+  startAnonymousSignIn,
+  completeAnonymousSignIn,
+} from "./listenerState.util";
+
+type Store = AuthActions & { isAnonymous: boolean };
+
+/**
+ * Handle anonymous mode sign-in
+ */
+export async function handleAnonymousMode(store: Store, auth: Auth): Promise<void> {
+  if (!startAnonymousSignIn()) {
+    return; // Already signing in
+  }
+
+  const handleAnonymousSignIn = createAnonymousSignInHandler(auth, store);
+
+  try {
+    await handleAnonymousSignIn();
+  } finally {
+    completeAnonymousSignIn();
+  }
+}

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

@@ -0,0 +1,59 @@
+/**
+ * Auth State Change Handler
+ * Processes Firebase auth state changes and updates store
+ */
+
+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 {
+  createOrUpdateUserDocument,
+  getFirestoreInstance,
+} from "../../repositories/UserDocumentRepository";
+
+type Store = AuthActions & { isAnonymous: boolean };
+
+/**
+ * Handle auth state change from Firebase
+ */
+export function handleAuthStateChange(
+  user: User | null,
+  store: Store,
+  auth: Auth,
+  autoAnonymousSignIn: boolean,
+  onAuthStateChange?: (user: User | null) => void
+): void {
+  try {
+    if (!user && autoAnonymousSignIn) {
+      // Start anonymous sign-in without blocking
+      void handleAnonymousMode(store, auth);
+      store.setFirebaseUser(null);
+      completeInitialization();
+      return;
+    }
+
+    store.setFirebaseUser(user);
+    store.setInitialized(true);
+
+    // Create or update Firestore user document (best practice)
+    if (user) {
+      createOrUpdateUserDocument(getFirestoreInstance(), user).catch((error) => {
+        console.error("[AuthListener] Failed to create/update user document:", error);
+        // Don't throw - Firestore failures shouldn't block auth state updates
+      });
+    }
+
+    // Handle conversion from anonymous
+    if (user && !user.isAnonymous && store.isAnonymous) {
+      store.setIsAnonymous(false);
+    }
+
+    onAuthStateChange?.(user);
+  } catch (error) {
+    console.error("[AuthListener] Error handling auth state change:", error);
+    // Ensure we don't leave the app in a bad state
+    store.setInitialized(true);
+    store.setLoading(false);
+  }
+}

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

@@ -0,0 +1,46 @@
+/**
+ * Cleanup Handlers
+ * Manages unsubscribe and cleanup logic for auth listener
+ */
+
+import {
+  isListenerInitialized,
+  incrementRefCount,
+  decrementRefCount,
+  resetListenerState,
+} from "./listenerState.util";
+
+/**
+ * Create unsubscribe function that decrements ref count
+ */
+export function createUnsubscribeHandler(): () => void {
+  return () => {
+    const { shouldCleanup } = decrementRefCount();
+
+    if (shouldCleanup) {
+      resetListenerState();
+    }
+  };
+}
+
+/**
+ * Return existing unsubscribe if already initialized
+ * Returns null if initialization is in progress
+ */
+export function handleExistingInitialization(): (() => void) | null {
+  if (!isListenerInitialized()) {
+    return null;
+  }
+
+  incrementRefCount();
+  return createUnsubscribeHandler();
+}
+
+/**
+ * Return no-op if initialization is in progress
+ */
+export function handleInitializationInProgress(): () => void {
+  return () => {
+    // No-op - handled by initial initialization
+  };
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Initialization Handlers
+ * Helper functions for listener initialization
+ */
+
+import type { AuthActions } from "../../../types/auth-store.types";
+import { completeInitialization } from "./listenerState.util";
+
+type Store = AuthActions & { isAnonymous: boolean };
+
+/**
+ * Handle case where Firebase auth is not available
+ */
+export function handleNoFirebaseAuth(store: Store): () => void {
+  completeInitialization();
+  store.setLoading(false);
+  store.setInitialized(true);
+  return () => {};
+}
+
+/**
+ * Complete listener setup and mark as initialized
+ */
+export function completeListenerSetup(): void {
+  completeInitialization();
+}