@umituz/react-native-firebase 2.4.4 → 2.4.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "2.4.4",
+  "version": "2.4.6",
   "description": "Unified Firebase package for React Native apps - Auth and Firestore services using Firebase JS SDK (no native modules).",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/domains/account-deletion/infrastructure/services/account-deletion.service.ts

@@ -13,7 +13,7 @@ import {
   reauthenticateWithPassword,
   reauthenticateWithGoogle,
 } from "./reauthentication.service";
-import { successResult, type Result } from "../../../../shared/domain/utils";
+import { successResult, type Result, toAuthErrorInfo } from "../../../../shared/domain/utils";
 import type { AccountDeletionOptions } from "../../application/ports/reauthentication.types";
 
 export interface AccountDeletionResult extends Result<void> {
@@ -67,16 +67,33 @@ export async function deleteCurrentUser(
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       console.log("[deleteCurrentUser] attemptReauth result:", reauth);
     }
-    if (reauth) return reauth;
+    if (reauth) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[deleteCurrentUser] Reauth returned result, returning:", reauth);
+      }
+      return reauth;
+    }
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[deleteCurrentUser] Reauth returned null, continuing to deleteUser");
+    }
   }
 
   try {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[deleteCurrentUser] Calling deleteUser");
+    }
     await deleteUser(user);
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[deleteCurrentUser] deleteUser successful");
+    }
     return successResult();
   } catch (error: unknown) {
-    const authErr = error instanceof Error ? (error as { code?: string; message?: string }) : null;
-    const code = authErr?.code ?? "auth/failed";
-    const message = authErr?.message ?? "Account deletion failed";
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[deleteCurrentUser] deleteUser failed:", error);
+    }
+    const errorInfo = toAuthErrorInfo(error);
+    const code = errorInfo.code;
+    const message = errorInfo.message;
 
     const hasCredentials = !!(options.password || options.googleIdToken);
     const shouldReauth = options.autoReauthenticate === true || hasCredentials;
@@ -149,43 +166,69 @@ async function attemptReauth(user: User, options: AccountDeletionOptions): Promi
         console.log("[attemptReauth] onPasswordRequired returned:", pwd ? "password received" : "null/cancelled");
       }
       if (!pwd) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[attemptReauth] Password was null/cancelled, returning error");
+        }
         return {
           success: false,
           error: { code: "auth/password-reauth-cancelled", message: "Password reauth cancelled" },
           requiresReauth: true
         };
       }
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[attemptReauth] Password received, setting password variable");
+      }
       password = pwd;
     }
     if (!password) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[attemptReauth] No password available after callback, returning error");
+      }
       return {
         success: false,
         error: { code: "auth/password-reauth", message: "Password required" },
         requiresReauth: true
       };
     }
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[attemptReauth] Calling reauthenticateWithPassword");
+    }
     res = await reauthenticateWithPassword(user, password);
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[attemptReauth] reauthenticateWithPassword result:", res);
+    }
   } else {
     return null;
   }
 
   if (res.success) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[attemptReauth] Reauthentication successful, calling deleteUser");
+    }
     try {
-      // After reauthentication, get fresh user reference from auth
       const auth = getFirebaseAuth();
       const currentUser = auth?.currentUser || user;
       await deleteUser(currentUser);
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[attemptReauth] deleteUser successful after reauth");
+      }
       return successResult();
     } catch (err: unknown) {
-      const authErr = err instanceof Error ? (err as { code?: string; message?: string }) : null;
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[attemptReauth] deleteUser failed after reauth:", err);
+      }
+      const errorInfo = toAuthErrorInfo(err);
       return {
         success: false,
-        error: { code: authErr?.code ?? "auth/failed", message: authErr?.message ?? "Deletion failed" },
+        error: { code: errorInfo.code, message: errorInfo.message },
         requiresReauth: false
       };
     }
   }
 
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[attemptReauth] Reauthentication failed, returning error");
+  }
   return {
     success: false,
     error: {
@@ -209,12 +252,11 @@ export async function deleteUserAccount(user: User | null): Promise<AccountDelet
     await deleteUser(user);
     return successResult();
   } catch (error: unknown) {
-    const authErr = error instanceof Error ? (error as { code?: string; message?: string }) : null;
-    const code = authErr?.code ?? "auth/failed";
+    const errorInfo = toAuthErrorInfo(error);
     return {
       success: false,
-      error: { code, message: authErr?.message ?? "Deletion failed" },
-      requiresReauth: code === "auth/requires-recent-login"
+      error: { code: errorInfo.code, message: errorInfo.message },
+      requiresReauth: errorInfo.code === "auth/requires-recent-login"
     };
   }
 }

package/src/domains/account-deletion/infrastructure/services/reauthentication.service.ts

@@ -13,7 +13,7 @@ import {
 import * as AppleAuthentication from "expo-apple-authentication";
 import { Platform } from "react-native";
 import { generateNonce, hashNonce } from "../../../auth/infrastructure/services/crypto.util";
-import { executeOperation, failureResultFrom } from "../../../../shared/domain/utils";
+import { executeOperation, failureResultFrom, toAuthErrorInfo } from "../../../../shared/domain/utils";
 import { isCancelledError } from "../../../../shared/domain/utils/error-handler.util";
 import type {
   ReauthenticationResult,
@@ -98,15 +98,11 @@ export async function getAppleReauthCredential(): Promise<ReauthCredentialResult
       credential
     };
   } catch (error: unknown) {
-    const err = error instanceof Error ? error : new Error(String(error));
-    const errorInfo = {
-      code: (err as { code?: string }).code ?? '',
-      message: err.message
-    };
-    const code = isCancelledError(errorInfo) ? "auth/cancelled" : "auth/failed";
+    const errorInfo = toAuthErrorInfo(error);
+    const code = isCancelledError(errorInfo) ? "auth/cancelled" : errorInfo.code;
     return {
       success: false,
-      error: { code, message: err.message }
+      error: { code, message: errorInfo.message }
     };
   }
 }

package/src/domains/auth/infrastructure/config/FirebaseAuthClient.ts

@@ -64,7 +64,8 @@ class FirebaseAuthClientSingleton extends ServiceClientSingleton<Auth, FirebaseA
         this.setError(errorMessage);
       }
     }
-    return this.getInstance();
+    // Enable auto-initialization flag when getting instance
+    return this.getInstance(true);
   }
 }
 

package/src/domains/auth/infrastructure/services/anonymous-auth.service.ts

@@ -5,6 +5,7 @@
 
 import { signInAnonymously, type Auth, type User } from "firebase/auth";
 import { toAnonymousUser, type AnonymousUser } from "../../domain/entities/AnonymousUser";
+import { ERROR_MESSAGES } from "../../../../shared/domain/utils/error-handlers/error-messages";
 
 export interface AnonymousAuthResult {
   readonly user: User;
@@ -18,7 +19,7 @@ export interface AnonymousAuthServiceInterface {
 
 export class AnonymousAuthService implements AnonymousAuthServiceInterface {
   async signInAnonymously(auth: Auth): Promise<AnonymousAuthResult> {
-    if (!auth) throw new Error("Firebase Auth instance is required");
+    if (!auth) throw new Error(ERROR_MESSAGES.AUTH.NOT_INITIALIZED);
 
     const currentUser = auth.currentUser;
 
@@ -31,10 +32,15 @@ export class AnonymousAuthService implements AnonymousAuthServiceInterface {
     }
 
     if (currentUser && !currentUser.isAnonymous) {
-      throw new Error("A non-anonymous user is already signed in. Sign out first before creating an anonymous session.");
+      throw new Error(ERROR_MESSAGES.AUTH.SIGN_OUT_REQUIRED);
     }
 
     const userCredential = await signInAnonymously(auth);
+
+    if (!userCredential.user.isAnonymous) {
+      throw new Error(ERROR_MESSAGES.AUTH.INVALID_USER);
+    }
+
     const anonymousUser = toAnonymousUser(userCredential.user);
     return {
       user: userCredential.user,

package/src/domains/auth/infrastructure/services/auth-guard.service.ts

@@ -11,6 +11,7 @@ import {
   getCurrentUserId,
   getCurrentUser,
 } from './auth-utils.service';
+import { ERROR_MESSAGES } from '../../../../shared/domain/utils/error-handlers/error-messages';
 
 /**
  * Auth Guard Service
@@ -24,22 +25,21 @@ export class AuthGuardService {
   async requireAuthenticatedUser(): Promise<string> {
     const auth = getFirebaseAuth();
     if (!auth) {
-      throw new Error('Firebase Auth is not initialized');
+      throw new Error(ERROR_MESSAGES.AUTH.NOT_INITIALIZED);
     }
 
     const userId = getCurrentUserId(auth);
     if (!userId) {
-      throw new Error('User must be authenticated to perform this action');
+      throw new Error(ERROR_MESSAGES.AUTH.NOT_AUTHENTICATED);
     }
 
     const currentUser = getCurrentUser(auth);
     if (!currentUser) {
-      throw new Error('User must be authenticated to perform this action');
+      throw new Error(ERROR_MESSAGES.AUTH.NOT_AUTHENTICATED);
     }
 
-    // Check if user is anonymous (guest)
     if (currentUser.isAnonymous) {
-      throw new Error('Guest users cannot perform this action');
+      throw new Error(ERROR_MESSAGES.AUTH.NON_ANONYMOUS_ONLY);
     }
 
     return userId;

package/src/domains/auth/infrastructure/stores/auth.store.ts

@@ -62,7 +62,11 @@ export const useFirebaseAuthStore = createStore<AuthState, AuthActions>({
         // Listener setup complete - keep mutex locked until cleanup
         // (setupInProgress remains true to indicate active listener)
       } catch (error) {
-        // On error, release the mutex so retry is possible
+        // On error, clean up partially initialized listener and release the mutex
+        if (unsubscribe) {
+          unsubscribe();
+          unsubscribe = null;
+        }
         setupInProgress = false;
         set({ listenerSetup: false, loading: false });
         throw error; // Re-throw to allow caller to handle

package/src/domains/firestore/infrastructure/repositories/BasePaginatedRepository.ts

@@ -12,6 +12,19 @@ import type { PaginatedResult, PaginationParams } from "../../types/pagination.t
 import { BaseQueryRepository } from "./BaseQueryRepository";
 
 export abstract class BasePaginatedRepository extends BaseQueryRepository {
+  /**
+   * Validate cursor format
+   * Cursors must be non-empty strings without path separators
+   */
+  private isValidCursor(cursor: string): boolean {
+    if (!cursor || typeof cursor !== 'string') return false;
+    // Check for invalid characters (path separators, null bytes)
+    if (cursor.includes('/') || cursor.includes('\\') || cursor.includes('\0')) return false;
+    // Check length (Firestore document IDs can't be longer than 1500 bytes)
+    if (cursor.length > 1500) return false;
+    return true;
+  }
+
   /**
    * Execute paginated query with cursor support
    *
@@ -47,6 +60,12 @@ export abstract class BasePaginatedRepository extends BaseQueryRepository {
     if (helper.hasCursor(params) && params?.cursor) {
       cursorKey = params.cursor;
 
+      // Validate cursor format to prevent Firestore errors
+      if (!this.isValidCursor(params.cursor)) {
+        // Invalid cursor format - return empty result
+        return [];
+      }
+
       // Fetch cursor document first
       const cursorDocRef = doc(db, collectionName, params.cursor);
       const cursorDoc = await getDoc(cursorDocRef);

package/src/domains/firestore/infrastructure/repositories/BaseRepository.ts

@@ -11,6 +11,7 @@
 import type { Firestore, CollectionReference, DocumentReference, DocumentData } from 'firebase/firestore';
 import { getFirestore, collection, doc } from 'firebase/firestore';
 import { isQuotaError as checkQuotaError } from '../../utils/quota-error-detector.util';
+import { ERROR_MESSAGES } from '../../../../shared/domain/utils/error-handlers/error-messages';
 
 export enum RepositoryState {
   ACTIVE = 'active',
@@ -75,19 +76,15 @@ export abstract class BaseRepository implements IPathResolver {
     operation: () => Promise<T>
   ): Promise<T> {
     if (this.state === RepositoryState.DESTROYED) {
-      throw new Error('Repository has been destroyed');
+      throw new Error(ERROR_MESSAGES.REPOSITORY.DESTROYED);
     }
 
     try {
       return await operation();
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-
-      // Check if this is a quota error
       if (checkQuotaError(error)) {
-        throw new Error(`Firestore quota exceeded: ${errorMessage}`);
+        throw new Error(ERROR_MESSAGES.FIRESTORE.QUOTA_EXCEEDED);
       }
-
       throw error;
     }
   }

package/src/shared/domain/utils/error-handlers/error-checkers.ts

@@ -84,8 +84,8 @@ export function isQuotaError(error: unknown): boolean {
   if (!error || typeof error !== 'object') return false;
 
   if (hasCodeProperty(error)) {
-    const code = error.code;
-    return QUOTA_ERROR_CODES.some(
+    const code = error.code.toLowerCase();
+    return QUOTA_ERROR_CODES.map(c => c.toLowerCase()).some(
       (c) => code === c || code.endsWith(`/${c}`) || code.startsWith(`${c}/`)
     );
   }
@@ -94,12 +94,10 @@ export function isQuotaError(error: unknown): boolean {
     const message = error.message.toLowerCase();
     return QUOTA_ERROR_MESSAGES.some((m) => {
       const pattern = m.toLowerCase();
-      return (
-        message.includes(` ${pattern} `) ||
-        message.startsWith(`${pattern} `) ||
-        message.endsWith(` ${pattern}`) ||
-        message === pattern
-      );
+      // More flexible matching: handle hyphens, underscores, and no spaces
+      const normalizedMessage = message.replace(/[-_\s]+/g, ' ');
+      const normalizedPattern = pattern.replace(/[-_\s]+/g, ' ');
+      return normalizedMessage.includes(normalizedPattern);
     });
   }
 

package/src/shared/domain/utils/error-handlers/error-messages.ts

@@ -1,18 +1,33 @@
-/**
- * Error Messages
- * User-friendly error messages for common error types
- */
+export const ERROR_MESSAGES = {
+  AUTH: {
+    NOT_INITIALIZED: 'Firebase Auth is not initialized',
+    NOT_AUTHENTICATED: 'User must be authenticated',
+    ANONYMOUS_ONLY: 'Anonymous users cannot perform this action',
+    NON_ANONYMOUS_ONLY: 'Guest users cannot perform this action',
+    SIGN_OUT_REQUIRED: 'Sign out first before performing this action',
+    NO_USER: 'No user is currently signed in',
+    INVALID_USER: 'Invalid user',
+  },
+  FIRESTORE: {
+    NOT_INITIALIZED: 'Firestore is not initialized',
+    QUOTA_EXCEEDED: 'Daily quota exceeded. Please try again tomorrow or upgrade your plan.',
+  },
+  REPOSITORY: {
+    DESTROYED: 'Repository has been destroyed',
+  },
+  SERVICE: {
+    NOT_CONFIGURED: 'Service is not configured',
+  },
+  GENERAL: {
+    RETRYABLE: 'Temporary error occurred. Please try again.',
+    UNKNOWN: 'Unknown error occurred',
+  },
+} as const;
 
-/**
- * Get user-friendly quota error message
- */
 export function getQuotaErrorMessage(): string {
-  return 'Daily quota exceeded. Please try again tomorrow or upgrade your plan.';
+  return ERROR_MESSAGES.FIRESTORE.QUOTA_EXCEEDED;
 }
 
-/**
- * Get user-friendly retryable error message
- */
 export function getRetryableErrorMessage(): string {
-  return 'Temporary error occurred. Please try again.';
+  return ERROR_MESSAGES.GENERAL.RETRYABLE;
 }

package/src/shared/domain/utils/executors/batch-executors.util.ts

@@ -1,41 +1,38 @@
-/**
- * Batch Async Executors
- * Execute multiple operations in parallel or sequence
- */
-
 import type { Result, FailureResult } from '../result.util';
-import { failureResultFromError, successResult } from '../result.util';
+import { failureResultFromError, successResult, isSuccess } from '../result.util';
 
-/**
- * Execute multiple operations in parallel
- * Returns success only if all operations succeed
- */
 export async function executeAll<T>(
   ...operations: (() => Promise<Result<T>>)[]
 ): Promise<Result<T[]>> {
   try {
     const results = await Promise.all(operations.map((op) => op()));
-    const failures = results.filter((r) => !r.success);
-    if (failures.length > 0) {
-      return failures[0] as FailureResult;
+
+    for (const result of results) {
+      if (!result.success && result.error !== undefined) {
+        return result as FailureResult;
+      }
     }
-    const data = results.map((r) => (r as { success: true; data: T }).data);
+
+    const data: T[] = [];
+    for (const result of results) {
+      if (isSuccess(result) && result.data !== undefined) {
+        data.push(result.data);
+      }
+    }
+
     return successResult(data);
   } catch (error) {
     return failureResultFromError(error);
   }
 }
 
-/**
- * Execute operations in sequence, stopping at first failure
- */
 export async function executeSequence<T>(
   ...operations: (() => Promise<Result<T>>)[]
 ): Promise<Result<void>> {
   for (const operation of operations) {
     const result = await operation();
-    if (!result.success) {
-      return result as Result<void>;
+    if (!result.success && result.error !== undefined) {
+      return { success: false, error: result.error };
     }
   }
   return successResult();

package/src/shared/domain/utils/result/result-helpers.ts

@@ -17,7 +17,7 @@ export function isSuccess<T>(result: Result<T>): result is SuccessResult<T> {
  * Check if result is a failure
  */
 export function isFailure<T>(result: Result<T>): result is FailureResult {
-  return result.success === false;
+  return result.success === false && result.error !== undefined;
 }
 
 /**

package/src/shared/domain/utils/service-config.util.ts

@@ -1,8 +1,4 @@
-/**
- * Configurable Service Base Class
- * Provides common service configuration pattern
- * Eliminates code duplication across services
- */
+import { ERROR_MESSAGES } from './error-handlers/error-messages';
 
 /**
  * Configuration state management
@@ -78,12 +74,9 @@ export class ConfigurableService<TConfig = unknown> implements IConfigurableServ
     return true;
   }
 
-  /**
-   * Get required configuration or throw error
-   */
   protected requireConfig(): TConfig {
     if (!this.configState.config) {
-      throw new Error('Service is not configured');
+      throw new Error(ERROR_MESSAGES.SERVICE.NOT_CONFIGURED);
     }
     return this.configState.config;
   }

package/src/shared/infrastructure/config/FirebaseConfigLoader.ts

@@ -96,7 +96,7 @@ export function loadFirebaseConfig(): FirebaseConfig | null {
 
   // Validate authDomain format (should be like "projectId.firebaseapp.com")
   if (!isValidFirebaseAuthDomain(authDomain)) {
-    // Invalid format but not a critical error - continue
+    return null;
   }
 
   // Build type-safe FirebaseConfig object

package/src/shared/infrastructure/config/base/ServiceClientSingleton.ts

@@ -33,6 +33,7 @@ export interface ServiceClientOptions<TInstance, TConfig = unknown> {
 export class ServiceClientSingleton<TInstance, TConfig = unknown> {
   protected state: ServiceClientState<TInstance>;
   private readonly options: ServiceClientOptions<TInstance, TConfig>;
+  private initInProgress = false;
 
   constructor(options: ServiceClientOptions<TInstance, TConfig>) {
     this.options = options;
@@ -55,6 +56,12 @@ export class ServiceClientSingleton<TInstance, TConfig = unknown> {
       return null;
     }
 
+    // Prevent concurrent initialization attempts
+    if (this.initInProgress) {
+      return null;
+    }
+
+    this.initInProgress = true;
     try {
       const instance = this.options.initializer ? this.options.initializer(config) : null;
       if (instance) {
@@ -66,6 +73,8 @@ export class ServiceClientSingleton<TInstance, TConfig = unknown> {
       const errorMessage = error instanceof Error ? error.message : `Failed to initialize ${this.options.serviceName}`;
       this.state.initializationError = errorMessage;
       return null;
+    } finally {
+      this.initInProgress = false;
     }
   }
 
@@ -81,7 +90,13 @@ export class ServiceClientSingleton<TInstance, TConfig = unknown> {
       return null;
     }
 
+    // Prevent concurrent auto-initialization attempts
+    if (this.initInProgress) {
+      return null;
+    }
+
     if (autoInit && this.options.autoInitializer) {
+      this.initInProgress = true;
       try {
         const instance = this.options.autoInitializer();
         if (instance) {
@@ -92,6 +107,8 @@ export class ServiceClientSingleton<TInstance, TConfig = unknown> {
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : `Failed to initialize ${this.options.serviceName}`;
         this.state.initializationError = errorMessage;
+      } finally {
+        this.initInProgress = false;
       }
     }
 
@@ -119,6 +136,7 @@ export class ServiceClientSingleton<TInstance, TConfig = unknown> {
     this.state.instance = null;
     this.state.initializationError = null;
     this.state.isInitialized = false;
+    this.initInProgress = false;
   }
 
   /**

package/src/shared/infrastructure/config/validators/FirebaseConfigValidator.ts

@@ -7,7 +7,7 @@
 
 import type { FirebaseConfig } from '../../../domain/value-objects/FirebaseConfig';
 import { FirebaseConfigurationError } from '../../../domain/errors/FirebaseError';
-import { isValidString, isValidFirebaseApiKey, isValidFirebaseProjectId } from '../../../domain/utils/validation.util';
+import { isValidString, isValidFirebaseApiKey, isValidFirebaseProjectId, isValidFirebaseAuthDomain } from '../../../domain/utils/validation.util';
 
 /**
  * Validation rule interface
@@ -70,7 +70,7 @@ class PlaceholderRule implements ValidationRule {
 export class FirebaseConfigValidator {
   private static rules: ValidationRule[] = [
     new RequiredFieldRule('API Key', config => config.apiKey, isValidFirebaseApiKey),
-    new RequiredFieldRule('Auth Domain', config => config.authDomain),
+    new RequiredFieldRule('Auth Domain', config => config.authDomain, isValidFirebaseAuthDomain),
     new RequiredFieldRule('Project ID', config => config.projectId, isValidFirebaseProjectId),
     new PlaceholderRule('API Key', config => config.apiKey, 'your_firebase_api_key'),
     new PlaceholderRule('Project ID', config => config.projectId, 'your-project-id'),