@umituz/react-native-firebase 2.6.0 → 2.6.2

package/src/domains/auth/presentation/hooks/GoogleOAuthHookService_part_ab

@@ -0,0 +1,97 @@
+    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';

package/src/domains/firestore/domain/entities/Collection.ts

@@ -0,0 +1,128 @@
+/**
+ * Collection Entity (Main)
+ * Single Responsibility: Represent a Firestore collection with metadata
+ *
+ * Domain entity that encapsulates collection information and metadata.
+ * Provides business logic for collection operations.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { CollectionReference, Query } from 'firebase/firestore';
+import {
+  isValidCollectionName,
+  isValidCollectionPath,
+  extractCollectionNameFromPath,
+  extractParentCollectionPath,
+  isUserCollectionPath,
+  extractUserIdFromPath,
+  createSubCollectionPath as createSubCollectionPathUtil,
+} from './CollectionValidation';
+import {
+  getCollectionDepth,
+  collectionToObject,
+  isQueryReference,
+  isCollectionReference as isCollectionReferenceUtil,
+} from './CollectionUtils';
+import { fromReference, fromQuery } from './CollectionFactory';
+
+/**
+ * Collection metadata
+ */
+export interface CollectionMetadata {
+  readonly name: string;
+  readonly path: string;
+  readonly parentPath?: string;
+}
+
+/**
+ * Collection entity
+ * Represents a Firestore collection with metadata
+ */
+export class Collection<TDocument = unknown> {
+  readonly name: string;
+  readonly path: string;
+  readonly parentPath: string | undefined;
+  private readonly reference: CollectionReference<TDocument> | Query<TDocument>;
+
+  constructor(
+    reference: CollectionReference<TDocument> | Query<TDocument>,
+    metadata: CollectionMetadata
+  ) {
+    this.reference = reference;
+    this.name = metadata.name;
+    this.path = metadata.path;
+    this.parentPath = metadata.parentPath || undefined;
+  }
+
+  /**
+   * Create collection from collection reference
+   */
+  static fromReference<TDocument = unknown>(
+    reference: CollectionReference<TDocument>
+  ): Collection<TDocument> {
+    return fromReference(reference);
+  }
+
+  /**
+   * Create collection from query
+   */
+  static fromQuery<TDocument = unknown>(query: Query<TDocument>, name: string, path: string): Collection<TDocument> {
+    return fromQuery(query, name, path);
+  }
+
+  getName(): string {
+    return this.name;
+  }
+
+  getPath(): string {
+    return this.path;
+  }
+
+  getParentPath(): string | undefined {
+    return this.parentPath;
+  }
+
+  isNested(): boolean {
+    return this.parentPath !== undefined;
+  }
+
+  isRootLevel(): boolean {
+    return this.parentPath === undefined;
+  }
+
+  getDepth(): number {
+    return getCollectionDepth(this);
+  }
+
+  getReference(): CollectionReference<TDocument> | Query<TDocument> {
+    return this.reference;
+  }
+
+  isQuery(): boolean {
+    return isQueryReference(this.reference);
+  }
+
+  isCollectionReference(): boolean {
+    return isCollectionReferenceUtil(this.reference);
+  }
+
+  toObject(): CollectionMetadata {
+    return collectionToObject(this);
+  }
+
+  createSubCollectionPath(subCollectionName: string): string | null {
+    return createSubCollectionPathUtil(this.path, subCollectionName);
+  }
+
+  isUserCollection(): boolean {
+    return isUserCollectionPath(this.path);
+  }
+
+  extractUserId(): string | null {
+    return extractUserIdFromPath(this.path);
+  }
+}
+
+// Re-export factory function for backward compatibility
+export { createCollection, fromReference, fromQuery } from './CollectionFactory';