@umituz/react-native-firebase 3.0.3 → 3.0.5

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

@@ -5,8 +5,8 @@
  */
 
 import type { Auth } from 'firebase/auth';
-import { getAuth as getFirebaseAuthFromFirebase } from 'firebase/auth';
 import { getFirebaseApp } from '../../../../shared/infrastructure/config/services/FirebaseInitializationService';
+import { FirebaseAuthInitializer } from './initializers/FirebaseAuthInitializer';
 import type { FirebaseAuthConfig } from '../../domain/value-objects/FirebaseAuthConfig';
 import { ServiceClientSingleton } from '../../../../shared/infrastructure/config/base/ServiceClientSingleton';
 
@@ -15,64 +15,76 @@ import { ServiceClientSingleton } from '../../../../shared/infrastructure/config
  */
 class FirebaseAuthClientSingleton extends ServiceClientSingleton<Auth, FirebaseAuthConfig> {
   private constructor() {
-    super();
+    super({
+      serviceName: 'FirebaseAuth',
+      initializer: (config?: FirebaseAuthConfig) => {
+        const app = getFirebaseApp();
+        if (!app) {
+          this.setError('Firebase App is not initialized');
+          return null;
+        }
+        const auth = FirebaseAuthInitializer.initialize(app, config);
+        if (!auth) {
+          this.setError('Auth initialization returned null');
+        }
+        return auth;
+      },
+    });
   }
 
-  initialize(): Auth {
-    try {
-      const app = getFirebaseApp();
-      if (!app) {
-        this.setError('Firebase App is not initialized');
-        throw new Error('Firebase App is not initialized');
-      }
+  private static instance: FirebaseAuthClientSingleton | null = null;
 
-      const auth = getFirebaseAuthFromFirebase(app);
-      this.instance = auth;
-      return auth;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Auth initialization failed';
-      this.setError(errorMessage);
-      throw error;
-    }
+  static getInstance(): FirebaseAuthClientSingleton {
+    if (!this.instance) this.instance = new FirebaseAuthClientSingleton();
+    return this.instance;
   }
 
-  getAuth(): Auth {
-    if (!this.isInitialized()) {
-      return this.initialize();
-    }
-    return this.getInstance();
+  /**
+   * Initialize Auth with optional configuration
+   */
+  override initialize(config?: FirebaseAuthConfig): Auth | null {
+    return super.initialize(config);
   }
 
-  private static instance: FirebaseAuthClientSingleton | null = null;
-
-  static getInstance(): FirebaseAuthClientSingleton {
-    if (!this.instance) {
-      this.instance = new FirebaseAuthClientSingleton();
+  /**
+   * Get Auth instance
+   */
+  getAuth(): Auth | null {
+    // Attempt initialization if not already initialized
+    if (!this.isInitialized() && !this.getInitializationError()) {
+      try {
+        const app = getFirebaseApp();
+        if (app) {
+          this.initialize();
+        }
+      } catch (error) {
+        // Silently handle auto-initialization errors
+        // The error will be stored in state for later retrieval
+        const errorMessage = error instanceof Error ? error.message : 'Auto-initialization failed';
+        this.setError(errorMessage);
+      }
     }
-    return this.instance;
+    // Enable auto-initialization flag when getting instance
+    return this.getInstance(true);
   }
 }
 
-const firebaseAuthClientSingleton = FirebaseAuthClientSingleton.getInstance();
-
-export const initializeFirebaseAuth = (): Auth => {
-  return firebaseAuthClientSingleton.initialize();
-};
-
-export const getFirebaseAuth = (): Auth => {
-  return firebaseAuthClientSingleton.getAuth();
-};
-
-export const isFirebaseAuthInitialized = (): boolean => {
-  return firebaseAuthClientSingleton.isInitialized();
-};
-
-export const getFirebaseAuthInitializationError = (): Error | null => {
-  return firebaseAuthClientSingleton.getInitializationError();
-};
+function getFirebaseAuthClientSafe(): FirebaseAuthClientSingleton | null {
+  try {
+    return FirebaseAuthClientSingleton.getInstance();
+  } catch {
+    if (__DEV__) {
+      console.warn('[Firebase] Could not create FirebaseAuth client singleton.');
+    }
+    return null;
+  }
+}
 
-export const resetFirebaseAuthClient = (): void => {
-  firebaseAuthClientSingleton.reset();
-};
+export const firebaseAuthClient = getFirebaseAuthClientSafe();
+export const initializeFirebaseAuth = (c?: FirebaseAuthConfig) => firebaseAuthClient?.initialize(c) ?? null;
+export const getFirebaseAuth = () => firebaseAuthClient?.getAuth() ?? null;
+export const isFirebaseAuthInitialized = () => firebaseAuthClient?.isInitialized() ?? false;
+export const getFirebaseAuthInitializationError = () => firebaseAuthClient?.getInitializationError() ?? null;
+export const resetFirebaseAuthClient = () => firebaseAuthClient?.reset();
 
 export type { Auth } from 'firebase/auth';

package/src/domains/auth/infrastructure/config/initializers/FirebaseAuthInitializer.ts

@@ -1,7 +1,15 @@
+/**
+ * Firebase Auth Initializer
+ *
+ * Single Responsibility: Initialize Firebase Auth instance
+ * Platform-agnostic: Works on all platforms (Web, iOS, Android)
+ */
+
 import {
   initializeAuth,
   getAuth,
   // @ts-expect-error: getReactNativePersistence exists in the React Native bundle but missing from type definitions
+  // See: https://github.com/firebase/firebase-js-sdk/issues/9316
   getReactNativePersistence,
 } from 'firebase/auth';
 import type { Auth } from 'firebase/auth';
@@ -9,8 +17,40 @@ import AsyncStorage from '@react-native-async-storage/async-storage';
 import type { FirebaseApp } from 'firebase/app';
 import type { FirebaseAuthConfig } from '../../../domain/value-objects/FirebaseAuthConfig';
 
+/**
+ * Initializes Firebase Auth
+ * Platform-agnostic: Works on all platforms (Web, iOS, Android)
+ */
 export class FirebaseAuthInitializer {
+  /**
+   * Initialize Firebase Auth with persistence support
+   */
   static initialize(app: FirebaseApp, config?: FirebaseAuthConfig): Auth | null {
+    try {
+      const auth = this.initializeWithPersistence(app, config);
+      return auth;
+    } catch (error: unknown) {
+      return this.handleInitializationError(error, app);
+    }
+  }
+
+  private static handleInitializationError(error: unknown, app: FirebaseApp): Auth | null {
+    // Any initialization error: try to get existing auth instance
+    return this.getExistingAuth(app);
+  }
+
+  private static getExistingAuth(app: FirebaseApp): Auth | null {
+    try {
+      return getAuth(app);
+    } catch {
+      return null;
+    }
+  }
+
+  private static initializeWithPersistence(
+    app: FirebaseApp,
+    config?: FirebaseAuthConfig
+  ): Auth | null {
     try {
       const storage = config?.authStorage || {
         getItem: (key: string) => AsyncStorage.getItem(key),
@@ -22,11 +62,7 @@ export class FirebaseAuthInitializer {
         persistence: getReactNativePersistence(storage),
       });
     } catch {
-      try {
-        return getAuth(app);
-      } catch {
-        return null;
-      }
+      return this.getExistingAuth(app);
     }
   }
 }

package/src/domains/auth/presentation/hooks/useGoogleOAuth.ts

@@ -1,14 +1,37 @@
 /**
  * useGoogleOAuth Hook
  * Handles Google OAuth flow using expo-auth-session and Firebase auth
- *
- * Max lines: 150 (enforced for maintainability)
+ * This hook is optional and requires expo-auth-session to be installed
  */
 
-import { useState, useCallback } from 'react';
-import { getFirebaseAuth } from '../../infrastructure/config/FirebaseAuthClient';
-import type { GoogleOAuthConfig } from '../../infrastructure/services/google-oauth.service';
-import { GoogleOAuthService } from '../../infrastructure/services/google-oauth.service';
+import { useState, useCallback, useEffect, useRef, useMemo } from "react";
+import { googleOAuthService } from "../../infrastructure/services/google-oauth.service";
+import { getFirebaseAuth } from "../../infrastructure/config/FirebaseAuthClient";
+import type { GoogleOAuthConfig } from "../../infrastructure/services/google-oauth.service";
+// Conditional import for expo-auth-session
+interface AuthSessionResponse {
+  type: string;
+  authentication?: { idToken?: string } | null;
+}
+
+interface ExpoAuthSessionModule {
+  useAuthRequest: (config: {
+    iosClientId: string;
+    webClientId: string;
+    androidClientId: string;
+  }) => [unknown, AuthSessionResponse | null, (() => Promise<AuthSessionResponse>) | null];
+}
+
+let ExpoAuthSession: ExpoAuthSessionModule | null = null;
+let isExpoAuthAvailable = false;
+
+try {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  ExpoAuthSession = require("expo-auth-session/providers/google") as ExpoAuthSessionModule;
+  isExpoAuthAvailable = true;
+} catch {
+  // expo-auth-session not available - hook will return unavailable state
+}
 
 export interface UseGoogleOAuthResult {
   signInWithGoogle: () => Promise<SocialAuthResult>;
@@ -26,41 +49,113 @@ interface SocialAuthResult {
 
 /**
  * Hook for Google OAuth authentication
+ * Requires expo-auth-session and expo-web-browser to be installed
  */
 export function useGoogleOAuth(config?: GoogleOAuthConfig): UseGoogleOAuthResult {
   const [isLoading, setIsLoading] = useState(false);
   const [googleError, setGoogleError] = useState<string | null>(null);
 
-  const service = new GoogleOAuthService();
+  // Memoize service checks to avoid repeated calls on every render
+  const googleAvailable = useMemo(() => googleOAuthService.isAvailable(), []);
+  const googleConfigured = useMemo(() => googleOAuthService.isConfigured(config), [config]);
 
-  const googleAvailable = service.isAvailable();
-  const googleConfigured = service.isConfigured(config);
+  // Keep config in a ref so the response useEffect doesn't re-run when config object reference changes
+  const configRef = useRef(config);
+  configRef.current = config;
+
+  // Call the Hook directly (only valid in React component)
+  // If expo-auth-session is not available, these will be null
+  // Empty strings are passed when config is missing to preserve hook call order (Rules of Hooks)
+  const [request, response, promptAsync] = isExpoAuthAvailable && ExpoAuthSession
+    ? ExpoAuthSession.useAuthRequest({
+        iosClientId: config?.iosClientId ?? "",
+        webClientId: config?.webClientId ?? "",
+        androidClientId: config?.androidClientId ?? "",
+      })
+    : [null, null, null];
+
+  // Handle OAuth response
+  useEffect(() => {
+    if (!googleAvailable || !response) return;
+
+    const handleResponse = async () => {
+      if (response.type === "success" && response.authentication?.idToken) {
+        setIsLoading(true);
+        setGoogleError(null);
+
+        try {
+          const auth = getFirebaseAuth();
+          if (!auth) {
+            setGoogleError("Firebase Auth not initialized");
+            setIsLoading(false);
+            return;
+          }
+
+          await googleOAuthService.signInWithOAuth(
+            auth,
+            configRef.current,
+            async () => response
+          );
+        } catch (error) {
+          setGoogleError(
+            error instanceof Error ? error.message : "Firebase sign-in failed"
+          );
+        } finally {
+          setIsLoading(false);
+        }
+      } else if (response.type === "error") {
+        setGoogleError("Google authentication failed");
+      }
+    };
+
+    // Call async function and catch errors separately
+    handleResponse().catch((err) => {
+      // Errors are already handled in handleResponse
+      if (__DEV__) {
+        console.error('[useGoogleOAuth] Unexpected error in handleResponse:', err);
+      }
+    });
+  }, [response, googleAvailable]); // config read via ref to prevent re-running on reference changes
 
   const signInWithGoogle = useCallback(async (): Promise<SocialAuthResult> => {
+    if (!googleAvailable) {
+      const error = "expo-auth-session is not available. Please install expo-auth-session and expo-web-browser.";
+      setGoogleError(error);
+      return { success: false, error };
+    }
+
+    if (!googleConfigured) {
+      const error = "Google Sign-In is not configured. Please provide valid client IDs.";
+      setGoogleError(error);
+      return { success: false, error };
+    }
+
+    if (!request || !promptAsync) {
+      const error = "Google Sign-In not ready";
+      setGoogleError(error);
+      return { success: false, error };
+    }
+
     setIsLoading(true);
     setGoogleError(null);
 
     try {
       const auth = getFirebaseAuth();
-      const result = await service.signInWithOAuth(auth, config);
-
-      if (!result.success) {
-        setGoogleError(result.error || 'Google sign-in failed');
-        return { success: false, error: result.error };
+      if (!auth) {
+        const error = "Firebase Auth not initialized";
+        setGoogleError(error);
+        return { success: false, error };
       }
 
-      return {
-        success: true,
-        isNewUser: result.isNewUser,
-      };
+      return await googleOAuthService.signInWithOAuth(auth, config, promptAsync);
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      const errorMessage = error instanceof Error ? error.message : "Google sign-in failed";
       setGoogleError(errorMessage);
       return { success: false, error: errorMessage };
     } finally {
       setIsLoading(false);
     }
-  }, [service, config]);
+  }, [googleAvailable, googleConfigured, request, promptAsync]); // config read via ref to prevent re-creation on reference changes
 
   return {
     signInWithGoogle,

package/src/domains/firestore/domain/constants/QuotaLimits.ts

@@ -0,0 +1,101 @@
+/**
+ * Quota Limit Constants
+ * Domain layer - Default Firestore quota limits
+ *
+ * General-purpose constants for any app using Firestore
+ * Based on Firestore free tier and pricing documentation
+ */
+
+import { calculatePercentage, calculateRemaining } from '../../../../shared/domain/utils/calculation.util';
+
+/**
+ * Firestore free tier daily limits
+ * https://firebase.google.com/docs/firestore/quotas
+ */
+export const FREE_TIER_LIMITS = {
+  /**
+   * Daily read operations (documents)
+   * Free tier: 50,000 reads/day
+   */
+  DAILY_READS: 50_000,
+
+  /**
+   * Daily write operations (documents)
+   * Free tier: 20,000 writes/day
+   */
+  DAILY_WRITES: 20_000,
+
+  /**
+   * Daily delete operations (documents)
+   * Free tier: 20,000 deletes/day
+   */
+  DAILY_DELETES: 20_000,
+
+  /**
+   * Stored data (GB)
+   * Free tier: 1 GB
+   */
+  STORAGE_GB: 1,
+} as const;
+
+/**
+ * Quota warning thresholds (percentage of limit)
+ * Apps can use these to show warnings before hitting limits
+ */
+export const QUOTA_THRESHOLDS = {
+  /**
+   * Warning threshold (80% of limit)
+   * Show warning to user
+   */
+  WARNING: 0.8,
+
+  /**
+   * Critical threshold (95% of limit)
+   * Show critical alert, consider disabling features
+   */
+  CRITICAL: 0.95,
+
+  /**
+   * Emergency threshold (98% of limit)
+   * Disable non-essential features
+   */
+  EMERGENCY: 0.98,
+} as const;
+
+/**
+ * Calculate quota usage percentage
+ * Optimized: Uses centralized calculation utility
+ * @param current - Current usage count
+ * @param limit - Total limit
+ * @returns Percentage (0-1)
+ */
+export function calculateQuotaUsage(current: number, limit: number): number {
+  return calculatePercentage(current, limit);
+}
+
+/**
+ * Check if quota threshold is reached
+ * @param current - Current usage count
+ * @param limit - Total limit
+ * @param threshold - Threshold to check (0-1)
+ * @returns true if threshold is reached
+ */
+export function isQuotaThresholdReached(
+  current: number,
+  limit: number,
+  threshold: number,
+): boolean {
+  const usage = calculateQuotaUsage(current, limit);
+  return usage >= threshold;
+}
+
+/**
+ * Get remaining quota
+ * Optimized: Uses centralized calculation utility
+ * @param current - Current usage count
+ * @param limit - Total limit
+ * @returns Remaining quota count
+ */
+export function getRemainingQuota(current: number, limit: number): number {
+  return calculateRemaining(current, limit);
+}

package/src/domains/firestore/domain/entities/QuotaMetrics.ts

@@ -0,0 +1,26 @@
+/**
+ * Quota Metrics Types
+ */
+
+export interface QuotaMetrics {
+    readCount: number;
+    writeCount: number;
+    deleteCount: number;
+    lastResetDate: string;
+}
+
+export interface QuotaLimits {
+    dailyReadLimit: number;
+    dailyWriteLimit: number;
+    dailyDeleteLimit: number;
+}
+
+export interface QuotaStatus {
+    metrics: QuotaMetrics;
+    limits: QuotaLimits;
+    readPercentage: number;
+    writePercentage: number;
+    deletePercentage: number;
+    isNearLimit: boolean;
+    isOverLimit: boolean;
+}

package/src/domains/firestore/domain/entities/RequestLog.ts

@@ -0,0 +1,28 @@
+/**
+ * Request Log Types
+ */
+
+export type RequestType = 'read' | 'write' | 'delete' | 'listener';
+
+export interface RequestLog {
+    id: string;
+    type: RequestType;
+    collection: string;
+    documentId?: string;
+    cached: boolean;
+    success: boolean;
+    error?: string;
+    duration?: number;
+    timestamp: number;
+}
+
+export interface RequestStats {
+    totalRequests: number;
+    readRequests: number;
+    writeRequests: number;
+    deleteRequests: number;
+    listenerRequests: number;
+    cachedRequests: number;
+    failedRequests: number;
+    averageDuration: number;
+}

package/src/domains/firestore/domain/services/QuotaCalculator.ts

@@ -0,0 +1,71 @@
+/**
+ * Quota Calculator Service
+ * Domain service for calculating quota usage and status
+ */
+
+import type { QuotaMetrics, QuotaLimits, QuotaStatus } from '../entities/QuotaMetrics';
+import { FREE_TIER_LIMITS, QUOTA_THRESHOLDS, calculateQuotaUsage } from '../constants/QuotaLimits';
+
+/**
+ * Default quota limits (Firebase Spark Plan)
+ * Can be overridden via configuration
+ */
+const DEFAULT_QUOTA_LIMITS: QuotaLimits = {
+  dailyReadLimit: FREE_TIER_LIMITS.DAILY_READS,
+  dailyWriteLimit: FREE_TIER_LIMITS.DAILY_WRITES,
+  dailyDeleteLimit: FREE_TIER_LIMITS.DAILY_DELETES,
+};
+
+export class QuotaCalculator {
+  /**
+   * Calculate quota status from metrics and limits
+   */
+  static calculateStatus(
+    metrics: QuotaMetrics,
+    limits: QuotaLimits = DEFAULT_QUOTA_LIMITS,
+  ): QuotaStatus {
+    const readPercentage = calculateQuotaUsage(metrics.readCount, limits.dailyReadLimit) * 100;
+    const writePercentage = calculateQuotaUsage(metrics.writeCount, limits.dailyWriteLimit) * 100;
+    const deletePercentage = calculateQuotaUsage(metrics.deleteCount, limits.dailyDeleteLimit) * 100;
+
+    const warningThreshold = QUOTA_THRESHOLDS.WARNING * 100;
+    const isNearLimit =
+      readPercentage >= warningThreshold ||
+      writePercentage >= warningThreshold ||
+      deletePercentage >= warningThreshold;
+
+    const isOverLimit =
+      readPercentage >= 100 ||
+      writePercentage >= 100 ||
+      deletePercentage >= 100;
+
+    return {
+      metrics,
+      limits,
+      readPercentage,
+      writePercentage,
+      deletePercentage,
+      isNearLimit,
+      isOverLimit,
+    };
+  }
+
+  /**
+   * Get default quota limits
+   */
+  static getDefaultLimits(): QuotaLimits {
+    return { ...DEFAULT_QUOTA_LIMITS };
+  }
+
+  /**
+   * Check if metrics are within limits
+   */
+  static isWithinLimits(
+    metrics: QuotaMetrics,
+    limits: QuotaLimits = DEFAULT_QUOTA_LIMITS,
+  ): boolean {
+    const status = this.calculateStatus(metrics, limits);
+    return !status.isOverLimit;
+  }
+}
+