@umituz/react-native-firebase 1.13.137 → 1.13.139

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "1.13.137",
+  "version": "1.13.139",
   "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/auth/infrastructure/services/account-deletion.service.ts

@@ -1,5 +1,6 @@
 /**
  * Account Deletion Service
+ * Handles Firebase account deletion with reauthentication support
  */
 
 import { deleteUser, type User } from "firebase/auth";
@@ -21,14 +22,19 @@ export async function deleteCurrentUser(
   const auth = getFirebaseAuth();
   const user = auth?.currentUser;
 
-  if (!auth || !user) return {
-    success: false,
-    error: { code: "auth/not-ready", message: "Auth not ready", requiresReauth: false }
-  };
-  if (user.isAnonymous) return {
-    success: false,
-    error: { code: "auth/anonymous", message: "Cannot delete anonymous", requiresReauth: false }
-  };
+  if (!auth || !user) {
+    return {
+      success: false,
+      error: { code: "auth/not-ready", message: "Auth not ready", requiresReauth: false }
+    };
+  }
+
+  if (user.isAnonymous) {
+    return {
+      success: false,
+      error: { code: "auth/anonymous", message: "Cannot delete anonymous", requiresReauth: false }
+    };
+  }
 
   try {
     await deleteUser(user);
@@ -50,14 +56,27 @@ async function attemptReauth(user: User, options: AccountDeletionOptions): Promi
   const provider = getUserAuthProvider(user);
   let res: { success: boolean; error?: { code?: string; message?: string } };
 
-  if (provider === "apple.com") res = await reauthenticateWithApple(user);
-  else if (provider === "google.com") {
-    if (!options.googleIdToken) return { success: false, error: { code: "auth/google-reauth", message: "Google reauth required", requiresReauth: true } };
+  if (provider === "apple.com") {
+    res = await reauthenticateWithApple(user);
+  } else if (provider === "google.com") {
+    if (!options.googleIdToken) {
+      return {
+        success: false,
+        error: { code: "auth/google-reauth", message: "Google reauth required", requiresReauth: true }
+      };
+    }
     res = await reauthenticateWithGoogle(user, options.googleIdToken);
   } else if (provider === "password") {
-    if (!options.password) return { success: false, error: { code: "auth/password-reauth", message: "Password required", requiresReauth: true } };
+    if (!options.password) {
+      return {
+        success: false,
+        error: { code: "auth/password-reauth", message: "Password required", requiresReauth: true }
+      };
+    }
     res = await reauthenticateWithPassword(user, options.password);
-  } else return null;
+  } else {
+    return null;
+  }
 
   if (res.success) {
     try {
@@ -68,16 +87,33 @@ async function attemptReauth(user: User, options: AccountDeletionOptions): Promi
       return { success: false, error: { ...authErr, requiresReauth: false } };
     }
   }
-  return { success: false, error: { code: res.error?.code || "auth/reauth-failed", message: res.error?.message || "Reauth failed", requiresReauth: true } };
+
+  return {
+    success: false,
+    error: {
+      code: res.error?.code || "auth/reauth-failed",
+      message: res.error?.message || "Reauth failed",
+      requiresReauth: true
+    }
+  };
 }
 
 export async function deleteUserAccount(user: User | null): Promise<AccountDeletionResult> {
-  if (!user || user.isAnonymous) return { success: false, error: { code: "auth/invalid", message: "Invalid user", requiresReauth: false } };
+  if (!user || user.isAnonymous) {
+    return {
+      success: false,
+      error: { code: "auth/invalid", message: "Invalid user", requiresReauth: false }
+    };
+  }
+
   try {
     await deleteUser(user);
     return { success: true };
   } catch (error: unknown) {
     const authErr = toAuthErrorInfo(error);
-    return { success: false, error: { ...authErr, requiresReauth: authErr.code === "auth/requires-recent-login" } };
+    return {
+      success: false,
+      error: { ...authErr, requiresReauth: authErr.code === "auth/requires-recent-login" }
+    };
   }
 }

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

@@ -43,7 +43,6 @@ export class AnonymousAuthService implements AnonymousAuthServiceInterface {
         wasAlreadySignedIn: false,
       };
     } catch (error) {
-      if (__DEV__) console.error("[AnonymousAuthService] Failed", error);
       throw error;
     }
   }

package/src/auth/infrastructure/services/apple-auth.service.ts

@@ -15,7 +15,6 @@ import type { AppleAuthResult } from "./apple-auth.types";
 import {
   createSuccessResult,
   createFailureResult,
-  logAuthError,
   isCancellationError,
 } from "./base/base-auth.service";
 
@@ -24,8 +23,7 @@ export class AppleAuthService {
     if (Platform.OS !== "ios") return false;
     try {
       return await AppleAuthentication.isAvailableAsync();
-    } catch (error) {
-      if (__DEV__) console.warn('[AppleAuth] isAvailable check failed:', error);
+    } catch {
       return false;
     }
   }
@@ -37,7 +35,7 @@ export class AppleAuthService {
         return {
           success: false,
           error: "Apple Sign-In is not available on this device",
-          code: "unavailable",
+          code: "unavailable"
         };
       }
 
@@ -77,7 +75,6 @@ export class AppleAuthService {
         };
       }
 
-      logAuthError('Apple Sign-In', error);
       return createFailureResult(error);
     }
   }

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

@@ -52,8 +52,7 @@ export class AuthGuardService {
   async getAuthenticatedUserId(): Promise<string | null> {
     try {
       return await this.requireAuthenticatedUser();
-    } catch (error) {
-      if (__DEV__) console.warn('[AuthGuard] getAuthenticatedUserId:', error);
+    } catch {
       return null;
     }
   }
@@ -95,4 +94,3 @@ export class AuthGuardService {
 }
 
 export const authGuardService = new AuthGuardService();
-

package/src/auth/infrastructure/services/auth-utils.service.ts

@@ -15,12 +15,11 @@ export interface AuthCheckResult {
 }
 
 /**
- * Check current authentication state
+ * Create auth check result from user
+ * Centralized utility for creating AuthCheckResult objects
  */
-export function checkAuthState(auth: Auth): AuthCheckResult {
-  const currentUser = auth.currentUser;
-
-  if (!currentUser) {
+export function createAuthCheckResult(user: User | null): AuthCheckResult {
+  if (!user) {
     return {
       isAuthenticated: false,
       isAnonymous: false,
@@ -31,12 +30,19 @@ export function checkAuthState(auth: Auth): AuthCheckResult {
 
   return {
     isAuthenticated: true,
-    isAnonymous: currentUser.isAnonymous,
-    currentUser,
-    userId: currentUser.uid,
+    isAnonymous: user.isAnonymous,
+    currentUser: user,
+    userId: user.uid,
   };
 }
 
+/**
+ * Check current authentication state
+ */
+export function checkAuthState(auth: Auth): AuthCheckResult {
+  return createAuthCheckResult(auth.currentUser);
+}
+
 /**
  * Check if user is authenticated
  */
@@ -124,4 +130,3 @@ export function isValidUser(user: unknown): user is User {
     isValidString(user.uid)
   );
 }
-

package/src/auth/infrastructure/services/base/base-auth.service.ts

@@ -93,12 +93,3 @@ export function createSuccessResult(userCredential: UserCredential): AuthSuccess
     isNewUser: checkIsNewUser(userCredential),
   };
 }
-
-/**
- * Log auth error in development mode
- */
-export function logAuthError(serviceName: string, error: unknown): void {
-  if (__DEV__) {
-    console.error(`[Firebase Auth] ${serviceName} failed:`, error);
-  }
-}

package/src/auth/infrastructure/services/firestore-utils.service.ts

@@ -85,10 +85,7 @@ export function shouldSkipFirestoreQuery(
     }
 
     return createResult(false, authState);
-  } catch (error) {
-    if (__DEV__) {
-      console.error("[FirestoreUtils] Error checking query", error);
-    }
+  } catch {
     // Return a default result on error
     return createResult(true, {
       isAuthenticated: false,

package/src/auth/infrastructure/services/google-auth.service.ts

@@ -12,7 +12,6 @@ import type { GoogleAuthConfig, GoogleAuthResult } from "./google-auth.types";
 import {
   createSuccessResult,
   createFailureResult,
-  logAuthError,
 } from "./base/base-auth.service";
 
 /**
@@ -48,7 +47,6 @@ export class GoogleAuthService {
       const userCredential = await signInWithCredential(auth, credential);
       return createSuccessResult(userCredential);
     } catch (error) {
-      logAuthError('Google Sign-In', error);
       return createFailureResult(error);
     }
   }

package/src/auth/infrastructure/services/password.service.ts

@@ -4,6 +4,7 @@
  */
 
 import { updatePassword, type User } from 'firebase/auth';
+import { toAuthErrorInfo } from '../../../domain/utils/error-handler.util';
 
 /**
  * Result of a password update operation
@@ -25,12 +26,12 @@ export async function updateUserPassword(user: User, newPassword: string): Promi
     await updatePassword(user, newPassword);
     return { success: true };
   } catch (error: unknown) {
-    const err = error as { code?: string; message?: string };
+    const errorInfo = toAuthErrorInfo(error);
     return {
       success: false,
       error: {
-        code: err.code || 'auth/password-update-failed',
-        message: err.message || 'Failed to update password',
+        code: errorInfo.code,
+        message: errorInfo.message,
       },
     };
   }

package/src/auth/infrastructure/services/reauthentication.service.ts

@@ -47,7 +47,13 @@ export async function reauthenticateWithGoogle(user: User, idToken: string): Pro
 }
 
 export async function reauthenticateWithPassword(user: User, pass: string): Promise<ReauthenticationResult> {
-  if (!user.email) return { success: false, error: { code: "auth/no-email", message: "User has no email" } };
+  if (!user.email) {
+    return {
+      success: false,
+      error: { code: "auth/no-email", message: "User has no email" }
+    };
+  }
+
   try {
     await reauthenticateWithCredential(user, EmailAuthProvider.credential(user.email, pass));
     return { success: true };
@@ -58,30 +64,62 @@ export async function reauthenticateWithPassword(user: User, pass: string): Prom
 }
 
 export async function getAppleReauthCredential(): Promise<ReauthCredentialResult> {
-  if (Platform.OS !== "ios") return { success: false, error: { code: "auth/ios-only", message: "iOS only" } };
+  if (Platform.OS !== "ios") {
+    return {
+      success: false,
+      error: { code: "auth/ios-only", message: "iOS only" }
+    };
+  }
+
   try {
-    if (!(await AppleAuthentication.isAvailableAsync()))
-      return { success: false, error: { code: "auth/unavailable", message: "Unavailable" } };
+    const isAvailable = await AppleAuthentication.isAvailableAsync();
+    if (!isAvailable) {
+      return {
+        success: false,
+        error: { code: "auth/unavailable", message: "Unavailable" }
+      };
+    }
 
     const nonce = await generateNonce();
     const hashed = await hashNonce(nonce);
     const apple = await AppleAuthentication.signInAsync({
-      requestedScopes: [AppleAuthentication.AppleAuthenticationScope.FULL_NAME, AppleAuthentication.AppleAuthenticationScope.EMAIL],
+      requestedScopes: [
+        AppleAuthentication.AppleAuthenticationScope.FULL_NAME,
+        AppleAuthentication.AppleAuthenticationScope.EMAIL
+      ],
       nonce: hashed,
     });
 
-    if (!apple.identityToken) return { success: false, error: { code: "auth/no-token", message: "No token" } };
-    return { success: true, credential: new OAuthProvider("apple.com").credential({ idToken: apple.identityToken, rawNonce: nonce }) };
+    if (!apple.identityToken) {
+      return {
+        success: false,
+        error: { code: "auth/no-token", message: "No token" }
+      };
+    }
+
+    const credential = new OAuthProvider("apple.com").credential({
+      idToken: apple.identityToken,
+      rawNonce: nonce
+    });
+
+    return {
+      success: true,
+      credential
+    };
   } catch (error: unknown) {
     const err = toAuthErrorInfo(error);
     const code = isCancelledError(err) ? "auth/cancelled" : err.code;
-    return { success: false, error: { code, message: err.message } };
+    return {
+      success: false,
+      error: { code, message: err.message }
+    };
   }
 }
 
 export async function reauthenticateWithApple(user: User): Promise<ReauthenticationResult> {
   const res = await getAppleReauthCredential();
   if (!res.success || !res.credential) return { success: false, error: res.error };
+
   try {
     await reauthenticateWithCredential(user, res.credential);
     return { success: true };

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

@@ -65,9 +65,6 @@ export const useFirebaseAuthStore = createStore<AuthState, AuthActions>({
         // On error, release the mutex so retry is possible
         setupInProgress = false;
         set({ listenerSetup: false, loading: false });
-        if (__DEV__) {
-          console.error('[Auth Store] Failed to setup auth listener:', error);
-        }
         throw error; // Re-throw to allow caller to handle
       }
     },

package/src/auth/presentation/hooks/utils/auth-state-change.handler.ts

@@ -5,29 +5,7 @@
 
 import type { User } from 'firebase/auth';
 import type { AuthCheckResult } from '../../../infrastructure/services/auth-utils.service';
-
-/**
- * Convert Firebase User to AuthCheckResult
- * @param user - Firebase user or null
- * @returns AuthCheckResult
- */
-export function userToAuthCheckResult(user: User | null): AuthCheckResult {
-  if (!user) {
-    return {
-      isAuthenticated: false,
-      isAnonymous: false,
-      currentUser: null,
-      userId: null,
-    };
-  }
-
-  return {
-    isAuthenticated: true,
-    isAnonymous: user.isAnonymous === true,
-    currentUser: user,
-    userId: user.uid,
-  };
-}
+import { createAuthCheckResult } from '../../../infrastructure/services/auth-utils.service';
 
 /**
  * Create auth state change handler callback
@@ -53,20 +31,21 @@ export function createAuthStateChangeHandler(
 
   return (user: User | null) => {
     try {
-      const authState = userToAuthCheckResult(user);
+      const authState = createAuthCheckResult(user);
       setAuthState(authState);
       setError(null);
     } catch (err) {
       const authError =
         err instanceof Error ? err : new Error('Auth state check failed');
       setError(authError);
-
-      if (__DEV__) {
-         
-        console.error('[AuthStateHandler] Auth state change error', authError);
-      }
     } finally {
       setLoading(false);
     }
   };
 }
+
+/**
+ * Convert Firebase User to AuthCheckResult
+ * Re-exports createAuthCheckResult for convenience
+ */
+export const userToAuthCheckResult = createAuthCheckResult;

package/src/domain/guards/firebase-error.guard.ts

@@ -8,7 +8,7 @@
 
 import type { FirestoreError } from 'firebase/firestore';
 import type { AuthError } from 'firebase/auth';
-import { hasCodeProperty } from '../utils/error-handler.util';
+import { hasCodeProperty } from '../utils/type-guards.util';
 
 /**
  * Firebase error base interface

package/src/domain/utils/error-handler.util.ts

@@ -3,6 +3,8 @@
  * Centralized error handling utilities for Firebase operations
  */
 
+import { hasCodeProperty, hasMessageProperty, hasCodeAndMessageProperties } from './type-guards.util';
+
 /**
  * Standard error structure with code and message
  */
@@ -36,32 +38,6 @@ const QUOTA_ERROR_MESSAGES = [
  */
 const RETRYABLE_ERROR_CODES = ['unavailable', 'deadline-exceeded', 'aborted'];
 
-/**
- * Type guard for error with code property
- * Uses proper type predicate instead of 'as' assertion
- */
-export function hasCodeProperty(error: unknown): error is { code: string } {
-  return (
-    typeof error === 'object' &&
-    error !== null &&
-    'code' in error &&
-    typeof (error as { code: unknown }).code === 'string'
-  );
-}
-
-/**
- * Type guard for error with message property
- * Uses proper type predicate instead of 'as' assertion
- */
-export function hasMessageProperty(error: unknown): error is { message: string } {
-  return (
-    typeof error === 'object' &&
-    error !== null &&
-    'message' in error &&
-    typeof (error as { message: unknown }).message === 'string'
-  );
-}
-
 /**
  * Convert unknown error to standard error info
  * Handles Error objects, strings, and unknown types
@@ -197,3 +173,6 @@ export function getQuotaErrorMessage(): string {
 export function getRetryableErrorMessage(): string {
   return 'Temporary error occurred. Please try again.';
 }
+
+// Re-export type guards for convenience
+export { hasCodeProperty, hasMessageProperty, hasCodeAndMessageProperties };

package/src/domain/utils/type-guards.util.ts

@@ -0,0 +1,66 @@
+/**
+ * Type Guard Utilities
+ *
+ * Common type guards for Firebase and JavaScript objects.
+ * Provides type-safe checking without using 'as' assertions.
+ */
+
+/**
+ * Type guard for objects with a 'code' property of type string
+ * Commonly used for Firebase errors and other error objects
+ */
+export function hasCodeProperty(error: unknown): error is { code: string } {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'code' in error &&
+    typeof (error as { code: unknown }).code === 'string'
+  );
+}
+
+/**
+ * Type guard for objects with a 'message' property of type string
+ * Commonly used for Error objects
+ */
+export function hasMessageProperty(error: unknown): error is { message: string } {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'message' in error &&
+    typeof (error as { message: unknown }).message === 'string'
+  );
+}
+
+/**
+ * Type guard for objects with both 'code' and 'message' properties
+ * Commonly used for Firebase error objects
+ */
+export function hasCodeAndMessageProperties(error: unknown): error is { code: string; message: string } {
+  return hasCodeProperty(error) && hasMessageProperty(error);
+}
+
+/**
+ * Type guard for objects with a 'name' property of type string
+ * Commonly used for Error objects
+ */
+export function hasNameProperty(error: unknown): error is { name: string } {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'name' in error &&
+    typeof (error as { name: unknown }).name === 'string'
+  );
+}
+
+/**
+ * Type guard for objects with a 'stack' property of type string
+ * Commonly used for Error objects
+ */
+export function hasStackProperty(error: unknown): error is { stack: string } {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'stack' in error &&
+    typeof (error as { stack: unknown }).stack === 'string'
+  );
+}

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

@@ -30,7 +30,11 @@ export abstract class BasePaginatedRepository extends BaseQueryRepository {
     orderByField: string = "createdAt",
     orderDirection: "asc" | "desc" = "desc",
   ): Promise<QueryDocumentSnapshot<DocumentData>[]> {
-    const db = this.getDbOrThrow();
+    const db = this.getDb();
+    if (!db) {
+      return [];
+    }
+
     const helper = new PaginationHelper();
     const pageLimit = helper.getLimit(params);
     const fetchLimit = helper.getFetchLimit(pageLimit);
@@ -49,9 +53,6 @@ export abstract class BasePaginatedRepository extends BaseQueryRepository {
 
       if (!cursorDoc.exists()) {
         // Cursor document doesn't exist - return empty result
-        if (__DEV__) {
-          console.warn(`[BasePaginatedRepository] Cursor document not found: ${params.cursor}`);
-        }
         return [];
       }
 
@@ -114,4 +115,4 @@ export abstract class BasePaginatedRepository extends BaseQueryRepository {
     const pageLimit = helper.getLimit(params);
     return helper.buildResult(items, pageLimit, getCursor);
   }
-}
+}

package/src/firestore/infrastructure/repositories/BaseQueryRepository.ts

@@ -43,13 +43,13 @@ export abstract class BaseQueryRepository extends BaseRepository {
     return queryDeduplicationMiddleware.deduplicate(queryKey, async () => {
       // Execute the query function
       const result = await queryFn();
-      
+
       // Track the operation after successful execution
       // We calculate count based on result if possible, otherwise default to 1 (for list/count queries)
       const count = Array.isArray(result) ? result.length : 1;
-      
+
       this.trackRead(collection, count, cached);
-      
+
       return result;
     });
   }
@@ -82,4 +82,4 @@ export abstract class BaseQueryRepository extends BaseRepository {
   ): void {
     quotaTrackingMiddleware.trackDelete(collection, count);
   }
-}
+}

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

@@ -1,152 +1,107 @@
 /**
- * Base Repository - Core Operations
+ * Base Repository - Core Firestore Operations
  *
- * Provides essential Firestore operations with centralized database access.
- * All Firestore repositories should extend this class.
- *
- * Architecture:
- * - DRY: Centralized database access (getDb)
- * - SOLID: Single Responsibility - Database access only
- * - KISS: Simple base class with protected db property
- * - App-agnostic: Works with any app, no app-specific code
- *
- * This class is designed to be used across hundreds of apps.
- * It provides a consistent interface for Firestore operations.
+ * Provides base functionality for all Firestore repositories.
+ * Handles initialization checks, error handling, and quota tracking.
  */
 
-import type { Firestore } from "firebase/firestore";
-import { getFirestore } from "../config/FirestoreClient";
-import {
-  isQuotaError as checkQuotaError,
-  getQuotaErrorMessage,
-} from "../../utils/quota-error-detector.util";
-import { FirebaseFirestoreQuotaError } from "../../domain/errors/FirebaseFirestoreError";
+import type { Firestore } from 'firebase/firestore';
+import { getFirestore } from 'firebase/firestore';
+import { isQuotaError as checkQuotaError } from '../../utils/quota-error-detector.util';
+
+/**
+ * Repository destruction state
+ */
+export enum RepositoryState {
+  ACTIVE = 'active',
+  DESTROYED = 'destroyed',
+}
 
-export class BaseRepository {
-  private isDestroyed = false;
+/**
+ * Base repository for Firestore operations
+ * Provides common functionality for all repositories
+ */
+export abstract class BaseRepository {
+  protected state: RepositoryState = RepositoryState.ACTIVE;
 
   /**
-   * Get Firestore database instance
-   * Returns null if Firestore is not initialized (offline mode)
-   * Use getDbOrThrow() if you need to throw an error instead
-   *
-   * @returns Firestore instance or null if not initialized
+   * Get the Firestore instance
+   * @throws Error if repository is destroyed
    */
   protected getDb(): Firestore | null {
-    if (this.isDestroyed) {
-      if (__DEV__) {
-        console.warn('[BaseRepository] Attempted to use destroyed repository');
-      }
+    if (this.state === RepositoryState.DESTROYED) {
       return null;
     }
     return getFirestore();
   }
 
-  /**
-   * Get Firestore database instance or throw error
-   * Throws error if Firestore is not initialized
-   * Use this method when Firestore is required for the operation
-   *
-   * @returns Firestore instance
-   * @throws Error if Firestore is not initialized
-   */
-  protected getDbOrThrow(): Firestore {
-    if (this.isDestroyed) {
-      throw new Error("Repository has been destroyed");
-    }
-    const db = getFirestore();
-    if (!db) {
-      throw new Error("Firestore is not initialized. Please initialize Firebase App first.");
-    }
-    return db;
-  }
-
   /**
    * Check if Firestore is initialized
-   * Useful for conditional operations
-   *
-   * @returns true if Firestore is initialized, false otherwise
    */
   protected isDbInitialized(): boolean {
     try {
-      const db = getFirestore();
+      const db = this.getDb();
       return db !== null;
-    } catch (error) {
-      if (__DEV__) console.warn('[BaseRepository] isDbInitialized check failed:', error);
+    } catch {
       return false;
     }
   }
 
   /**
-   * Check if error is a quota error
-   * Quota errors indicate daily read/write/delete limits are exceeded
-   *
-   * @param error - Error to check
-   * @returns true if error is a quota error
-   */
-  protected isQuotaError(error: unknown): boolean {
-    return checkQuotaError(error);
-  }
-
-  /**
-   * Handle quota error
-   * Throws FirebaseFirestoreQuotaError with user-friendly message
-   *
-   * @param error - Original error
-   * @throws FirebaseFirestoreQuotaError
+   * Execute operation with error handling
+   * @param collection - Collection name for tracking
+   * @param operation - Operation to execute
+   * @returns Operation result
+   * @throws Error if operation fails
    */
-  protected handleQuotaError(error: unknown): never {
-    const message = getQuotaErrorMessage();
-    throw new FirebaseFirestoreQuotaError(message, error);
-  }
-
-  /**
-   * Wrap Firestore operation with quota error handling
-   * Automatically detects and handles quota errors
-   *
-   * @param operation - Firestore operation to execute
-   * @returns Result of the operation
-   * @throws FirebaseFirestoreQuotaError if quota error occurs
-   */
-  protected async executeWithQuotaHandling<T>(
-    operation: () => Promise<T>,
+  protected async executeOperation<T>(
+    collection: string,
+    operation: () => Promise<T>
   ): Promise<T> {
+    if (this.state === RepositoryState.DESTROYED) {
+      throw new Error('Repository has been destroyed');
+    }
+
     try {
       return await operation();
     } catch (error) {
-      if (this.isQuotaError(error)) {
-        this.handleQuotaError(error);
-      }
-      // Log the error for debugging
-      if (__DEV__) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        console.error('[BaseRepository] Operation failed:', errorMessage);
+      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 error;
     }
   }
 
   /**
-   * Destroy repository and cleanup resources
-   * Child classes can override onDestroy() to add custom cleanup logic
+   * Track read operation
    */
-  destroy(): void {
-    if (__DEV__) {
-      console.log(`[BaseRepository] Destroying repository for ${this.constructor.name}`);
-    }
+  protected trackRead(_collection: string, _count: number = 1): void {
+    // Quota tracking delegated to middleware
+  }
 
-    // Call child class cleanup if implemented
-    this.onDestroy();
+  /**
+   * Track write operation
+   */
+  protected trackWrite(_collection: string, _count: number = 1): void {
+    // Quota tracking delegated to middleware
+  }
 
-    // Mark as destroyed
-    this.isDestroyed = true;
+  /**
+   * Track delete operation
+   */
+  protected trackDelete(_collection: string, _count: number = 1): void {
+    // Quota tracking delegated to middleware
   }
 
   /**
-   * Cleanup hook for child classes
-   * Override this method to add custom cleanup logic (e.g., unsubscribe from listeners)
+   * Destroy the repository
+   * Prevents further operations
    */
-  protected onDestroy(): void {
-    // Override in child classes if needed
+  destroy(): void {
+    this.state = RepositoryState.DESTROYED;
   }
-}
+}

package/src/firestore/utils/transaction/transaction.util.ts

@@ -9,7 +9,7 @@ import {
   type Transaction,
 } from "firebase/firestore";
 import { getFirestore } from "../../infrastructure/config/FirestoreClient";
-import type { Firestore } from "../../infrastructure/config/FirestoreClient";
+import { hasCodeProperty } from "../../../domain/utils/type-guards.util";
 
 /**
  * Execute a transaction with automatic DB instance check.
@@ -23,15 +23,10 @@ export async function runTransaction<T>(
     throw new Error("[runTransaction] Firestore database is not initialized. Please ensure Firebase is properly initialized before running transactions.");
   }
   try {
-    return await fbRunTransaction(db as Firestore, updateFunction);
+    return await fbRunTransaction(db, updateFunction);
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-    const errorCode = error instanceof Error ? (error as { code?: string }).code : 'unknown';
-
-    if (__DEV__) {
-      console.error(`[runTransaction] Transaction failed (Code: ${errorCode}):`, errorMessage);
-    }
-
+    const errorCode = hasCodeProperty(error) ? error.code : 'unknown';
     throw new Error(`[runTransaction] Transaction failed: ${errorMessage} (Code: ${errorCode})`);
   }
 }

package/src/infrastructure/config/FirebaseClient.ts

@@ -6,14 +6,6 @@
  *
  * IMPORTANT: This package does NOT read from .env files.
  * Configuration must be provided by the application.
- *
- * NOTE: Auth initialization is handled by the main app via callback.
- * This removes the need for dynamic require() which causes issues in production.
- *
- * SOLID Principles:
- * - Single Responsibility: Only orchestrates initialization, delegates to specialized classes
- * - Open/Closed: Extensible through configuration, closed for modification
- * - Dependency Inversion: Depends on abstractions (interfaces), not concrete implementations
  */
 
 import type { FirebaseConfig } from '../../domain/value-objects/FirebaseConfig';
@@ -21,22 +13,29 @@ import type { IFirebaseClient } from '../../application/ports/IFirebaseClient';
 import type { FirebaseApp } from './initializers/FirebaseAppInitializer';
 import { FirebaseClientState } from './state/FirebaseClientState';
 import { FirebaseInitializationOrchestrator } from './orchestrators/FirebaseInitializationOrchestrator';
-import {
-  FirebaseServiceInitializer,
-  type AuthInitializer,
-  type ServiceInitializationOptions,
-} from './services/FirebaseServiceInitializer';
 import { loadFirebaseConfig } from './FirebaseConfigLoader';
 
-export type { FirebaseApp, AuthInitializer, ServiceInitializationOptions };
+export type { FirebaseApp };
+
+/**
+ * Auth initializer callback type
+ */
+export type AuthInitializer = () => Promise<void> | ((() => (any | null) | null));
+
+/**
+ * Service initialization options
+ */
+export interface ServiceInitializationOptions {
+  authInitializer?: AuthInitializer;
+}
 
 /**
  * Service initialization result interface
  */
 export interface ServiceInitializationResult {
   app: FirebaseApp | null;
-  auth: unknown; // Auth result from authInitializer callback (can be Auth, UserCredential, or any custom type)
-  authError?: string; // Error message if auth initialization failed
+  auth: boolean | null;
+  authError?: string;
 }
 
 /**
@@ -59,11 +58,11 @@ class FirebaseClientSingleton implements IFirebaseClient {
   }
 
   initialize(config: FirebaseConfig): FirebaseApp | null {
-    return FirebaseInitializationOrchestrator.initialize(config, this.state);
+    return FirebaseInitializationOrchestrator.initialize(config);
   }
 
   getApp(): FirebaseApp | null {
-    return FirebaseInitializationOrchestrator.autoInitialize(this.state);
+    return FirebaseInitializationOrchestrator.autoInitialize();
   }
 
   isInitialized(): boolean {
@@ -109,24 +108,7 @@ export function autoInitializeFirebase(): FirebaseApp | null {
 
 /**
  * Initialize all Firebase services (App and Auth)
- * This is the main entry point for applications - call this once at app startup
- *
- * IMPORTANT: Auth initialization is handled via callback to avoid require() issues.
- * The main app should pass the authInitializer callback from react-native-firebase-auth.
- *
- * @param config - Optional Firebase configuration
- * @param options - Optional service initialization options including authInitializer
- * @returns Object with initialization results for each service
- *
- * @example
- * ```typescript
- * import { initializeAllFirebaseServices } from '@umituz/react-native-firebase';
- * import { initializeFirebaseAuth } from '@umituz/react-native-firebase-auth';
- *
- * const result = await initializeAllFirebaseServices(undefined, {
- *   authInitializer: () => initializeFirebaseAuth(),
- * });
- * ```
+ * This is the main entry point for applications
  */
 export async function initializeAllFirebaseServices(
   config?: FirebaseConfig,
@@ -141,11 +123,23 @@ export async function initializeAllFirebaseServices(
     };
   }
 
-  const { auth } = await FirebaseServiceInitializer.initializeServices(options);
+  // Initialize Auth if provided
+  let authSuccess = null;
+  let authError: string | undefined;
+
+  if (options?.authInitializer) {
+    try {
+      await options.authInitializer();
+      authSuccess = true;
+    } catch (error) {
+      authError = error instanceof Error ? error.message : 'Auth initialization failed';
+    }
+  }
 
   return {
     app,
-    auth,
+    auth: authSuccess,
+    authError,
   };
 }
 

package/src/infrastructure/config/FirebaseConfigLoader.ts

@@ -46,8 +46,7 @@ function loadExpoConfig(): Record<string, string> {
     const Constants = require('expo-constants');
     const expoConfig = Constants?.expoConfig || Constants?.default?.expoConfig;
     return expoConfig?.extra || {};
-  } catch (error) {
-    if (__DEV__) console.warn('[FirebaseConfigLoader] expo-constants not available:', error);
+  } catch {
     return {};
   }
 }
@@ -87,27 +86,26 @@ export function loadFirebaseConfig(): FirebaseConfig | null {
   const projectId = config.projectId?.trim();
 
   if (!isValidString(apiKey) || !isValidString(authDomain) || !isValidString(projectId)) {
-    if (__DEV__) {
-      console.error('[FirebaseConfigLoader] Missing required configuration fields');
-    }
     return null;
   }
 
   // Validate API key format
   if (!isValidFirebaseApiKey(apiKey)) {
-    if (__DEV__) {
-      console.error('[FirebaseConfigLoader] Invalid API key format');
-    }
     return null;
   }
 
   // Validate authDomain format (should be like "projectId.firebaseapp.com")
   if (!isValidFirebaseAuthDomain(authDomain)) {
-    if (__DEV__) {
-      console.warn('[FirebaseConfigLoader] Unusual authDomain format, expected "projectId.firebaseapp.com" or similar');
-    }
+    // Invalid format but not a critical error - continue
   }
 
-  return config as FirebaseConfig;
+  // Build type-safe FirebaseConfig object
+  return {
+    apiKey,
+    authDomain,
+    projectId,
+    storageBucket: config.storageBucket || undefined,
+    messagingSenderId: config.messagingSenderId || undefined,
+    appId: config.appId || undefined,
+  };
 }
-

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

@@ -67,11 +67,6 @@ 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;
-
-      if (__DEV__) {
-        console.error(`[${this.options.serviceName}] Initialization failed:`, errorMessage);
-      }
-
       return null;
     }
   }
@@ -99,10 +94,6 @@ 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;
-
-        if (__DEV__) {
-          console.error(`[${this.options.serviceName}] Auto-initialization failed:`, errorMessage);
-        }
       }
     }
 
@@ -130,10 +121,6 @@ export class ServiceClientSingleton<TInstance, TConfig = unknown> {
     this.state.instance = null;
     this.state.initializationError = null;
     this.state.isInitialized = false;
-
-    if (__DEV__) {
-      console.log(`[${this.options.serviceName}] Service reset`);
-    }
   }
 
   /**

package/src/infrastructure/config/initializers/FirebaseAppInitializer.ts

@@ -44,8 +44,7 @@ class FirebaseAppManager {
     try {
       const existingApps = getApps();
       return existingApps.length > 0;
-    } catch (error) {
-      if (__DEV__) console.warn('[FirebaseAppManager] isInitialized check failed:', error);
+    } catch {
       return false;
     }
   }
@@ -57,8 +56,7 @@ class FirebaseAppManager {
     try {
       const existingApps = getApps();
       return existingApps.length > 0 ? existingApps[0] ?? null : null;
-    } catch (error) {
-      if (__DEV__) console.warn('[FirebaseAppManager] getExistingApp failed:', error);
+    } catch {
       return null;
     }
   }
@@ -98,4 +96,4 @@ export class FirebaseAppInitializer {
     // Create new app
     return FirebaseAppManager.createApp(config);
   }
-}
+}

package/src/infrastructure/config/orchestrators/FirebaseInitializationOrchestrator.ts

@@ -1,61 +1,53 @@
 /**
  * Firebase Initialization Orchestrator
- * Handles the initialization logic for Firebase App
  *
- * Single Responsibility: Only orchestrates Firebase App initialization
+ * Orchestrates the initialization of Firebase services
  */
 
+import type { FirebaseApp } from 'firebase/app';
+import { getApps } from 'firebase/app';
+import { initializeApp } from 'firebase/app';
 import type { FirebaseConfig } from '../../../domain/value-objects/FirebaseConfig';
-import type { FirebaseApp } from '../initializers/FirebaseAppInitializer';
-import { FirebaseConfigValidator } from '../validators/FirebaseConfigValidator';
-import { FirebaseAppInitializer } from '../initializers/FirebaseAppInitializer';
-import { loadFirebaseConfig } from '../FirebaseConfigLoader';
-import type { FirebaseClientState } from '../state/FirebaseClientState';
+import { FirebaseInitializationError } from '../../../domain/errors/FirebaseError';
 
+/**
+ * Orchestrates Firebase initialization
+ */
 export class FirebaseInitializationOrchestrator {
-  static initialize(
-    config: FirebaseConfig,
-    state: FirebaseClientState
-  ): FirebaseApp | null {
-    if (state.isInitialized()) {
-      return state.getApp();
-    }
-
-    if (state.getInitializationError()) {
-      return null;
+  /**
+   * Initialize Firebase app
+   */
+  static initialize(config: FirebaseConfig): FirebaseApp {
+    // Check for existing app
+    const existingApps = getApps();
+    const existingApp = existingApps.length > 0 ? existingApps[0] : undefined;
+    if (existingApp) {
+      return existingApp;
     }
 
+    // Initialize new app
     try {
-      FirebaseConfigValidator.validate(config);
-      const app = FirebaseAppInitializer.initialize(config);
-      state.setApp(app);
-
-      return app;
+      return initializeApp({
+        apiKey: config.apiKey,
+        authDomain: config.authDomain,
+        projectId: config.projectId,
+        storageBucket: config.storageBucket,
+        messagingSenderId: config.messagingSenderId,
+        appId: config.appId,
+      });
     } catch (error) {
-      const errorMessage =
-        error instanceof Error
-          ? error.message
-          : 'Failed to initialize Firebase client';
-      state.setInitializationError(errorMessage);
-
-      if (__DEV__) {
-        console.error('[Firebase] Initialization failed:', errorMessage);
-      }
-
-      return null;
+      throw new FirebaseInitializationError(
+        `Failed to initialize Firebase: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        error
+      );
     }
   }
 
-  static autoInitialize(state: FirebaseClientState): FirebaseApp | null {
-    if (state.isInitialized() || state.getInitializationError()) {
-      return state.getApp();
-    }
-
-    const autoConfig = loadFirebaseConfig();
-    if (autoConfig) {
-      return this.initialize(autoConfig, state);
-    }
-
-    return null;
+  /**
+   * Get existing app instance
+   */
+  static autoInitialize(): FirebaseApp | null {
+    const existingApps = getApps();
+    return existingApps.length > 0 ? (existingApps[0] ?? null) : null;
   }
 }

package/src/infrastructure/config/services/FirebaseServiceInitializer.ts

@@ -1,49 +1,43 @@
 /**
  * Firebase Service Initializer
- * Handles initialization of Firebase Auth service
  *
- * NOTE: Auth initialization is handled by the main app via callback.
- * This removes the need for dynamic require() which causes issues in production.
- *
- * Single Responsibility: Only initializes Firebase Auth service
+ * Orchestrates initialization of all Firebase services
+ * NOTE: This file is deprecated - use FirebaseClient.ts instead
+ * Kept for backwards compatibility
  */
 
-export type AuthInitializer = () => unknown;
-
-export interface ServiceInitializationOptions {
-  authInitializer?: AuthInitializer;
-}
-
-export interface ServiceInitializationResult {
-  auth: unknown;
-}
-
-export interface ServiceInitializationResult {
-  auth: unknown;
-  authError?: string;
-}
+import type { FirebaseApp } from 'firebase/app';
 
+/**
+ * Initialize Firebase services
+ * @deprecated Use initializeAllFirebaseServices from FirebaseClient instead
+ */
 export class FirebaseServiceInitializer {
-  static async initializeServices(
-    options?: ServiceInitializationOptions
-  ): Promise<ServiceInitializationResult> {
-    let auth: unknown = null;
-    let authError: string | undefined;
-
-    if (options?.authInitializer) {
-      try {
-        auth = await options.authInitializer();
-      } catch (error) {
-        // Auth initialization is optional but we should log the error
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        authError = errorMessage;
-
-        if (__DEV__) {
-          console.error('[FirebaseServiceInitializer] Auth initialization failed:', errorMessage);
-        }
-      }
-    }
+  /**
+   * Initialize all Firebase services
+   * @deprecated
+   */
+  static async initializeAll(
+    _app: FirebaseApp,
+    _options?: unknown
+  ): Promise<{ app: FirebaseApp | null; auth: boolean | null }> {
+    // This is now handled by FirebaseClient
+    return {
+      app: null,
+      auth: null,
+    };
+  }
 
-    return { auth, authError };
+  /**
+   * Initialize services (legacy compatibility)
+   * @deprecated
+   */
+  static async initializeServices(
+    _options?: unknown
+  ): Promise<{ app: FirebaseApp | null; auth: boolean | null }> {
+    return {
+      app: null,
+      auth: null,
+    };
   }
 }

package/src/init/createFirebaseInitModule.ts

@@ -5,7 +5,6 @@
 
 import type { InitModule } from '@umituz/react-native-design-system';
 import { initializeAllFirebaseServices } from '../infrastructure/config/FirebaseClient';
-import { initializeFirebaseAuth } from '../auth/infrastructure/config/FirebaseAuthClient';
 
 export interface FirebaseInitModuleConfig {
   /**
@@ -48,17 +47,10 @@ export function createFirebaseInitModule(
     init: async () => {
       try {
         await initializeAllFirebaseServices(undefined, {
-          authInitializer: authInitializer ?? (() => initializeFirebaseAuth()),
+          authInitializer: authInitializer ?? (() => Promise.resolve()),
         });
-
-        if (__DEV__) {
-        }
-
         return true;
-      } catch (error) {
-        if (__DEV__) {
-          console.error('[createFirebaseInitModule] Error:', error);
-        }
+      } catch {
         // Return false to indicate failure, let the app initializer handle it
         return false;
       }