@umituz/react-native-auth 3.6.86 → 3.6.88

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-auth",
-  "version": "3.6.86",
+  "version": "3.6.88",
   "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/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/services/UserDocument.types.ts

@@ -0,0 +1,60 @@
+/**
+ * User Document Types and Configuration
+ */
+
+/**
+ * Minimal user interface for document creation
+ * Compatible with both Firebase User and AuthUser
+ */
+export interface UserDocumentUser {
+  uid: string;
+  displayName?: string | null;
+  email?: string | null;
+  photoURL?: string | null;
+  isAnonymous?: boolean;
+}
+
+/**
+ * Configuration for user document service
+ */
+export interface UserDocumentConfig {
+  /** Firestore collection name (default: "users") */
+  collectionName?: string;
+  /** Additional fields to store with user document */
+  extraFields?: Record<string, unknown>;
+  /** Callback to collect device/app info */
+  collectExtras?: () => Promise<UserDocumentExtras>;
+}
+
+/**
+ * User document extras from device/app
+ */
+export interface UserDocumentExtras {
+  [key: string]: string | number | boolean | null | undefined;
+  deviceId?: string;
+  persistentDeviceId?: string;
+  nativeDeviceId?: string;
+  platform?: string;
+  deviceModel?: string;
+  deviceBrand?: string;
+  deviceName?: string;
+  deviceType?: number | string;
+  deviceYearClass?: number | string;
+  isDevice?: boolean;
+  osName?: string;
+  osVersion?: string;
+  osBuildId?: string;
+  totalMemory?: number | string;
+  appVersion?: string;
+  buildNumber?: string;
+  locale?: string;
+  region?: string;
+  timezone?: string;
+  screenWidth?: number;
+  screenHeight?: number;
+  screenScale?: number;
+  fontScale?: number;
+  isLandscape?: boolean;
+  previousAnonymousUserId?: string;
+  signUpMethod?: string;
+}

package/src/infrastructure/services/UserDocumentService.ts

@@ -0,0 +1,85 @@
+/**
+ * User Document Service
+ * Generic service for creating/updating user documents in Firestore
+ */
+
+import { doc, getDoc, setDoc, serverTimestamp } from "firebase/firestore";
+import type { User } from "firebase/auth";
+import { getFirestore } from "@umituz/react-native-firebase";
+import type {
+  UserDocumentUser,
+  UserDocumentConfig,
+  UserDocumentExtras,
+} from "./UserDocument.types";
+import {
+  getSignUpMethod,
+  buildBaseData,
+  buildCreateData,
+  buildUpdateData,
+} from "../utils/userDocumentBuilder.util";
+
+export type {
+  UserDocumentUser,
+  UserDocumentConfig,
+  UserDocumentExtras,
+} from "./UserDocument.types";
+
+declare const __DEV__: boolean;
+
+let userDocumentConfig: UserDocumentConfig = {};
+
+export function configureUserDocumentService(config: UserDocumentConfig): void {
+  userDocumentConfig = { ...config };
+}
+
+export async function ensureUserDocument(
+  user: UserDocumentUser | User,
+  extras?: UserDocumentExtras,
+): Promise<boolean> {
+  const db = getFirestore();
+  if (!db || !user.uid) return false;
+
+  try {
+    let allExtras = extras || {};
+    if (userDocumentConfig.collectExtras) {
+      const collectedExtras = await userDocumentConfig.collectExtras();
+      allExtras = { ...collectedExtras, ...allExtras };
+    }
+
+    if (!allExtras.signUpMethod) allExtras.signUpMethod = getSignUpMethod(user);
+
+    const collectionName = userDocumentConfig.collectionName || "users";
+    const userRef = doc(db, collectionName, user.uid);
+    const userDoc = await getDoc(userRef);
+    const baseData = buildBaseData(user, allExtras);
+
+    const docData = !userDoc.exists()
+      ? buildCreateData(baseData, userDocumentConfig.extraFields, allExtras)
+      : buildUpdateData(baseData, allExtras);
+
+    await setDoc(userRef, docData, { merge: true });
+    return true;
+  } catch (error) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[UserDocumentService] Failed:", error);
+    }
+    return false;
+  }
+}
+
+export async function markUserDeleted(userId: string): Promise<boolean> {
+  const db = getFirestore();
+  if (!db || !userId) return false;
+
+  try {
+    const userRef = doc(db, userDocumentConfig.collectionName || "users", userId);
+    await setDoc(userRef, {
+      isDeleted: true,
+      deletedAt: serverTimestamp(),
+      updatedAt: serverTimestamp(),
+    }, { merge: true });
+    return true;
+  } catch {
+    return false;
+  }
+}

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/authStateHandler.ts

@@ -4,6 +4,7 @@
  */
 
 import type { User } from "firebase/auth";
+import { ensureUserDocument } from "../services/UserDocumentService";
 import { detectConversion, type ConversionState } from "./authConversionDetector";
 
 export interface AuthStateHandlerOptions {
@@ -40,6 +41,12 @@ export function createAuthStateHandler(
       }
     }
 
+    const extras = conversion.isConversion && state.current.previousUserId
+      ? { previousAnonymousUserId: state.current.previousUserId }
+      : undefined;
+
+    await ensureUserDocument(user, extras);
+
     state.current = {
       previousUserId: currentUserId,
       wasAnonymous: isCurrentlyAnonymous,

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);
+  }
+}