@umituz/react-native-firebase 2.4.43 → 2.4.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "2.4.43",
+  "version": "2.4.45",
   "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/domains/auth/infrastructure/config/initializers/FirebaseAuthInitializer.ts

@@ -35,12 +35,7 @@ export class FirebaseAuthInitializer {
   }
 
   private static handleInitializationError(error: unknown, app: FirebaseApp): Auth | null {
-    const errorCode = (error as { code?: string })?.code;
-
-    if (errorCode === 'auth/already-initialized') {
-      return this.getExistingAuth(app);
-    }
-
+    // Any initialization error: try to get existing auth instance
     return this.getExistingAuth(app);
   }
 

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

@@ -21,16 +21,24 @@ import { isNewUser as checkIsNewUser } from "../../domain/utils/user-metadata.ut
 import { convertToOAuthResult } from "./utils/auth-result-converter.util";
 
 // Conditional import - expo-apple-authentication is optional
-let AppleAuthentication: any = null;
+interface AppleAuthModule {
+  isAvailableAsync: () => Promise<boolean>;
+  signInAsync: (options: {
+    requestedScopes: number[];
+    nonce: string;
+  }) => Promise<{ identityToken: string | null }>;
+  AppleAuthenticationScope: { FULL_NAME: number; EMAIL: number };
+}
+
+let AppleAuthentication: AppleAuthModule | null = null;
 let isAppleAuthAvailable = false;
 
 try {
   // eslint-disable-next-line @typescript-eslint/no-require-imports
-  AppleAuthentication = require("expo-apple-authentication");
+  AppleAuthentication = require("expo-apple-authentication") as AppleAuthModule;
   isAppleAuthAvailable = true;
 } catch {
   // expo-apple-authentication not available - this is fine if not using Apple auth
-  console.info("expo-apple-authentication is not installed. Apple authentication will not be available.");
 }
 
 export class AppleAuthService {
@@ -67,6 +75,10 @@ export class AppleAuthService {
     }
 
     const result = await executeAuthOperation(async () => {
+      if (!AppleAuthentication) {
+        throw new Error("Apple authentication module not loaded");
+      }
+
       const nonce = await generateNonce();
       const hashedNonce = await hashNonce(nonce);
 

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

@@ -9,21 +9,21 @@ import type { GoogleAuthResult } from "./google-auth.types";
 import { googleAuthService } from "./google-auth.service";
 
 // Conditional import - expo-web-browser is optional
-let ExpoWebBrowser: any = null;
+interface ExpoWebBrowserModule {
+  maybeCompleteAuthSession: () => { type: string };
+}
+
+let ExpoWebBrowser: ExpoWebBrowserModule | null = null;
 let isExpoAuthAvailable = false;
 
 try {
   // eslint-disable-next-line @typescript-eslint/no-require-imports
-  ExpoWebBrowser = require("expo-web-browser");
+  ExpoWebBrowser = require("expo-web-browser") as ExpoWebBrowserModule;
   isExpoAuthAvailable = true;
 
-  // Complete auth session if available
-  if (ExpoWebBrowser?.maybeCompleteAuthSession) {
-    ExpoWebBrowser.maybeCompleteAuthSession();
-  }
+  ExpoWebBrowser.maybeCompleteAuthSession();
 } catch {
   // expo-web-browser not available - this is fine if not using Google OAuth
-  console.info("expo-web-browser is not installed. Google OAuth will not be available.");
 }
 
 export interface GoogleOAuthConfig {

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

@@ -10,12 +10,25 @@ import { getFirebaseAuth } from "../../infrastructure/config/FirebaseAuthClient"
 import type { GoogleOAuthConfig } from "../../infrastructure/services/google-oauth.service";
 
 // Conditional import for expo-auth-session
-let ExpoAuthSession: any = null;
+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");
+  ExpoAuthSession = require("expo-auth-session/providers/google") as ExpoAuthSessionModule;
   isExpoAuthAvailable = true;
 } catch {
   // expo-auth-session not available - hook will return unavailable state
@@ -50,7 +63,7 @@ export function useGoogleOAuth(config?: GoogleOAuthConfig): UseGoogleOAuthResult
 
   // Call the Hook directly (only valid in React component)
   // If expo-auth-session is not available, these will be null
-  const [request, response, promptAsync] = isExpoAuthAvailable && ExpoAuthSession?.useAuthRequest
+  const [request, response, promptAsync] = isExpoAuthAvailable && ExpoAuthSession
     ? ExpoAuthSession.useAuthRequest({
         iosClientId: config?.iosClientId || PLACEHOLDER_CLIENT_ID,
         webClientId: config?.webClientId || PLACEHOLDER_CLIENT_ID,

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

@@ -82,12 +82,11 @@ export abstract class BasePaginatedRepository extends BaseQueryRepository {
 
     return this.executeQuery(
       collectionName,
-      q,
       async () => {
         const snapshot = await getDocs(q);
         return snapshot.docs;
       },
-      false, // Default to false as we don't know yet
+      false,
       uniqueKey
     );
   }

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

@@ -5,8 +5,6 @@
  * Extends BaseRepository with query-specific functionality.
  */
 
-import type { Query } from "firebase/firestore";
-import { quotaTrackingMiddleware } from "../middleware/QuotaTrackingMiddleware";
 import { queryDeduplicationMiddleware } from "../middleware/QueryDeduplicationMiddleware";
 import { BaseRepository } from "./BaseRepository";
 
@@ -14,72 +12,27 @@ export abstract class BaseQueryRepository extends BaseRepository {
   /**
    * Execute query with deduplication and quota tracking
    * Prevents duplicate queries and tracks quota usage
-   *
-   * @param collection - Collection name
-   * @param query - Firestore query (kept for interface compatibility)
-   * @param queryFn - Function to execute the query
-   * @param cached - Whether the result is from cache
-   * @param uniqueKey - Unique key for deduplication (critical for correct caching)
-   * @returns Query result
    */
   protected async executeQuery<T>(
     collection: string,
-    _query: Query,
     queryFn: () => Promise<T>,
     cached: boolean = false,
     uniqueKey?: string
   ): Promise<T> {
-    // Use provided uniqueKey, or generate a stable key based on collection
-    // IMPORTANT: Don't use Date.now() as it defeats deduplication!
     const safeKey = uniqueKey || `${collection}_query`;
 
     const queryKey = {
       collection,
-      filters: safeKey, // Use the unique key as the filter identifier
+      filters: safeKey,
       limit: undefined,
       orderBy: undefined,
     };
 
     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;
     });
   }
-
-  /**
-   * Track read operation
-   *
-   * @param collection - Collection name
-   * @param count - Number of documents read
-   * @param cached - Whether the result is from cache
-   */
-  protected trackRead(
-    collection: string,
-    count: number = 1,
-    cached: boolean = false,
-  ): void {
-    quotaTrackingMiddleware.trackRead(collection, count, cached);
-  }
-
-  protected trackWrite(
-    collection: string,
-    count: number = 1,
-  ): void {
-    quotaTrackingMiddleware.trackWrite(collection, count);
-  }
-
-  protected trackDelete(
-    collection: string,
-    count: number = 1,
-  ): void {
-    quotaTrackingMiddleware.trackDelete(collection, count);
-  }
 }

package/src/index.ts

@@ -34,21 +34,6 @@ export type {
 
 export type { FirebaseApp } from "./shared/infrastructure/config/initializers/FirebaseAppInitializer";
 
-import { FirebaseClientSingleton } from "./shared/infrastructure/config/clients/FirebaseClientSingleton";
-
-function getFirebaseClientSafe(): FirebaseClientSingleton | null {
-  try {
-    return FirebaseClientSingleton.getInstance();
-  } catch {
-    if (__DEV__) {
-      console.warn('[Firebase] Could not create Firebase client singleton — Firebase may not be configured.');
-    }
-    return null;
-  }
-}
-
-export const firebaseClient = getFirebaseClientSafe();
-
 // Type Guards
 export {
   isFirestoreError,