@umituz/react-native-firebase 1.13.2 → 1.13.4

package/src/auth/presentation/hooks/useAnonymousAuth.ts

@@ -0,0 +1,201 @@
+/**
+ * useAnonymousAuth Hook
+ * React hook for anonymous authentication state
+ */
+
+import { useState, useEffect, useCallback, useRef } from "react";
+import { onAuthStateChanged, type Auth } from "firebase/auth";
+import { checkAuthState, type AuthCheckResult } from "../../infrastructure/services/auth-utils.service";
+import { anonymousAuthService, type AnonymousAuthResult } from "../../infrastructure/services/anonymous-auth.service";
+
+declare const __DEV__: boolean;
+
+export interface UseAnonymousAuthResult extends AuthCheckResult {
+  /**
+   * Sign in anonymously
+   */
+  signInAnonymously: () => Promise<AnonymousAuthResult>;
+
+  /**
+   * Loading state
+   */
+  readonly loading: boolean;
+
+  /**
+   * Error state
+   */
+  readonly error: Error | null;
+
+  /**
+   * Clear error
+   */
+  clearError: () => void;
+}
+
+/**
+ * Hook for anonymous authentication
+ */
+export function useAnonymousAuth(auth: Auth | null): UseAnonymousAuthResult {
+  const [authState, setAuthState] = useState<AuthCheckResult>(() =>
+    checkAuthState(auth),
+  );
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+  const authRef = useRef(auth);
+  const unsubscribeRef = useRef<(() => void) | null>(null);
+
+  // Update ref when auth changes
+  useEffect(() => {
+    authRef.current = auth;
+  }, [auth]);
+
+  // Clear error helper
+  const clearError = useCallback(() => {
+    setError(null);
+  }, []);
+
+  // Auth state change handler - accepts user from onAuthStateChanged callback
+  const handleAuthStateChange = useCallback((user: import("firebase/auth").User | null) => {
+    try {
+      // Use the user from the callback, NOT auth.currentUser
+      // This ensures we have the correct user from Firebase's persistence
+      if (!user) {
+        setAuthState({
+          isAuthenticated: false,
+          isAnonymous: false,
+          isGuest: false,
+          currentUser: null,
+          userId: null,
+        });
+      } else {
+        const anonymous = user.isAnonymous === true;
+        setAuthState({
+          isAuthenticated: true,
+          isAnonymous: anonymous,
+          isGuest: anonymous,
+          currentUser: user,
+          userId: user.uid,
+        });
+      }
+      setError(null);
+    } catch (err) {
+      const authError = err instanceof Error ? err : new Error('Auth state check failed');
+      setError(authError);
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.error("[useAnonymousAuth] Auth state change error", authError);
+      }
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  // Setup auth state listener
+  // IMPORTANT: Do NOT call handleAuthStateChange() immediately!
+  // Wait for onAuthStateChanged to fire - it will have the correct user from persistence
+  useEffect(() => {
+    // Cleanup previous listener
+    if (unsubscribeRef.current) {
+      unsubscribeRef.current();
+      unsubscribeRef.current = null;
+    }
+
+    if (!auth) {
+      setAuthState({
+        isAuthenticated: false,
+        isAnonymous: false,
+        isGuest: false,
+        currentUser: null,
+        userId: null,
+      });
+      setLoading(false);
+      setError(null);
+      return;
+    }
+
+    // Keep loading true until onAuthStateChanged fires
+    setLoading(true);
+
+    try {
+      // Listen to auth state changes - this is the ONLY source of truth
+      // The first callback will have the user restored from persistence (or null)
+      unsubscribeRef.current = onAuthStateChanged(auth, (user) => {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          // eslint-disable-next-line no-console
+          console.log("[useAnonymousAuth] onAuthStateChanged fired", {
+            hasUser: !!user,
+            uid: user?.uid,
+            isAnonymous: user?.isAnonymous,
+            email: user?.email,
+          });
+        }
+        // IMPORTANT: Pass the user from the callback, not auth.currentUser!
+        handleAuthStateChange(user);
+      });
+    } catch (err) {
+      const authError = err instanceof Error ? err : new Error('Auth listener setup failed');
+      setError(authError);
+      setLoading(false);
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.error("[useAnonymousAuth] Auth listener setup error", authError);
+      }
+    }
+
+    // Cleanup function
+    return () => {
+      if (unsubscribeRef.current) {
+        unsubscribeRef.current();
+        unsubscribeRef.current = null;
+      }
+    };
+  }, [auth, handleAuthStateChange]);
+
+  // Sign in anonymously
+  const signInAnonymously = useCallback(async (): Promise<AnonymousAuthResult> => {
+    if (!auth) {
+      const authError = new Error("Firebase Auth not initialized");
+      setError(authError);
+      throw authError;
+    }
+
+    setLoading(true);
+    setError(null);
+
+    try {
+      const result = await anonymousAuthService.signInAnonymously(auth);
+
+      // Update auth state after successful sign in
+      // Pass the user from the result, not from auth.currentUser
+      handleAuthStateChange(result.user);
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.log("[useAnonymousAuth] Successfully signed in anonymously", {
+          uid: result.anonymousUser.uid,
+          wasAlreadySignedIn: result.wasAlreadySignedIn,
+        });
+      }
+
+      return result;
+    } catch (err) {
+      const authError = err instanceof Error ? err : new Error('Anonymous sign in failed');
+      setError(authError);
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.error("[useAnonymousAuth] Sign in error", authError);
+      }
+      throw authError;
+    } finally {
+      setLoading(false);
+    }
+  }, [auth, handleAuthStateChange]);
+
+  return {
+    ...authState,
+    signInAnonymously,
+    loading,
+    error,
+    clearError,
+  };
+}

package/src/auth/presentation/hooks/useFirebaseAuth.ts

@@ -0,0 +1,84 @@
+/**
+ * useFirebaseAuth Hook
+ * React hook for Firebase Auth state management
+ * 
+ * Directly uses Firebase Auth's built-in state management via onAuthStateChanged
+ */
+
+import { useEffect, useState } from "react";
+import { onAuthStateChanged, type User } from "firebase/auth";
+import { getFirebaseAuth, isFirebaseAuthInitialized } from "../../infrastructure/config/FirebaseAuthClient";
+
+export interface UseFirebaseAuthResult {
+  /** Current authenticated user from Firebase Auth */
+  user: User | null;
+  /** Whether auth state is loading (initial check) */
+  loading: boolean;
+  /** Whether Firebase Auth is initialized */
+  initialized: boolean;
+}
+
+/**
+ * Hook for Firebase Auth state management
+ * 
+ * Directly uses Firebase Auth's built-in state management.
+ * No additional state management layer needed.
+ * 
+ * @example
+ * ```typescript
+ * const { user, loading } = useFirebaseAuth();
+ * ```
+ */
+export function useFirebaseAuth(): UseFirebaseAuthResult {
+  const [user, setUser] = useState<User | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [initialized, setInitialized] = useState(false);
+
+  useEffect(() => {
+    // Check if Firebase Auth is initialized
+    const isInitialized = isFirebaseAuthInitialized();
+    setInitialized(isInitialized);
+
+    if (!isInitialized) {
+      setLoading(false);
+      setUser(null);
+      return;
+    }
+
+    try {
+      const auth = getFirebaseAuth();
+      
+      if (!auth) {
+        setUser(null);
+        setLoading(false);
+        return;
+      }
+      
+      // Subscribe to auth state changes
+      const unsubscribe = onAuthStateChanged(auth, (currentUser: User | null) => {
+        setUser(currentUser);
+        setLoading(false);
+      });
+
+      // Set initial state
+      setUser(auth.currentUser);
+      setLoading(false);
+
+      return () => {
+        unsubscribe();
+      };
+    } catch (error) {
+      // Firebase Auth not initialized or error
+      setUser(null);
+      setLoading(false);
+      return () => {};
+    }
+  }, []);
+
+  return {
+    user,
+    loading,
+    initialized,
+  };
+}
+

package/src/auth/presentation/hooks/useSocialAuth.ts

@@ -0,0 +1,162 @@
+/**
+ * useSocialAuth Hook
+ * Provides Google and Apple Sign-In functionality
+ *
+ * Note: This hook handles the Firebase authentication part.
+ * The OAuth flow (expo-auth-session for Google) should be set up in the consuming app.
+ */
+
+import { useState, useCallback, useEffect } from "react";
+import { getFirebaseAuth } from "../../infrastructure/config/FirebaseAuthClient";
+import {
+  googleAuthService,
+  type GoogleAuthConfig,
+} from "../../infrastructure/services/google-auth.service";
+import { appleAuthService } from "../../infrastructure/services/apple-auth.service";
+
+/**
+ * Social auth configuration
+ */
+export interface SocialAuthConfig {
+  google?: GoogleAuthConfig;
+  apple?: { enabled: boolean };
+}
+
+/**
+ * Social auth result
+ */
+export interface SocialAuthResult {
+  success: boolean;
+  isNewUser?: boolean;
+  error?: string;
+}
+
+/**
+ * Hook result
+ */
+export interface UseSocialAuthResult {
+  /** Sign in with Google using ID token (call after OAuth flow) */
+  signInWithGoogleToken: (idToken: string) => Promise<SocialAuthResult>;
+  /** Sign in with Apple (handles full flow) */
+  signInWithApple: () => Promise<SocialAuthResult>;
+  /** Whether Google is loading */
+  googleLoading: boolean;
+  /** Whether Apple is loading */
+  appleLoading: boolean;
+  /** Whether Google is configured */
+  googleConfigured: boolean;
+  /** Whether Apple is available */
+  appleAvailable: boolean;
+}
+
+/**
+ * Hook for social authentication
+ *
+ * Usage:
+ * 1. For Google: Set up expo-auth-session in your app, get idToken, then call signInWithGoogleToken
+ * 2. For Apple: Just call signInWithApple (handles complete flow)
+ */
+export function useSocialAuth(config?: SocialAuthConfig): UseSocialAuthResult {
+  const [googleLoading, setGoogleLoading] = useState(false);
+  const [appleLoading, setAppleLoading] = useState(false);
+  const [appleAvailable, setAppleAvailable] = useState(false);
+
+  // Configure Google Auth
+  const googleConfig = config?.google;
+  const googleConfigured = !!(
+    googleConfig?.webClientId ||
+    googleConfig?.iosClientId ||
+    googleConfig?.androidClientId
+  );
+
+  // Configure Google service on mount
+  useEffect(() => {
+    if (googleConfig) {
+      googleAuthService.configure(googleConfig);
+    }
+  }, [googleConfig]);
+
+  // Check Apple availability on mount
+  useEffect(() => {
+    const checkApple = async () => {
+      const available = await appleAuthService.isAvailable();
+      setAppleAvailable(available && (config?.apple?.enabled ?? false));
+    };
+    checkApple();
+  }, [config?.apple?.enabled]);
+
+  // Sign in with Google using ID token
+  const signInWithGoogleToken = useCallback(
+    async (idToken: string): Promise<SocialAuthResult> => {
+      if (!googleConfigured) {
+        return { success: false, error: "Google Sign-In is not configured" };
+      }
+
+      setGoogleLoading(true);
+      try {
+        const auth = getFirebaseAuth();
+        if (!auth) {
+          return { success: false, error: "Firebase Auth not initialized" };
+        }
+
+        const signInResult = await googleAuthService.signInWithIdToken(
+          auth,
+          idToken,
+        );
+
+        return {
+          success: signInResult.success,
+          isNewUser: signInResult.isNewUser,
+          error: signInResult.error,
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : "Google sign-in failed",
+        };
+      } finally {
+        setGoogleLoading(false);
+      }
+    },
+    [googleConfigured],
+  );
+
+  // Sign in with Apple
+  const signInWithApple = useCallback(async (): Promise<SocialAuthResult> => {
+    if (!appleAvailable) {
+      return { success: false, error: "Apple Sign-In is not available" };
+    }
+
+    setAppleLoading(true);
+    try {
+      const auth = getFirebaseAuth();
+      if (!auth) {
+        return { success: false, error: "Firebase Auth not initialized" };
+      }
+
+      const result = await appleAuthService.signIn(auth);
+
+      return {
+        success: result.success,
+        isNewUser: result.isNewUser,
+        error: result.error,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Apple sign-in failed",
+      };
+    } finally {
+      setAppleLoading(false);
+    }
+  }, [appleAvailable]);
+
+  return {
+    signInWithGoogleToken,
+    signInWithApple,
+    googleLoading,
+    appleLoading,
+    googleConfigured,
+    appleAvailable,
+  };
+}

package/src/firestore/__tests__/BaseRepository.test.ts

@@ -0,0 +1,133 @@
+/**
+ * Tests for BaseRepository
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import { BaseRepository } from '../infrastructure/repositories/BaseRepository';
+import { getFirestore, resetFirestoreClient } from '../infrastructure/config/FirestoreClient';
+
+// Mock Firestore client
+jest.mock('../infrastructure/config/FirestoreClient', () => ({
+  getFirestore: jest.fn(),
+  resetFirestoreClient: jest.fn(),
+}));
+
+const mockGetFirestore = getFirestore as jest.MockedFunction<typeof getFirestore>;
+const mockResetFirestoreClient = resetFirestoreClient as jest.MockedFunction<typeof resetFirestoreClient>;
+
+describe('BaseRepository', () => {
+  let repository: BaseRepository;
+
+  beforeEach(() => {
+    repository = new BaseRepository();
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    repository.destroy();
+  });
+
+  describe('getDb', () => {
+    it('should return Firestore instance when available', () => {
+      const mockFirestore = {} as any;
+      mockGetFirestore.mockReturnValue(mockFirestore);
+
+      const result = repository.getDb();
+      expect(result).toBe(mockFirestore);
+    });
+
+    it('should return null when Firestore is not available', () => {
+      mockGetFirestore.mockReturnValue(null);
+
+      const result = repository.getDb();
+      expect(result).toBeNull();
+    });
+
+    it('should return null when repository is destroyed', () => {
+      repository.destroy();
+      const result = repository.getDb();
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('getDbOrThrow', () => {
+    it('should return Firestore instance when available', () => {
+      const mockFirestore = {} as any;
+      mockGetFirestore.mockReturnValue(mockFirestore);
+
+      const result = repository.getDbOrThrow();
+      expect(result).toBe(mockFirestore);
+    });
+
+    it('should throw error when Firestore is not available', () => {
+      mockGetFirestore.mockReturnValue(null);
+
+      expect(() => repository.getDbOrThrow()).toThrow(
+        'Firestore is not initialized. Please initialize Firebase App first.'
+      );
+    });
+  });
+
+  describe('isDbInitialized', () => {
+    it('should return true when Firestore is available', () => {
+      mockGetFirestore.mockReturnValue({} as any);
+
+      const result = repository.isDbInitialized();
+      expect(result).toBe(true);
+    });
+
+    it('should return false when Firestore is not available', () => {
+      mockGetFirestore.mockReturnValue(null);
+
+      const result = repository.isDbInitialized();
+      expect(result).toBe(false);
+    });
+
+    it('should return false when getFirestore throws', () => {
+      mockGetFirestore.mockImplementation(() => {
+        throw new Error('Test error');
+      });
+
+      const result = repository.isDbInitialized();
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('executeWithQuotaHandling', () => {
+    it('should execute operation successfully', async () => {
+      const mockOperation = jest.fn().mockResolvedValue('success');
+      const result = await repository.executeWithQuotaHandling(mockOperation);
+      expect(result).toBe('success');
+      expect(mockOperation).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle quota errors', async () => {
+      const quotaError = new Error('Quota exceeded');
+      const mockOperation = jest.fn().mockRejectedValue(quotaError);
+      
+      // Mock quota error detection
+      jest.spyOn(repository, 'isQuotaError').mockReturnValue(true);
+      jest.spyOn(repository, 'handleQuotaError').mockImplementation(() => {
+        throw new Error('Quota error handled');
+      });
+
+      await expect(repository.executeWithQuotaHandling(mockOperation)).rejects.toThrow('Quota error handled');
+    });
+
+    it('should re-throw non-quota errors', async () => {
+      const regularError = new Error('Regular error');
+      const mockOperation = jest.fn().mockRejectedValue(regularError);
+      
+      jest.spyOn(repository, 'isQuotaError').mockReturnValue(false);
+
+      await expect(repository.executeWithQuotaHandling(mockOperation)).rejects.toThrow('Regular error');
+    });
+  });
+
+  describe('destroy', () => {
+    it('should mark repository as destroyed', () => {
+      repository.destroy();
+      expect(repository.getDb()).toBeNull();
+    });
+  });
+});