@umituz/react-native-firebase 2.6.0 → 2.6.1

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

@@ -0,0 +1,247 @@
+/**
+ * Google OAuth Hook Service
+ * Single Responsibility: Handle Google OAuth business logic
+ *
+ * Service class that manages Google OAuth flow.
+ * Separates business logic from React hook concerns.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { Auth } from 'firebase/auth';
+import { googleOAuthService } from '../../infrastructure/services/google-oauth.service';
+import type { GoogleOAuthConfig } from '../../infrastructure/services/google-oauth.service';
+
+// Conditional import for expo-auth-session
+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') as ExpoAuthSessionModule;
+  isExpoAuthAvailable = true;
+} catch {
+  // expo-auth-session not available
+}
+
+/**
+ * Google OAuth hook service
+ * Manages OAuth flow, response handling, and errors
+ */
+export class GoogleOAuthHookService {
+  private config: GoogleOAuthConfig | undefined;
+  private authRequest: [unknown, AuthSessionResponse | null, (() => Promise<AuthSessionResponse>) | null];
+
+  constructor(config?: GoogleOAuthConfig) {
+    this.config = config;
+    this.authRequest = this.initAuthRequest();
+  }
+
+  /**
+   * Initialize auth request
+   * Uses expo-auth-session if available
+   */
+  private initAuthRequest(): [unknown, AuthSessionResponse | null, (() => Promise<AuthSessionResponse>) | null] {
+    if (!isExpoAuthAvailable || !ExpoAuthSession) {
+      return [null, null, null];
+    }
+
+    return ExpoAuthSession.useAuthRequest({
+      iosClientId: this.config?.iosClientId ?? '',
+      webClientId: this.config?.webClientId ?? '',
+      androidClientId: this.config?.androidClientId ?? '',
+    });
+  }
+
+  /**
+   * Check if Google OAuth is available
+   */
+  isAvailable(): boolean {
+    return isExpoAuthAvailable;
+  }
+
+  /**
+   * Check if Google OAuth is configured
+   */
+  isConfigured(): boolean {
+    return googleOAuthService.isConfigured(this.config);
+  }
+
+  /**
+   * Update configuration
+   */
+  updateConfig(config: GoogleOAuthConfig | undefined): void {
+    this.config = config;
+  }
+
+  /**
+   * Get auth request tuple
+   */
+  getAuthRequest(): [unknown, AuthSessionResponse | null, (() => Promise<AuthSessionResponse>) | null] {
+    return this.authRequest;
+  }
+
+  /**
+   * Handle OAuth response
+   * Called when expo-auth-session returns a response
+   */
+  async handleResponse(response: AuthSessionResponse | null, auth: Auth | null): Promise<void> {
+    if (!response) return;
+
+    if (response.type === 'success' && response.authentication?.idToken) {
+      if (!auth) {
+        throw new Error('Firebase Auth not initialized');
+      }
+
+      await googleOAuthService.signInWithOAuth(
+        auth,
+        this.config,
+        async () => response
+      );
+    } else if (response.type === 'error') {
+      throw new Error('Google authentication failed');
+    }
+  }
+
+  /**
+   * Sign in with Google
+   * Initiates OAuth flow and returns result
+   */
+  async signIn(auth: Auth | null): Promise<{ success: boolean; isNewUser?: boolean; error?: string }> {
+    if (!this.isAvailable()) {
+      const error = 'expo-auth-session is not available. Please install expo-auth-session and expo-web-browser.';
+      throw new Error(error);
+    }
+
+    if (!this.isConfigured()) {
+      const error = 'Google Sign-In is not configured. Please provide valid client IDs.';
+      throw new Error(error);
+    }
+
+    const [, , promptAsync] = this.authRequest;
+
+    if (!promptAsync) {
+      throw new Error('Google Sign-In not ready');
+    }
+
+    if (!auth) {
+      throw new Error('Firebase Auth not initialized');
+    }
+
+    return await googleOAuthService.signInWithOAuth(auth, this.config, promptAsync);
+  }
+
+  /**
+   * Validate OAuth state
+   */
+  validate(): { valid: boolean; error?: string } {
+    if (!this.isAvailable()) {
+      return {
+        valid: false,
+        error: 'expo-auth-session is not available. Please install expo-auth-session and expo-web-browser.',
+      };
+    }
+
+    if (!this.isConfigured()) {
+      return {
+        valid: false,
+        error: 'Google Sign-In is not configured. Please provide valid client IDs.',
+      };
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Get error message from error
+   */
+  getErrorMessage(error: unknown): string {
+    if (error instanceof Error) {
+      return error.message;
+    }
+    return 'Google sign-in failed';
+  }
+
+  /**
+   * Check if response is successful
+   */
+  isSuccessfulResponse(response: AuthSessionResponse | null): boolean {
+    return response?.type === 'success' && !!response.authentication?.idToken;
+  }
+
+  /**
+   * Check if response is error
+   */
+  isErrorResponse(response: AuthSessionResponse | null): boolean {
+    return response?.type === 'error';
+  }
+
+  /**
+   * Extract ID token from response
+   */
+  extractIdToken(response: AuthSessionResponse | null): string | null {
+    return response?.authentication?.idToken || null;
+  }
+
+  /**
+   * Create error result
+   */
+  createErrorResult(error: string): { success: false; error: string } {
+    return { success: false, error };
+  }
+
+  /**
+   * Check if auth request is ready
+   */
+  isReady(): boolean {
+    const [request, , promptAsync] = this.authRequest;
+    return request !== null && promptAsync !== null;
+  }
+
+  /**
+   * Get configuration
+   */
+  getConfig(): GoogleOAuthConfig | undefined {
+    return this.config;
+  }
+
+  /**
+   * Reset service state
+   */
+  reset(): void {
+    this.config = undefined;
+  }
+}
+
+/**
+ * Factory function to create Google OAuth hook service
+ */
+export function createGoogleOAuthHookService(config?: GoogleOAuthConfig): GoogleOAuthHookService {
+  return new GoogleOAuthHookService(config);
+}
+
+/**
+ * Check if expo-auth-session is available
+ * Useful for conditional rendering
+ */
+export function isExpoAuthSessionAvailable(): boolean {
+  return isExpoAuthAvailable;
+}
+
+/**
+ * Re-export types for convenience
+ */
+export type { AuthSessionResponse, ExpoAuthSessionModule };

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

@@ -1,37 +1,21 @@
 /**
  * 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
+ *
+ * This hook delegates business logic to GoogleOAuthHookService.
+ * Focuses only on React state management and side effects.
+ *
+ * Max lines: 150 (enforced for maintainability)
  */
 
-import { useState, useCallback, useEffect, useRef, useMemo } 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";
-// Conditional import for expo-auth-session
-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") as ExpoAuthSessionModule;
-  isExpoAuthAvailable = true;
-} catch {
-  // expo-auth-session not available - hook will return unavailable state
-}
+import { useState, useCallback, useEffect, useMemo } from 'react';
+import { getFirebaseAuth } from '../../infrastructure/config/FirebaseAuthClient';
+import type { GoogleOAuthConfig } from '../../infrastructure/services/google-oauth.service';
+import {
+  GoogleOAuthHookService,
+  createGoogleOAuthHookService,
+  isExpoAuthSessionAvailable,
+} from './GoogleOAuthHookService';
 
 export interface UseGoogleOAuthResult {
   signInWithGoogle: () => Promise<SocialAuthResult>;
@@ -55,107 +39,62 @@ export function useGoogleOAuth(config?: GoogleOAuthConfig): UseGoogleOAuthResult
   const [isLoading, setIsLoading] = useState(false);
   const [googleError, setGoogleError] = useState<string | null>(null);
 
-  // Memoize service checks to avoid repeated calls on every render
-  const googleAvailable = useMemo(() => googleOAuthService.isAvailable(), []);
-  const googleConfigured = useMemo(() => googleOAuthService.isConfigured(config), [config]);
-
-  // Keep config in a ref so the response useEffect doesn't re-run when config object reference changes
-  const configRef = useRef(config);
-  configRef.current = config;
-
-  // Call the Hook directly (only valid in React component)
-  // If expo-auth-session is not available, these will be null
-  // Empty strings are passed when config is missing to preserve hook call order (Rules of Hooks)
-  const [request, response, promptAsync] = isExpoAuthAvailable && ExpoAuthSession
-    ? ExpoAuthSession.useAuthRequest({
-        iosClientId: config?.iosClientId ?? "",
-        webClientId: config?.webClientId ?? "",
-        androidClientId: config?.androidClientId ?? "",
-      })
-    : [null, null, null];
+  // Initialize service with config
+  const service = useMemo(() => createGoogleOAuthHookService(config), [config]);
+
+  // Update service when config changes
+  useEffect(() => {
+    service.updateConfig(config);
+  }, [service, config]);
+
+  // Memoize service checks
+  const googleAvailable = useMemo(() => service.isAvailable(), [service]);
+  const googleConfigured = useMemo(() => service.isConfigured(), [service]);
+
+  // Get auth request tuple from service
+  const [, response] = service.getAuthRequest();
 
   // 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");
-            setIsLoading(false);
-            return;
-          }
-
-          await googleOAuthService.signInWithOAuth(
-            auth,
-            configRef.current,
-            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(true);
+      setGoogleError(null);
+
+      try {
+        const auth = getFirebaseAuth();
+        await service.handleResponse(response, auth);
+      } catch (error) {
+        setGoogleError(service.getErrorMessage(error));
+      } finally {
+        setIsLoading(false);
       }
     };
 
-    // Call async function and catch errors separately
     handleResponse().catch((err) => {
-      // Errors are already handled in handleResponse
       if (__DEV__) {
         console.error('[useGoogleOAuth] Unexpected error in handleResponse:', err);
       }
     });
-  }, [response, googleAvailable]); // config read via ref to prevent re-running on reference changes
+  }, [response, googleAvailable, service]);
 
+  // Sign in with Google
   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);
+      return await service.signIn(auth);
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Google sign-in failed";
+      const errorMessage = service.getErrorMessage(error);
       setGoogleError(errorMessage);
       return { success: false, error: errorMessage };
     } finally {
       setIsLoading(false);
     }
-  }, [googleAvailable, googleConfigured, request, promptAsync]); // config read via ref to prevent re-creation on reference changes
+  }, [service]);
 
   return {
     signInWithGoogle,
@@ -165,3 +104,10 @@ export function useGoogleOAuth(config?: GoogleOAuthConfig): UseGoogleOAuthResult
     googleError,
   };
 }
+
+/**
+ * Check if expo-auth-session is available
+ * Useful for conditional rendering
+ */
+export { isExpoAuthSessionAvailable };
+

package/src/domains/auth/presentation.ts

@@ -0,0 +1,25 @@
+/**
+ * Firebase Auth Presentation Layer
+ * Domain-Driven Design (DDD) - Presentation Exports
+ *
+ * React hooks for Firebase authentication.
+ * Provides clean interface for UI components.
+ */
+
+export { useFirebaseAuth } from './presentation/hooks/useFirebaseAuth';
+export type { UseFirebaseAuthResult } from './presentation/hooks/useFirebaseAuth';
+
+export { useAnonymousAuth } from './presentation/hooks/useAnonymousAuth';
+export type { UseAnonymousAuthResult } from './presentation/hooks/useAnonymousAuth';
+
+export { useSocialAuth } from './presentation/hooks/useSocialAuth';
+export type {
+  SocialAuthConfig,
+  SocialAuthResult,
+  UseSocialAuthResult,
+} from './presentation/hooks/useSocialAuth';
+
+export { useGoogleOAuth } from './presentation/hooks/useGoogleOAuth';
+export type {
+  UseGoogleOAuthResult,
+} from './presentation/hooks/useGoogleOAuth';