@umituz/react-native-firebase 1.13.159 → 1.13.161

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "1.13.159",
+  "version": "1.13.161",
   "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",
@@ -35,11 +35,24 @@
     "@umituz/react-native-design-system": "*",
     "expo": ">=54.0.0",
     "expo-apple-authentication": ">=6.0.0",
+    "expo-auth-session": ">=5.0.0",
     "expo-crypto": ">=13.0.0",
+    "expo-web-browser": ">=12.0.0",
     "firebase": ">=10.0.0",
     "react": ">=19.0.0",
     "react-native": "0.81.4"
   },
+  "peerDependenciesMeta": {
+    "expo-apple-authentication": {
+      "optional": true
+    },
+    "expo-auth-session": {
+      "optional": true
+    },
+    "expo-web-browser": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@expo/vector-icons": "^15.0.3",
     "@react-native-async-storage/async-storage": "^2.2.0",

package/src/auth/index.ts

@@ -109,6 +109,14 @@ export type {
   GoogleAuthResult,
 } from './infrastructure/services/google-auth.types';
 
+export {
+  GoogleOAuthService,
+  googleOAuthService,
+} from './infrastructure/services/google-oauth.service';
+export type {
+  GoogleOAuthConfig,
+} from './infrastructure/services/google-oauth.service';
+
 export {
   AppleAuthService,
   appleAuthService,
@@ -132,6 +140,11 @@ export type {
   UseSocialAuthResult,
 } from './presentation/hooks/useSocialAuth';
 
+export { useGoogleOAuth } from './presentation/hooks/useGoogleOAuth';
+export type {
+  UseGoogleOAuthResult,
+} from './presentation/hooks/useGoogleOAuth';
+
 // Password Management
 export {
   updateUserPassword,

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

@@ -1,6 +1,7 @@
 /**
  * Apple Auth Service
  * Handles Apple Sign-In with Firebase Authentication
+ * This service is optional and requires expo-apple-authentication to be installed
  */
 
 import {
@@ -8,7 +9,6 @@ import {
   signInWithCredential,
   type Auth,
 } from "firebase/auth";
-import * as AppleAuthentication from "expo-apple-authentication";
 import { Platform } from "react-native";
 import { generateNonce, hashNonce } from "./crypto.util";
 import type { AppleAuthResult } from "./apple-auth.types";
@@ -17,9 +17,22 @@ import {
 } from "./base/base-auth.service";
 import { executeAuthOperation, type Result } from "../../../domain/utils";
 
+// Conditional import - expo-apple-authentication is optional
+let AppleAuthentication: any = null;
+let isAppleAuthAvailable = false;
+
+try {
+  AppleAuthentication = require("expo-apple-authentication");
+  isAppleAuthAvailable = true;
+} catch (error) {
+  // 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 {
   async isAvailable(): Promise<boolean> {
     if (Platform.OS !== "ios") return false;
+    if (!isAppleAuthAvailable || !AppleAuthentication?.isAvailableAsync) return false;
     try {
       return await AppleAuthentication.isAvailableAsync();
     } catch {
@@ -43,6 +56,14 @@ export class AppleAuthService {
   }
 
   async signIn(auth: Auth): Promise<AppleAuthResult> {
+    if (!isAppleAuthAvailable) {
+      return {
+        success: false,
+        error: "expo-apple-authentication is not available. Please install expo-apple-authentication.",
+        code: "unavailable"
+      };
+    }
+
     const isAvailable = await this.isAvailable();
     if (!isAvailable) {
       return {

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

@@ -0,0 +1,125 @@
+/**
+ * useGoogleOAuth Hook
+ * Handles Google OAuth flow using expo-auth-session and Firebase auth
+ * This hook is optional and requires expo-auth-session to be installed
+ */
+
+import { useState, useCallback, useEffect } 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";
+
+export interface UseGoogleOAuthResult {
+  signInWithGoogle: () => Promise<SocialAuthResult>;
+  googleLoading: boolean;
+  googleConfigured: boolean;
+  googleAvailable: boolean;
+  googleError: string | null;
+}
+
+export interface SocialAuthResult {
+  success: boolean;
+  isNewUser?: boolean;
+  error?: string;
+}
+
+/**
+ * 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 googleAvailable = googleOAuthService.isAvailable();
+  const googleConfigured = googleOAuthService.isConfigured(config);
+
+  // Create auth request - this will return null values if expo-auth-session is not available
+  const authRequest = googleOAuthService.createAuthRequest(config);
+  const { request, response, promptAsync } = authRequest;
+
+  // 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");
+            return;
+          }
+
+          await googleOAuthService.signInWithOAuth(
+            auth,
+            config,
+            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");
+        setIsLoading(false);
+      }
+    };
+
+    handleResponse();
+  }, [response, googleAvailable, config]);
+
+  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();
+      if (!auth) {
+        const error = "Firebase Auth not initialized";
+        setGoogleError(error);
+        return { success: false, error };
+      }
+
+      return await googleOAuthService.signInWithOAuth(auth, config, promptAsync);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Google sign-in failed";
+      setGoogleError(errorMessage);
+      return { success: false, error: errorMessage };
+    } finally {
+      setIsLoading(false);
+    }
+  }, [googleAvailable, googleConfigured, request, promptAsync, config]);
+
+  return {
+    signInWithGoogle,
+    googleLoading: isLoading,
+    googleConfigured,
+    googleAvailable,
+    googleError,
+  };
+}

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

@@ -2,11 +2,14 @@
  * Base Repository - Core Firestore Operations
  *
  * Provides base functionality for all Firestore repositories.
- * Handles initialization checks, error handling, and quota tracking.
+ * Standard pattern: users/{userId}/{collectionName}
+ *
+ * Subclasses must provide collectionName via constructor.
+ * This class handles all path resolution, eliminating need for FirestorePathResolver.
  */
 
-import type { Firestore } from 'firebase/firestore';
-import { getFirestore } from 'firebase/firestore';
+import type { Firestore, CollectionReference, DocumentReference, DocumentData } from 'firebase/firestore';
+import { getFirestore, collection, doc } from 'firebase/firestore';
 import { isQuotaError as checkQuotaError } from '../../utils/quota-error-detector.util';
 
 /**
@@ -23,6 +26,11 @@ export enum RepositoryState {
  */
 export abstract class BaseRepository {
   protected state: RepositoryState = RepositoryState.ACTIVE;
+  protected readonly collectionName: string;
+
+  constructor(collectionName: string) {
+    this.collectionName = collectionName;
+  }
 
   /**
    * Get the Firestore instance
@@ -35,6 +43,33 @@ export abstract class BaseRepository {
     return getFirestore();
   }
 
+  /**
+   * Get user collection reference
+   * Pattern: users/{userId}/{collectionName}
+   *
+   * @param userId User identifier
+   * @returns CollectionReference or null if db not initialized
+   */
+  protected getUserCollection(userId: string): CollectionReference<DocumentData> | null {
+    const db = this.getDb();
+    if (!db) return null;
+    return collection(db, 'users', userId, this.collectionName);
+  }
+
+  /**
+   * Get document reference
+   * Pattern: users/{userId}/{collectionName}/{documentId}
+   *
+   * @param userId User identifier
+   * @param documentId Document identifier
+   * @returns DocumentReference or null if db not initialized
+   */
+  protected getDocRef(userId: string, documentId: string): DocumentReference<DocumentData> | null {
+    const db = this.getDb();
+    if (!db) return null;
+    return doc(db, 'users', userId, this.collectionName, documentId);
+  }
+
   /**
    * Check if Firestore is initialized
    */

package/src/firestore/utils/path-resolver.ts

@@ -5,25 +5,25 @@ import { collection, doc } from "firebase/firestore";
  * Resolves Firestore paths for user collections
  * Standard pattern: users/{userId}/{collectionName}
  *
- * Uses lazy initialization to support Firebase initialization after module load
+ * Stateless design: db is passed to methods, not stored in constructor
+ * This eliminates initialization timing issues and makes testing easier
  * This class is designed to be used across hundreds of apps.
  * All user data MUST be under users/{userId}/ for consistency.
  */
 export class FirestorePathResolver {
     constructor(
         private readonly collectionName: string,
-        private readonly getDb: () => Firestore | null,
     ) { }
 
     /**
      * Get collection reference for a user
      * Pattern: users/{userId}/{collectionName}
      *
+     * @param db Firestore instance
      * @param userId User identifier
      * @returns CollectionReference or null if db not initialized
      */
-    getUserCollection(userId: string): CollectionReference<DocumentData> | null {
-        const db = this.getDb();
+    getUserCollection(db: Firestore | null, userId: string): CollectionReference<DocumentData> | null {
         if (!db) return null;
         return collection(db, "users", userId, this.collectionName);
     }
@@ -32,12 +32,12 @@ export class FirestorePathResolver {
      * Get document reference for a specific item
      * Pattern: users/{userId}/{collectionName}/{documentId}
      *
+     * @param db Firestore instance
      * @param userId User identifier
      * @param documentId Document identifier
      * @returns DocumentReference or null if db not initialized
      */
-    getDocRef(userId: string, documentId: string): DocumentReference<DocumentData> | null {
-        const db = this.getDb();
+    getDocRef(db: Firestore | null, userId: string, documentId: string): DocumentReference<DocumentData> | null {
         if (!db) return null;
         return doc(db, "users", userId, this.collectionName, documentId);
     }