@umituz/react-native-firebase 1.13.158 → 1.13.160

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "1.13.158",
+  "version": "1.13.160",
   "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/infrastructure/services/google-oauth.service.ts

@@ -0,0 +1,173 @@
+/**
+ * Google OAuth Service
+ * Handles Google OAuth flow using expo-auth-session
+ * This service is optional and requires expo-auth-session to be installed
+ */
+
+import type { Auth } from "firebase/auth";
+import type { GoogleAuthResult } from "./google-auth.types";
+import { googleAuthService } from "./google-auth.service";
+
+// Conditional imports - these packages are optional
+let ExpoAuthSession: any = null;
+let ExpoWebBrowser: any = null;
+let isExpoAuthAvailable = false;
+
+try {
+  ExpoAuthSession = require("expo-auth-session/providers/google");
+  ExpoWebBrowser = require("expo-web-browser");
+  isExpoAuthAvailable = true;
+
+  // Complete auth session if available
+  if (ExpoWebBrowser?.maybeCompleteAuthSession) {
+    ExpoWebBrowser.maybeCompleteAuthSession();
+  }
+} catch (error) {
+  // expo-auth-session not available - this is fine if not using Google OAuth
+  console.info("expo-auth-session is not installed. Google OAuth will not be available.");
+}
+
+export interface GoogleOAuthConfig {
+  iosClientId?: string;
+  webClientId?: string;
+  androidClientId?: string;
+}
+
+export interface GoogleOAuthHookResult {
+  request: any;
+  response: any;
+  promptAsync: (() => Promise<any>) | null;
+}
+
+const PLACEHOLDER_CLIENT_ID = "000000000000-placeholder.apps.googleusercontent.com";
+
+function validateGoogleConfig(config?: GoogleOAuthConfig): boolean {
+  if (!config) return false;
+  return !!(
+    (config.iosClientId && config.iosClientId !== PLACEHOLDER_CLIENT_ID) ||
+    (config.webClientId && config.webClientId !== PLACEHOLDER_CLIENT_ID) ||
+    (config.androidClientId && config.androidClientId !== PLACEHOLDER_CLIENT_ID)
+  );
+}
+
+/**
+ * Google OAuth Service
+ * Provides OAuth flow using expo-auth-session
+ */
+export class GoogleOAuthService {
+  /**
+   * Check if expo-auth-session is available
+   */
+  isAvailable(): boolean {
+    return isExpoAuthAvailable;
+  }
+
+  /**
+   * Check if Google OAuth is configured
+   */
+  isConfigured(config?: GoogleOAuthConfig): boolean {
+    return validateGoogleConfig(config);
+  }
+
+  /**
+   * Create auth request hook
+   * This mimics the behavior of expo-auth-session's useAuthRequest hook
+   */
+  createAuthRequest(config?: GoogleOAuthConfig): GoogleOAuthHookResult {
+    if (!isExpoAuthAvailable || !ExpoAuthSession?.useAuthRequest) {
+      return {
+        request: null,
+        response: null,
+        promptAsync: null,
+      };
+    }
+
+    try {
+      const [request, response, promptAsync] = ExpoAuthSession.useAuthRequest({
+        iosClientId: config?.iosClientId || PLACEHOLDER_CLIENT_ID,
+        webClientId: config?.webClientId || PLACEHOLDER_CLIENT_ID,
+        androidClientId: config?.androidClientId || PLACEHOLDER_CLIENT_ID,
+      });
+
+      return {
+        request: request ?? null,
+        response: response ?? null,
+        promptAsync: promptAsync ?? null,
+      };
+    } catch (error) {
+      console.error("Failed to create Google auth request:", error);
+      return {
+        request: null,
+        response: null,
+        promptAsync: null,
+      };
+    }
+  }
+
+  /**
+   * Sign in with Google using OAuth flow
+   */
+  async signInWithOAuth(
+    auth: Auth,
+    config?: GoogleOAuthConfig,
+    promptAsync?: () => Promise<any>
+  ): Promise<GoogleAuthResult> {
+    if (!isExpoAuthAvailable) {
+      return {
+        success: false,
+        error: "expo-auth-session is not available. Please install expo-auth-session and expo-web-browser.",
+        code: "unavailable",
+      };
+    }
+
+    if (!this.isConfigured(config)) {
+      return {
+        success: false,
+        error: "Google Sign-In is not configured. Please provide valid client IDs.",
+        code: "not-configured",
+      };
+    }
+
+    if (!promptAsync) {
+      return {
+        success: false,
+        error: "Google Sign-In not ready. No promptAsync function provided.",
+        code: "not-ready",
+      };
+    }
+
+    try {
+      const result = await promptAsync();
+
+      if (result.type === "success" && result.authentication?.idToken) {
+        // Use the existing google auth service to sign in with the token
+        return await googleAuthService.signInWithIdToken(
+          auth,
+          result.authentication.idToken
+        );
+      }
+
+      if (result.type === "cancel") {
+        return {
+          success: false,
+          error: "Google Sign-In was cancelled",
+          code: "cancelled",
+        };
+      }
+
+      return {
+        success: false,
+        error: "Google Sign-In failed",
+        code: "failed",
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Google sign-in failed",
+        code: "error",
+      };
+    }
+  }
+}
+
+export const googleOAuthService = new GoogleOAuthService();

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

@@ -4,38 +4,41 @@ import { collection, doc } from "firebase/firestore";
 /**
  * Resolves Firestore paths for user collections
  * Standard pattern: users/{userId}/{collectionName}
- * 
+ *
+ * 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 db: 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 {
-        if (!this.db) return null;
-        return collection(this.db, "users", userId, this.collectionName);
+    getUserCollection(db: Firestore | null, userId: string): CollectionReference<DocumentData> | null {
+        if (!db) return null;
+        return collection(db, "users", userId, this.collectionName);
     }
 
     /**
      * 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 {
-        if (!this.db) return null;
-        return doc(this.db, "users", userId, this.collectionName, documentId);
+    getDocRef(db: Firestore | null, userId: string, documentId: string): DocumentReference<DocumentData> | null {
+        if (!db) return null;
+        return doc(db, "users", userId, this.collectionName, documentId);
     }
 }