@umituz/react-native-firebase 1.13.118 → 1.13.120

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "1.13.118",
+  "version": "1.13.120",
   "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/index.ts

@@ -40,6 +40,7 @@ export {
   getCurrentUserId,
   getCurrentUser,
   getCurrentUserIdFromGlobal,
+  getCurrentUserFromGlobal,
   isCurrentUserAuthenticated,
   isCurrentUserAnonymous,
   verifyUserId,

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

@@ -38,7 +38,18 @@ class FirebaseAuthClientSingleton {
   }
 
   getAuth(): Auth | null {
-    if (!this.auth && !this.initializationError && getFirebaseApp()) this.initialize();
+    // Don't retry if we already have an auth instance
+    if (this.auth) return this.auth;
+
+    // Don't retry if we already failed to initialize
+    if (this.initializationError) return null;
+
+    // Don't retry if Firebase app is not available
+    const app = getFirebaseApp();
+    if (!app) return null;
+
+    // Attempt initialization
+    this.initialize();
     return this.auth;
   }
 

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

@@ -31,6 +31,7 @@ export class AppleAuthService {
         return {
           success: false,
           error: "Apple Sign-In is not available on this device",
+          code: "unavailable",
         };
       }
 
@@ -46,7 +47,11 @@ export class AppleAuthService {
       });
 
       if (!appleCredential.identityToken) {
-        return { success: false, error: "No identity token received" };
+        return {
+          success: false,
+          error: "No identity token received",
+          code: "no_token"
+        };
       }
 
       const provider = new OAuthProvider("apple.com");
@@ -67,12 +72,22 @@ export class AppleAuthService {
       };
     } catch (error) {
       if (error instanceof Error && error.message.includes("ERR_CANCELED")) {
-        return { success: false, error: "Apple Sign-In was cancelled" };
+        return {
+          success: false,
+          error: "Apple Sign-In was cancelled",
+          code: "canceled"
+        };
       }
+
       if (__DEV__) console.error('[Firebase Auth] Apple Sign-In failed:', error);
+
+      const errorCode = (error as { code?: string })?.code || 'unknown';
+      const errorMessage = error instanceof Error ? error.message : 'Apple sign-in failed';
+
       return {
         success: false,
-        error: error instanceof Error ? error.message : "Apple sign-in failed",
+        error: errorMessage,
+        code: errorCode,
       };
     }
   }

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

@@ -3,14 +3,29 @@
  * Type definitions for Apple authentication
  */
 
-export interface AppleAuthResult {
-  success: boolean;
-  user: User;
-  credential: AppleAuthCredential;
-  wasAlreadySignedIn: boolean;
-  error?: string;
+import type { UserCredential } from 'firebase/auth';
+
+export interface AppleAuthConfig {
+  clientId?: string;
+  scope?: string;
+  redirectURI?: string;
+  state?: string;
+}
+
+export interface AppleAuthSuccessResult {
+  success: true;
+  userCredential: UserCredential;
+  isNewUser: boolean;
 }
 
+export interface AppleAuthErrorResult {
+  success: false;
+  error: string;
+  code?: string;
+}
+
+export type AppleAuthResult = AppleAuthSuccessResult | AppleAuthErrorResult;
+
 export interface AppleAuthCredential {
   idToken: string;
   rawNonce: string;

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

@@ -4,6 +4,7 @@
  */
 
 import type { User, Auth } from 'firebase/auth';
+import { getFirebaseAuth } from '../config/FirebaseAuthClient';
 
 export interface AuthCheckResult {
   isAuthenticated: boolean;
@@ -67,16 +68,26 @@ export function getCurrentUser(auth: Auth): User | null {
  * Get current user ID from global auth instance
  */
 export function getCurrentUserIdFromGlobal(): string | null {
-  // This would use the global auth instance
-  return null;
+  const auth = getFirebaseAuth();
+
+  if (!auth || !auth.currentUser) {
+    return null;
+  }
+
+  return auth.currentUser.uid;
 }
 
 /**
  * Get current user from global auth instance
  */
 export function getCurrentUserFromGlobal(): User | null {
-  // This would use the global auth instance
-  return null;
+  const auth = getFirebaseAuth();
+
+  if (!auth) {
+    return null;
+  }
+
+  return auth.currentUser;
 }
 
 /**

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

@@ -61,7 +61,13 @@ export function shouldSkipFirestoreQuery(
 
   try {
     if (!auth) {
-      return createResult(true, checkAuthState(null), "no_auth");
+      // Return a default result when no auth instance is available
+      return createResult(true, {
+        isAuthenticated: false,
+        isAnonymous: false,
+        currentUser: null,
+        userId: null,
+      }, "no_auth");
     }
 
     const authState = checkAuthState(auth);
@@ -83,7 +89,13 @@ export function shouldSkipFirestoreQuery(
     if (__DEV__) {
       console.error("[FirestoreUtils] Error checking query", error);
     }
-    return createResult(true, checkAuthState(null), "invalid_options");
+    // Return a default result on error
+    return createResult(true, {
+      isAuthenticated: false,
+      isAnonymous: false,
+      currentUser: null,
+      userId: null,
+    }, "invalid_options");
   }
 }
 

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

@@ -55,9 +55,15 @@ export class GoogleAuthService {
       if (__DEV__) {
         console.error('[Firebase Auth] Google Sign-In failed:', error);
       }
+
+      // Extract error code for better error handling
+      const errorCode = (error as { code?: string })?.code || 'unknown';
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+
       return {
         success: false,
-        error: error instanceof Error ? error.message : "Google sign-in failed",
+        error: errorMessage,
+        code: errorCode,
       };
     }
   }

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

@@ -3,6 +3,8 @@
  * Type definitions for Google authentication
  */
 
+import type { UserCredential } from 'firebase/auth';
+
 export interface GoogleAuthConfig {
   clientId?: string;
   webClientId?: string;
@@ -10,13 +12,20 @@ export interface GoogleAuthConfig {
   androidClientId?: string;
 }
 
-export interface GoogleAuthResult {
-  success: boolean;
-  user: User;
-  credential: GoogleAuthCredential;
-  wasAlreadySignedIn: boolean;
+export interface GoogleAuthSuccessResult {
+  success: true;
+  userCredential: UserCredential;
+  isNewUser: boolean;
+}
+
+export interface GoogleAuthErrorResult {
+  success: false;
+  error: string;
+  code?: string;
 }
 
+export type GoogleAuthResult = GoogleAuthSuccessResult | GoogleAuthErrorResult;
+
 export interface GoogleAuthCredential {
   idToken: string;
   accessToken?: string;

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

@@ -3,25 +3,30 @@
  * Type definitions for reauthentication operations
  */
 
+import type { AuthCredential } from 'firebase/auth';
+
 export interface ReauthenticationCredential {
   provider: 'password' | 'google.com' | 'apple.com';
-  credential: unknown;
+  credential: AuthCredential;
 }
 
 export interface ReauthenticationResult {
   success: boolean;
   error?: {
-    code?: string;
-    message?: string;
+    code: string;
+    message: string;
   };
 }
 
-export type AuthProviderType = 'password' | 'google.com' | 'apple.com';
+export type AuthProviderType = 'anonymous' | 'password' | 'google.com' | 'apple.com' | 'unknown';
 
 export interface ReauthCredentialResult {
   success: boolean;
-  credential?: ReauthenticationCredential;
-  error?: string;
+  credential?: AuthCredential;
+  error?: {
+    code: string;
+    message: string;
+  };
 }
 
 export interface AccountDeletionResult {

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

@@ -40,13 +40,15 @@ export const useFirebaseAuthStore = createStore<AuthState, AuthActions>({
       const state = get();
 
       // Atomic check: both state flag AND in-progress mutex
+      // This prevents multiple simultaneous calls from setting up listeners
       if (state.listenerSetup || unsubscribe || setupInProgress) {
         return;
       }
 
       // Set mutex immediately (synchronous, before any async operation)
+      // This ensures no other call can pass the check above
       setupInProgress = true;
-      set({ listenerSetup: true });
+      set({ listenerSetup: true, loading: true });
 
       try {
         unsubscribe = onAuthStateChanged(auth, (currentUser: User | null) => {
@@ -59,10 +61,14 @@ export const useFirebaseAuthStore = createStore<AuthState, AuthActions>({
 
         // Listener setup complete - keep mutex locked until cleanup
         // (setupInProgress remains true to indicate active listener)
-      } catch {
+      } catch (error) {
         // On error, release the mutex so retry is possible
         setupInProgress = false;
-        set({ listenerSetup: 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/useFirebaseAuth.ts

@@ -37,7 +37,15 @@ export function useFirebaseAuth(): UseFirebaseAuthResult {
     }
 
     setupListener(auth);
-  }, [setupListener]);
+
+    // Cleanup function - called when component unmounts
+    return () => {
+      // Note: We don't call cleanupListener here because the store manages
+      // the shared listener. Multiple components can use this hook simultaneously,
+      // and we want to keep the listener active until all components are unmounted.
+      // The store will handle cleanup when appropriate.
+    };
+  }, [setupListener]); // setupListener is stable from the store
 
   return {
     user,

package/src/firestore/infrastructure/middleware/QueryDeduplicationMiddleware.ts

@@ -94,17 +94,25 @@ export class QueryDeduplicationMiddleware {
   }
 
   /**
-   * Add query to pending list
+   * Add query to pending list with guaranteed cleanup
    */
   private addPendingQuery(key: string, promise: Promise<unknown>): void {
+    // Wrap the promise to ensure cleanup happens regardless of outcome
+    const wrappedPromise = promise
+      .catch((error) => {
+        // Re-throw to maintain original promise behavior
+        throw error;
+      })
+      .finally(() => {
+        // Guaranteed cleanup - runs for both resolve and reject
+        this.pendingQueries.delete(key);
+      });
+
+    // Store the wrapped promise with the finally handler attached
     this.pendingQueries.set(key, {
-      promise,
+      promise: wrappedPromise,
       timestamp: Date.now(),
     });
-
-    promise.finally(() => {
-      this.pendingQueries.delete(key);
-    });
   }
 
   /**

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

@@ -36,27 +36,42 @@ export abstract class BasePaginatedRepository extends BaseQueryRepository {
     const fetchLimit = helper.getFetchLimit(pageLimit);
 
     const collectionRef = collection(db, collectionName);
-    let q = query(
-      collectionRef,
-      orderBy(orderByField, orderDirection),
-      limit(fetchLimit),
-    );
-
+    let q: import("firebase/firestore").Query<DocumentData>;
     let cursorKey = 'start';
+
+    // Handle cursor-based pagination
     if (helper.hasCursor(params) && params?.cursor) {
       cursorKey = params.cursor;
-      const cursorDoc = await getDoc(doc(db, collectionName, params.cursor));
-      if (cursorDoc.exists()) {
-        q = query(
-          collectionRef,
-          orderBy(orderByField, orderDirection),
-          startAfter(cursorDoc),
-          limit(fetchLimit),
-        );
+
+      // Fetch cursor document first
+      const cursorDocRef = doc(db, collectionName, params.cursor);
+      const cursorDoc = await getDoc(cursorDocRef);
+
+      if (!cursorDoc.exists()) {
+        // Cursor document doesn't exist - return empty result
+        if (__DEV__) {
+          console.warn(`[BasePaginatedRepository] Cursor document not found: ${params.cursor}`);
+        }
+        return [];
       }
+
+      // Build query with startAfter using the cursor document
+      q = query(
+        collectionRef,
+        orderBy(orderByField, orderDirection),
+        startAfter(cursorDoc),
+        limit(fetchLimit),
+      );
+    } else {
+      // No cursor - build standard query
+      q = query(
+        collectionRef,
+        orderBy(orderByField, orderDirection),
+        limit(fetchLimit),
+      );
     }
 
-    // Generate a unique key for deduplication
+    // Generate a unique key for deduplication (after cursor is resolved)
     const uniqueKey = `${collectionName}_list_${orderByField}_${orderDirection}_${fetchLimit}_${cursorKey}`;
 
     return this.executeQuery(

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

@@ -128,8 +128,25 @@ export class BaseRepository {
 
   /**
    * Destroy repository and cleanup resources
+   * Child classes can override onDestroy() to add custom cleanup logic
    */
   destroy(): void {
+    if (__DEV__) {
+      console.log(`[BaseRepository] Destroying repository for ${this.constructor.name}`);
+    }
+
+    // Call child class cleanup if implemented
+    this.onDestroy();
+
+    // Mark as destroyed
     this.isDestroyed = true;
   }
+
+  /**
+   * Cleanup hook for child classes
+   * Override this method to add custom cleanup logic (e.g., unsubscribe from listeners)
+   */
+  protected onDestroy(): void {
+    // Override in child classes if needed
+  }
 }

package/src/firestore/utils/firestore-helper.ts

@@ -107,7 +107,13 @@ export async function runTransaction<T>(
     return await fbRunTransaction(db, updateFunction);
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-    throw new Error(`[runTransaction] Transaction failed: ${errorMessage}`);
+    const errorCode = error instanceof Error ? (error as { code?: string }).code : 'unknown';
+
+    if (__DEV__) {
+      console.error(`[runTransaction] Transaction failed (Code: ${errorCode}):`, errorMessage);
+    }
+
+    throw new Error(`[runTransaction] Transaction failed: ${errorMessage} (Code: ${errorCode})`);
   }
 }
 

package/src/firestore/utils/quota-error-detector.util.ts

@@ -38,15 +38,22 @@ export function isQuotaError(error: unknown): boolean {
 
     if (hasCodeProperty(error)) {
         const code = error.code;
-        if (QUOTA_ERROR_CODES.some((c) => code.includes(c))) {
-            return true;
-        }
+        // Use more specific matching - exact match or ends with pattern
+        return QUOTA_ERROR_CODES.some((c) =>
+            code === c || code.endsWith(`/${c}`) || code.startsWith(`${c}/`)
+        );
     }
 
     if (hasMessageProperty(error)) {
         const message = error.message;
         const lowerMessage = message.toLowerCase();
-        return QUOTA_ERROR_MESSAGES.some((m) => lowerMessage.includes(m));
+        // Use word boundaries to avoid partial matches
+        return QUOTA_ERROR_MESSAGES.some((m) =>
+            lowerMessage.includes(` ${m} `) ||
+            lowerMessage.startsWith(`${m} `) ||
+            lowerMessage.endsWith(` ${m}`) ||
+            lowerMessage === m
+        );
     }
 
     return false;

package/src/index.ts

@@ -59,24 +59,12 @@ export {
   initializeFirebaseAuth,
 } from "./auth/infrastructure/config/FirebaseAuthClient";
 
-export { anonymousAuthService } from "./auth/infrastructure/services/anonymous-auth.service";
-export { deleteCurrentUser } from "./auth/infrastructure/services/account-deletion.service";
-export { appleAuthService } from "./auth/infrastructure/services/apple-auth.service";
-export { googleAuthService } from "./auth/infrastructure/services/google-auth.service";
-export type { GoogleAuthConfig } from "./auth/infrastructure/services/google-auth.types";
-export { useAnonymousAuth } from "./auth/presentation/hooks/useAnonymousAuth";
-export type { UseAnonymousAuthResult } from "./auth/presentation/hooks/useAnonymousAuth";
-
 // Commonly Used Firestore Exports (for convenience)
 export {
   getFirestore,
   initializeFirestore,
 } from "./firestore/infrastructure/config/FirestoreClient";
 
-export { BaseRepository } from "./firestore/infrastructure/repositories/BaseRepository";
-export { FirestorePathResolver } from "./firestore/utils/path-resolver";
-export { PaginationHelper } from "./firestore/utils/pagination.helper";
-
 export { Timestamp } from "firebase/firestore";
 export type {
   Transaction,
@@ -100,20 +88,6 @@ export {
 } from "./firestore/utils/firestore-helper";
 export type { FirestoreResult, NoDbResult } from "./firestore/utils/firestore-helper";
 
-// Auth Hooks (commonly used)
-export { useSocialAuth } from "./auth/presentation/hooks/useSocialAuth";
-export type {
-  SocialAuthConfig,
-  SocialAuthResult,
-} from "./auth/presentation/hooks/useSocialAuth";
-
-export { updateUserPassword } from "./auth/infrastructure/services/password.service";
-export type { PasswordUpdateResult } from "./auth/infrastructure/services/password.service";
-
-export { reauthenticateWithPassword } from "./auth/infrastructure/services/reauthentication.service";
-
-export { getCurrentUserFromGlobal } from "./auth/infrastructure/services/auth-utils.service";
-
 // Init Module Factory
 export {
   createFirebaseInitModule,

package/src/infrastructure/config/FirebaseClient.ts

@@ -35,7 +35,8 @@ export type { FirebaseApp, AuthInitializer, ServiceInitializationOptions };
  */
 export interface ServiceInitializationResult {
   app: FirebaseApp | null;
-  auth: unknown;
+  auth: unknown; // Auth result from authInitializer callback (can be Auth, UserCredential, or any custom type)
+  authError?: string; // Error message if auth initialization failed
 }
 
 /**

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

@@ -18,19 +18,32 @@ export interface ServiceInitializationResult {
   auth: unknown;
 }
 
+export interface ServiceInitializationResult {
+  auth: unknown;
+  authError?: string;
+}
+
 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 {
-        // Silently fail, auth initialization is optional
+      } 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);
+        }
       }
     }
 
-    return { auth };
+    return { auth, authError };
   }
 }

package/src/storage/uploader.ts

@@ -51,6 +51,9 @@ export async function uploadBase64Image(
     const storageRef = ref(storage, storagePath);
 
     const response = await fetch(dataUrl);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch base64 data: HTTP ${response.status} ${response.statusText}`);
+    }
     const blob = await response.blob();
 
     const metadata: UploadMetadata = {
@@ -82,6 +85,9 @@ export async function uploadFile(
     const storageRef = ref(storage, storagePath);
 
     const response = await fetch(uri);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch file from URI: HTTP ${response.status} ${response.statusText}`);
+    }
     const blob = await response.blob();
 
     const contentType = options?.mimeType ?? "image/jpeg";