@umituz/react-native-firebase 1.13.54 → 1.13.56

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "1.13.54",
+  "version": "1.13.56",
   "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/presentation/hooks/useAnonymousAuth.ts

@@ -4,9 +4,10 @@
  */
 
 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 { onAuthStateChanged, type Auth, type User } from "firebase/auth";
+import type { AuthCheckResult } from "../../infrastructure/services/auth-utils.service";
 import { anonymousAuthService, type AnonymousAuthResult } from "../../infrastructure/services/anonymous-auth.service";
+import { createAuthStateChangeHandler, userToAuthCheckResult } from "./utils/auth-state-change.handler";
 
 declare const __DEV__: boolean;
 
@@ -36,61 +37,32 @@ export interface UseAnonymousAuthResult extends AuthCheckResult {
  * Hook for anonymous authentication
  */
 export function useAnonymousAuth(auth: Auth | null): UseAnonymousAuthResult {
-  const [authState, setAuthState] = useState<AuthCheckResult>(() =>
-    checkAuthState(auth),
-  );
+  const [authState, setAuthState] = useState<AuthCheckResult>({
+    isAuthenticated: false,
+    isAnonymous: false,
+    currentUser: null,
+    userId: null,
+  });
   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,
-          currentUser: null,
-          userId: null,
-        });
-      } else {
-        const anonymous = user.isAnonymous === true;
-        setAuthState({
-          isAuthenticated: true,
-          isAnonymous: 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);
-    }
-  }, []);
+  // Auth state change handler
+  const handleAuthStateChange = useCallback((user: User | null) => {
+    const handler = createAuthStateChangeHandler({
+      setAuthState,
+      setLoading,
+      setError,
+    });
+    handler(user);
+  }, [setAuthState, setLoading, setError]);
 
   // 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) {
@@ -99,12 +71,7 @@ export function useAnonymousAuth(auth: Auth | null): UseAnonymousAuthResult {
     }
 
     if (!auth) {
-      setAuthState({
-        isAuthenticated: false,
-        isAnonymous: false,
-        currentUser: null,
-        userId: null,
-      });
+      setAuthState(userToAuthCheckResult(null));
       setLoading(false);
       setError(null);
       return;
@@ -114,10 +81,9 @@ export function useAnonymousAuth(auth: Auth | null): UseAnonymousAuthResult {
     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)
+      // Listen to auth state changes
       unsubscribeRef.current = onAuthStateChanged(auth, (user) => {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
+        if (__DEV__) {
           // eslint-disable-next-line no-console
           console.log("[useAnonymousAuth] onAuthStateChanged fired", {
             hasUser: !!user,
@@ -126,14 +92,13 @@ export function useAnonymousAuth(auth: Auth | null): UseAnonymousAuthResult {
             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__) {
+      if (__DEV__) {
         // eslint-disable-next-line no-console
         console.error("[useAnonymousAuth] Auth listener setup error", authError);
       }
@@ -161,12 +126,9 @@ export function useAnonymousAuth(auth: Auth | null): UseAnonymousAuthResult {
 
     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__) {
+      if (__DEV__) {
         // eslint-disable-next-line no-console
         console.log("[useAnonymousAuth] Successfully signed in anonymously", {
           uid: result.anonymousUser.uid,
@@ -178,7 +140,7 @@ export function useAnonymousAuth(auth: Auth | null): UseAnonymousAuthResult {
     } catch (err) {
       const authError = err instanceof Error ? err : new Error('Anonymous sign in failed');
       setError(authError);
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
+      if (__DEV__) {
         // eslint-disable-next-line no-console
         console.error("[useAnonymousAuth] Sign in error", authError);
       }

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

@@ -0,0 +1,74 @@
+/**
+ * Auth State Change Handler
+ * Single Responsibility: Handle authentication state changes
+ */
+
+import type { User } from 'firebase/auth';
+import type { AuthCheckResult } from '../../../infrastructure/services/auth-utils.service';
+
+declare const __DEV__: boolean;
+
+/**
+ * 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,
+  };
+}
+
+/**
+ * Create auth state change handler callback
+ * Returns a function that can be used with onAuthStateChanged
+ *
+ * @param setAuthState - State setter for auth state
+ * @param setLoading - State setter for loading
+ * @param setError - State setter for errors
+ * @returns Callback function for auth state changes
+ */
+export type AuthStateChangeHandler = (user: User | null) => void;
+
+export interface CreateAuthStateChangeHandlerParams {
+  setAuthState: (state: AuthCheckResult) => void;
+  setLoading: (loading: boolean) => void;
+  setError: (error: Error | null) => void;
+}
+
+export function createAuthStateChangeHandler(
+  params: CreateAuthStateChangeHandlerParams
+): AuthStateChangeHandler {
+  const { setAuthState, setLoading, setError } = params;
+
+  return (user: User | null) => {
+    try {
+      const authState = userToAuthCheckResult(user);
+      setAuthState(authState);
+      setError(null);
+    } catch (err) {
+      const authError =
+        err instanceof Error ? err : new Error('Auth state check failed');
+      setError(authError);
+
+      if (__DEV__) {
+        // eslint-disable-next-line no-console
+        console.error('[AuthStateHandler] Auth state change error', authError);
+      }
+    } finally {
+      setLoading(false);
+    }
+  };
+}

package/src/firestore/infrastructure/config/FirestoreClient.ts

@@ -6,11 +6,6 @@
  *
  * IMPORTANT: This package requires Firebase App to be initialized first.
  * Use @umituz/react-native-firebase to initialize Firebase App.
- *
- * SOLID Principles:
- * - Single Responsibility: Only manages Firestore initialization
- * - Open/Closed: Extensible through configuration, closed for modification
- * - Dependency Inversion: Depends on Firebase App from @umituz/react-native-firebase
  */
 
 // eslint-disable-next-line no-console
@@ -29,13 +24,8 @@ class FirestoreClientSingleton {
   private firestore: Firestore | null = null;
   private initializationError: string | null = null;
 
-  private constructor() {
-    // Private constructor to enforce singleton pattern
-  }
+  private constructor() {}
 
-  /**
-   * Get singleton instance
-   */
   static getInstance(): FirestoreClientSingleton {
     if (!FirestoreClientSingleton.instance) {
       FirestoreClientSingleton.instance = new FirestoreClientSingleton();
@@ -43,26 +33,13 @@ class FirestoreClientSingleton {
     return FirestoreClientSingleton.instance;
   }
 
-  /**
-   * Initialize Firestore
-   * Requires Firebase App to be initialized first via @umituz/react-native-firebase
-   *
-   * @returns Firestore instance or null if initialization fails
-   */
   initialize(): Firestore | null {
-    if (this.firestore) {
-      return this.firestore;
-    }
-    if (this.initializationError) {
-      return null;
-    }
-    try {
-      const app = getFirebaseApp(); // Get the core Firebase App
+    if (this.firestore) return this.firestore;
+    if (this.initializationError) return null;
 
-      // Return null if Firebase App is not available (offline mode)
-      if (!app) {
-        return null;
-      }
+    try {
+      const app = getFirebaseApp();
+      if (!app) return null;
 
       this.firestore = FirebaseFirestoreInitializer.initialize(app);
       return this.firestore;
@@ -75,61 +52,22 @@ class FirestoreClientSingleton {
     }
   }
 
-  /**
-   * Get Firestore instance
-   * Auto-initializes if Firebase App is available
-   * Returns null if config is not available (offline mode - no error)
-   * @returns Firestore instance or null if not initialized
-   */
   getFirestore(): Firestore | null {
-    // Auto-initialize if not already initialized
     if (!this.firestore && !this.initializationError) {
-      try {
-        // Try to get Firebase App (will auto-initialize if config is available)
-        const app = getFirebaseApp();
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          // eslint-disable-next-line no-console
-          console.log("[FirestoreClient] getFirestore - app:", !!app);
-        }
-        if (app) {
-          this.initialize();
-        }
-      } catch (e) {
-        // Firebase App not available, return null (offline mode)
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          // eslint-disable-next-line no-console
-          console.log("[FirestoreClient] getFirestore error:", e);
-        }
-        return null;
-      }
-    }
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[FirestoreClient] returning firestore:", !!this.firestore, "constructor:", this.firestore?.constructor?.name);
+      const app = getFirebaseApp();
+      if (app) this.initialize();
     }
-    // Return null if not initialized (offline mode - no error)
     return this.firestore || null;
   }
 
-  /**
-   * Check if Firestore is initialized
-   */
   isInitialized(): boolean {
     return this.firestore !== null;
   }
 
-  /**
-   * Get initialization error if any
-   */
   getInitializationError(): string | null {
     return this.initializationError;
   }
 
-  /**
-   * Reset Firestore client instance
-   * Useful for testing
-   */
   reset(): void {
     this.firestore = null;
     this.initializationError = null;
@@ -138,56 +76,22 @@ class FirestoreClientSingleton {
 
 export const firestoreClient = FirestoreClientSingleton.getInstance();
 
-/**
- * Initialize Firestore
- * Requires Firebase App to be initialized first via @umituz/react-native-firebase
- *
- * @returns Firestore instance or null if initialization fails
- *
- * @example
- * ```typescript
- * import { initializeFirebase } from '@umituz/react-native-firebase';
- * import { initializeFirestore } from '@umituz/react-native-firestore';
- *
- * // Initialize Firebase App first
- * const app = initializeFirebase(config);
- *
- * // Then initialize Firestore
- * const db = initializeFirestore();
- * ```
- */
 export function initializeFirestore(): Firestore | null {
   return firestoreClient.initialize();
 }
 
-/**
- * Get Firestore instance
- * Auto-initializes if Firebase App is available
- * Returns null if config is not available (offline mode - no error)
- * @returns Firestore instance or null if not initialized
- */
 export function getFirestore(): Firestore | null {
   return firestoreClient.getFirestore();
 }
 
-/**
- * Check if Firestore is initialized
- */
 export function isFirestoreInitialized(): boolean {
   return firestoreClient.isInitialized();
 }
 
-/**
- * Get Firestore initialization error if any
- */
 export function getFirestoreInitializationError(): string | null {
   return firestoreClient.getInitializationError();
 }
 
-/**
- * Reset Firestore client instance
- * Useful for testing
- */
 export function resetFirestoreClient(): void {
   firestoreClient.reset();
 }

package/src/firestore/utils/query-builder.ts

@@ -1,19 +1,6 @@
 /**
  * Query Builder Utility
  * Single Responsibility: Build Firestore queries with advanced filtering
- *
- * App-agnostic utility for building Firestore queries.
- * Supports:
- * - Firestore 'in' operator (up to 10 values)
- * - Firestore 'or' operator (for >10 values via chunking)
- * - Single value filtering
- * - Multiple field filtering
- * - Date range filtering
- * - Sorting
- * - Limiting
- *
- * This utility is designed to be used across hundreds of apps.
- * It provides a consistent interface for Firestore query building.
  */
 
 import {
@@ -49,97 +36,58 @@ export interface QueryBuilderOptions {
     order?: "asc" | "desc";
   };
   limitValue?: number;
-  /**
-   * Cursor value for pagination (timestamp in milliseconds)
-   * Used with startAfter for cursor-based pagination
-   */
   cursorValue?: number;
 }
 
 const MAX_IN_OPERATOR_VALUES = 10;
 
 /**
- * Build Firestore query with advanced filtering support
- *
- * @param db - Firestore database instance
- * @param options - Query builder options
- * @returns Firestore Query object
+ * Apply date range filters to query
  */
-export function buildQuery(
-  db: Firestore,
-  options: QueryBuilderOptions,
-): Query {
-  const {
-    collectionName,
-    baseFilters = [],
-    dateRange,
-    sort,
-    limitValue,
-    cursorValue,
-  } = options;
-
-  const collectionRef = collection(db, collectionName);
-  let q: Query = collectionRef;
-
-  // Apply base filters
-  for (const filter of baseFilters) {
-    q = applyFieldFilter(q, filter);
-  }
+function applyDateRange(q: Query, dateRange: QueryBuilderOptions['dateRange']): Query {
+  if (!dateRange) return q;
 
-  // Apply date range filters
-  if (dateRange) {
-    if (dateRange.startDate) {
-      q = query(
-        q,
-        where(
-          dateRange.field,
-          ">=",
-          Timestamp.fromMillis(dateRange.startDate),
-        ),
-      );
-    }
-    if (dateRange.endDate) {
-      q = query(
-        q,
-        where(
-          dateRange.field,
-          "<=",
-          Timestamp.fromMillis(dateRange.endDate),
-        ),
-      );
-    }
+  if (dateRange.startDate) {
+    q = query(q, where(dateRange.field, ">=", Timestamp.fromMillis(dateRange.startDate)));
   }
-
-  // Apply sorting
-  if (sort) {
-    const sortOrder = sort.order || "desc";
-    q = query(q, orderBy(sort.field, sortOrder));
+  if (dateRange.endDate) {
+    q = query(q, where(dateRange.field, "<=", Timestamp.fromMillis(dateRange.endDate)));
   }
+  return q;
+}
 
-  // Apply cursor for pagination (must come after orderBy)
-  if (cursorValue !== undefined) {
-    q = query(q, startAfter(Timestamp.fromMillis(cursorValue)));
-  }
+/**
+ * Apply sorting to query
+ */
+function applySort(q: Query, sort?: QueryBuilderOptions['sort']): Query {
+  if (!sort) return q;
+  const sortOrder = sort.order || "desc";
+  return query(q, orderBy(sort.field, sortOrder));
+}
 
-  // Apply limit
-  if (limitValue !== undefined) {
-    q = query(q, limitQuery(limitValue));
-  }
+/**
+ * Apply cursor for pagination
+ */
+function applyCursor(q: Query, cursorValue?: number): Query {
+  if (cursorValue === undefined) return q;
+  return query(q, startAfter(Timestamp.fromMillis(cursorValue)));
+}
 
-  return q;
+/**
+ * Apply limit to query
+ */
+function applyLimit(q: Query, limitValue?: number): Query {
+  if (limitValue === undefined) return q;
+  return query(q, limitQuery(limitValue));
 }
 
 /**
- * Apply field filter with support for 'in' operator and chunking
- * Handles arrays by using 'in' operator (up to 10 values)
- * For arrays >10 values, splits into chunks and uses 'or' operator
+ * Apply field filter with 'in' operator and chunking support
  */
 function applyFieldFilter(q: Query, filter: FieldFilter): Query {
   const { field, operator, value } = filter;
 
-  // Handle 'in' operator with array values
   if (operator === "in" && Array.isArray(value)) {
-    // Firestore 'in' operator supports up to 10 values
     if (value.length <= MAX_IN_OPERATOR_VALUES) {
       return query(q, where(field, "in", value));
     }
@@ -154,35 +102,58 @@ function applyFieldFilter(q: Query, filter: FieldFilter): Query {
     return query(q, or(...orConditions));
   }
 
-  // Standard filter
   return query(q, where(field, operator, value));
 }
 
 /**
- * Helper: Create a field filter for 'in' operator
- * Automatically handles chunking if array >10 values
+ * Build Firestore query with advanced filtering support
+ */
+export function buildQuery(
+  db: Firestore,
+  options: QueryBuilderOptions,
+): Query {
+  const {
+    collectionName,
+    baseFilters = [],
+    dateRange,
+    sort,
+    limitValue,
+    cursorValue,
+  } = options;
+
+  const collectionRef = collection(db, collectionName);
+  let q: Query = collectionRef;
+
+  // Apply base filters
+  for (const filter of baseFilters) {
+    q = applyFieldFilter(q, filter);
+  }
+
+  // Apply modifiers in correct order
+  q = applyDateRange(q, dateRange);
+  q = applySort(q, sort);
+  q = applyCursor(q, cursorValue);
+  q = applyLimit(q, limitValue);
+
+  return q;
+}
+
+/**
+ * Create a field filter for 'in' operator
  */
 export function createInFilter(
   field: string,
   values: string[] | number[],
 ): FieldFilter {
-  return {
-    field,
-    operator: "in",
-    value: values,
-  };
+  return { field, operator: "in", value: values };
 }
 
 /**
- * Helper: Create a field filter for equality
+ * Create a field filter for equality
  */
 export function createEqualFilter(
   field: string,
   value: string | number | boolean,
 ): FieldFilter {
-  return {
-    field,
-    operator: "==",
-    value,
-  };
+  return { field, operator: "==", value };
 }