@umituz/react-native-firebase 1.13.158 → 1.13.159

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "1.13.158",
+  "version": "1.13.159",
   "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/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/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}
- * 
+ *
+ * Uses lazy initialization to support Firebase initialization after module load
  * 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,
+        private readonly getDb: () => Firestore | null,
     ) { }
 
     /**
      * Get collection reference for a user
      * Pattern: users/{userId}/{collectionName}
-     * 
+     *
      * @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);
+        const db = this.getDb();
+        if (!db) return null;
+        return collection(db, "users", userId, this.collectionName);
     }
 
     /**
      * Get document reference for a specific item
      * Pattern: users/{userId}/{collectionName}/{documentId}
-     * 
+     *
      * @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);
+        const db = this.getDb();
+        if (!db) return null;
+        return doc(db, "users", userId, this.collectionName, documentId);
     }
 }