@umituz/react-native-firebase 1.13.2 → 1.13.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "1.13.2",
-  "description": "Unified Firebase package for React Native apps - Centralized initialization and core services (Analytics, Crashlytics).",
+  "version": "1.13.3",
+  "description": "Unified Firebase package for React Native apps - Centralized initialization and core services (Auth, Analytics, Crashlytics).",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "scripts": {
@@ -15,6 +15,8 @@
     "react-native",
     "firebase",
     "firebase-core",
+    "auth",
+    "authentication",
     "analytics",
     "crashlytics",
     "ddd",
@@ -30,6 +32,7 @@
     "@react-native-firebase/analytics": ">=18.0.0",
     "@react-native-firebase/app": ">=18.0.0",
     "@react-native-firebase/crashlytics": ">=18.0.0",
+    "expo-apple-authentication": ">=6.0.0",
     "firebase": ">=10.0.0",
     "react": ">=18.2.0",
     "react-native": ">=0.74.0"

package/src/auth/domain/entities/AnonymousUser.ts

@@ -0,0 +1,44 @@
+/**
+ * Anonymous User Entity
+ * Represents a Firebase Anonymous Auth user
+ */
+
+import type { User } from "firebase/auth";
+
+export interface AnonymousUser {
+  readonly uid: string;
+  readonly isAnonymous: boolean;
+  readonly createdAt?: number;
+}
+
+/**
+ * Check if a Firebase User is anonymous
+ */
+export function isAnonymousUser(user: User | null | undefined): user is User & { isAnonymous: true } {
+  return user?.isAnonymous === true;
+}
+
+/**
+ * Convert Firebase User to AnonymousUser entity
+ */
+export function toAnonymousUser(user: User): AnonymousUser {
+  return {
+    uid: user.uid,
+    isAnonymous: user.isAnonymous,
+    createdAt: Date.now(),
+  };
+}
+
+/**
+ * Validate AnonymousUser entity
+ */
+export function isValidAnonymousUser(user: unknown): user is AnonymousUser {
+  return (
+    typeof user === 'object' &&
+    user !== null &&
+    'uid' in user &&
+    typeof user.uid === 'string' &&
+    'isAnonymous' in user &&
+    typeof user.isAnonymous === 'boolean'
+  );
+}

package/src/auth/domain/errors/FirebaseAuthError.ts

@@ -0,0 +1,18 @@
+/**
+ * Firebase Auth Error Classes
+ * Custom error types for Firebase Auth operations
+ */
+
+export class FirebaseAuthError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'FirebaseAuthError';
+  }
+}
+
+export class FirebaseAuthInitializationError extends FirebaseAuthError {
+  constructor(message: string) {
+    super(message);
+    this.name = 'FirebaseAuthInitializationError';
+  }
+}

package/src/auth/domain/value-objects/FirebaseAuthConfig.ts

@@ -0,0 +1,45 @@
+/**
+ * Firebase Auth Configuration Value Object
+ * Configuration options for Firebase Auth initialization
+ */
+
+/**
+ * Storage interface for auth persistence
+ */
+export interface AuthStorage {
+  getItem: (key: string) => Promise<string | null>;
+  setItem: (key: string, value: string) => Promise<void>;
+  removeItem: (key: string) => Promise<void>;
+}
+
+export interface FirebaseAuthConfig {
+  /**
+   * Enable persistence (store user session across app restarts)
+   * Default: true
+   */
+  persistence?: boolean;
+
+  /**
+   * Auth state persistence type
+   * - 'local': Persist across browser/app restarts (default)
+   * - 'session': Persist only for current session
+   * - 'none': No persistence
+   */
+  persistenceType?: 'local' | 'session' | 'none';
+
+  /**
+   * Custom storage key prefix for auth state
+   */
+  storageKeyPrefix?: string;
+
+  /**
+   * Enable debug logging
+   */
+  debug?: boolean;
+
+  /**
+   * Custom auth storage implementation
+   * Default: Uses AsyncStorage
+   */
+  authStorage?: AuthStorage;
+}

package/src/auth/index.ts

@@ -0,0 +1,146 @@
+/**
+ * Firebase Auth Module
+ * Domain-Driven Design (DDD) Architecture
+ */
+
+// =============================================================================
+// DOMAIN LAYER - Business Logic
+// =============================================================================
+
+export {
+  FirebaseAuthError,
+  FirebaseAuthInitializationError,
+} from './domain/errors/FirebaseAuthError';
+
+export type { FirebaseAuthConfig } from './domain/value-objects/FirebaseAuthConfig';
+
+// Anonymous User Entity
+export {
+  isAnonymousUser,
+  toAnonymousUser,
+  isValidAnonymousUser,
+} from './domain/entities/AnonymousUser';
+export type { AnonymousUser } from './domain/entities/AnonymousUser';
+
+// =============================================================================
+// INFRASTRUCTURE LAYER - Implementation
+// =============================================================================
+
+export {
+  getFirebaseAuth,
+  isFirebaseAuthInitialized,
+  getFirebaseAuthInitializationError,
+  resetFirebaseAuthClient,
+  firebaseAuthClient,
+  initializeFirebaseAuth,
+} from './infrastructure/config/FirebaseAuthClient';
+
+export type {
+  Auth,
+} from './infrastructure/config/FirebaseAuthClient';
+
+// Auth Utilities
+export {
+  checkAuthState,
+  isAuthenticated,
+  isGuest,
+  getCurrentUserId,
+  getCurrentUser,
+  getCurrentUserIdFromGlobal,
+  getCurrentUserFromGlobal,
+  isCurrentUserAuthenticated,
+  isCurrentUserGuest,
+  verifyUserId,
+  getSafeUserId,
+  isValidUser,
+} from './infrastructure/services/auth-utils.service';
+
+export type {
+  AuthCheckResult,
+} from './infrastructure/services/auth-utils.service';
+
+// Auth Guard
+export {
+  AuthGuardService,
+  authGuardService,
+} from './infrastructure/services/auth-guard.service';
+
+// Anonymous Auth Service
+export {
+  AnonymousAuthService,
+  anonymousAuthService,
+} from './infrastructure/services/anonymous-auth.service';
+
+export type {
+  AnonymousAuthResult,
+  AnonymousAuthServiceInterface,
+} from './infrastructure/services/anonymous-auth.service';
+
+// Firestore Utilities
+export {
+  shouldSkipFirestoreQuery,
+  createFirestoreQueryOptions,
+} from './infrastructure/services/firestore-utils.service';
+
+export type {
+  FirestoreQueryOptions,
+  FirestoreQueryResult,
+  FirestoreQuerySkipReason,
+} from './infrastructure/services/firestore-utils.service';
+
+// Account Deletion
+export {
+  deleteCurrentUser,
+  deleteUserAccount,
+} from './infrastructure/services/account-deletion.service';
+
+export type { AccountDeletionResult, AccountDeletionOptions } from './infrastructure/services/account-deletion.service';
+
+// Reauthentication Service
+export {
+  getUserAuthProvider,
+  reauthenticateWithGoogle,
+  reauthenticateWithApple,
+  getAppleReauthCredential,
+} from './infrastructure/services/reauthentication.service';
+
+export type {
+  ReauthenticationResult,
+  AuthProviderType,
+} from './infrastructure/services/reauthentication.service';
+
+// =============================================================================
+// INFRASTRUCTURE LAYER - Social Auth Services
+// =============================================================================
+
+export {
+  GoogleAuthService,
+  googleAuthService,
+} from './infrastructure/services/google-auth.service';
+export type {
+  GoogleAuthConfig,
+  GoogleAuthResult,
+} from './infrastructure/services/google-auth.service';
+
+export {
+  AppleAuthService,
+  appleAuthService,
+} from './infrastructure/services/apple-auth.service';
+export type { AppleAuthResult } from './infrastructure/services/apple-auth.service';
+
+// =============================================================================
+// PRESENTATION LAYER - Hooks
+// =============================================================================
+
+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';

package/src/auth/infrastructure/config/FirebaseAuthClient.ts

@@ -0,0 +1,210 @@
+/**
+ * Firebase Auth Client - Infrastructure Layer
+ *
+ * Domain-Driven Design: Infrastructure implementation of Firebase Auth client
+ * Singleton pattern for managing Firebase Auth instance
+ *
+ * IMPORTANT: This package requires Firebase App to be initialized first.
+ * Use @umituz/react-native-firebase to initialize Firebase App.
+ *
+ * SOLID Principles:
+ * - Single Responsibility: Only manages Auth initialization
+ * - Open/Closed: Extensible through configuration, closed for modification
+ * - Dependency Inversion: Depends on Firebase App from @umituz/react-native-firebase
+ */
+
+import type { Auth } from 'firebase/auth';
+import { getFirebaseApp } from '../../../infrastructure/config/FirebaseClient';
+import { FirebaseAuthInitializationError } from '../../domain/errors/FirebaseAuthError';
+import { FirebaseAuthInitializer } from './initializers/FirebaseAuthInitializer';
+import type { FirebaseAuthConfig } from '../../domain/value-objects/FirebaseAuthConfig';
+
+declare const __DEV__: boolean;
+
+/**
+ * Firebase Auth Client Singleton
+ * Manages Firebase Auth initialization
+ */
+class FirebaseAuthClientSingleton {
+  private static instance: FirebaseAuthClientSingleton | null = null;
+  private auth: Auth | null = null;
+  private initializationError: string | null = null;
+
+  private constructor() {
+    // Private constructor to enforce singleton pattern
+  }
+
+  /**
+   * Get singleton instance
+   */
+  static getInstance(): FirebaseAuthClientSingleton {
+    if (!FirebaseAuthClientSingleton.instance) {
+      FirebaseAuthClientSingleton.instance = new FirebaseAuthClientSingleton();
+    }
+    return FirebaseAuthClientSingleton.instance;
+  }
+
+  /**
+   * Initialize Firebase Auth
+   * Requires Firebase App to be initialized first via @umituz/react-native-firebase
+   *
+   * @param config - Optional Firebase Auth configuration
+   * @returns Firebase Auth instance or null if initialization fails
+   */
+  initialize(config?: FirebaseAuthConfig): Auth | null {
+    // Return existing instance if already initialized
+    if (this.auth) {
+      if (__DEV__) {
+        console.log('[FirebaseAuth] Already initialized, returning existing instance');
+      }
+      return this.auth;
+    }
+
+    // Don't retry if initialization already failed
+    if (this.initializationError) {
+      if (__DEV__) {
+        console.warn('[FirebaseAuth] Previous initialization failed:', this.initializationError);
+      }
+      return null;
+    }
+
+    try {
+      // Get Firebase App instance (must be initialized first)
+      const app = getFirebaseApp();
+
+      // Return null if Firebase App is not available (offline mode)
+      if (!app) {
+        if (__DEV__) {
+          console.log('[FirebaseAuth] Firebase App not available - skipping Auth initialization');
+        }
+        // Don't set initializationError - this is normal offline mode
+        return null;
+      }
+
+      if (__DEV__) {
+        console.log('[FirebaseAuth] Initializing Firebase Auth...');
+      }
+
+      // Initialize Auth
+      this.auth = FirebaseAuthInitializer.initialize(app, config);
+
+      if (this.auth) {
+        if (__DEV__) {
+          console.log('[FirebaseAuth] ✅ Successfully initialized');
+        }
+      } else {
+        if (__DEV__) {
+          console.warn('[FirebaseAuth] ⚠️ Initialization returned null');
+        }
+      }
+
+      return this.auth;
+    } catch (error) {
+      // Only set error if it's a real initialization failure, not just missing config
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      if (__DEV__) {
+        console.error('[FirebaseAuth] ❌ Initialization error:', errorMessage);
+      }
+      if (!errorMessage.includes('not initialized') && !errorMessage.includes('not available')) {
+        this.initializationError = errorMessage;
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Get the Firebase Auth instance
+   * Auto-initializes if Firebase App is available
+   * Returns null if config is not available (offline mode - no error)
+   * @returns Firebase Auth instance or null if not initialized
+   */
+  getAuth(): Auth | null {
+    // Auto-initialize if not already initialized
+    if (!this.auth && !this.initializationError) {
+      try {
+        // Try to get Firebase App (will auto-initialize if config is available)
+        const app = getFirebaseApp();
+        if (app) {
+          this.initialize();
+        }
+      } catch {
+        // Firebase App not available, return null (offline mode)
+        return null;
+      }
+    }
+
+    // Return null if not initialized (offline mode - no error)
+    return this.auth || null;
+  }
+
+  /**
+   * Check if Auth is initialized
+   */
+  isInitialized(): boolean {
+    return this.auth !== null;
+  }
+
+  /**
+   * Get initialization error if any
+   */
+  getInitializationError(): string | null {
+    return this.initializationError;
+  }
+
+  /**
+   * Reset the Auth client instance
+   * Useful for testing
+   */
+  reset(): void {
+    this.auth = null;
+    this.initializationError = null;
+  }
+}
+
+/**
+ * Singleton instance
+ */
+export const firebaseAuthClient = FirebaseAuthClientSingleton.getInstance();
+
+export function initializeFirebaseAuth(
+  config?: FirebaseAuthConfig
+): Auth | null {
+  return firebaseAuthClient.initialize(config);
+}
+
+/**
+ * Get Firebase Auth instance
+ * Auto-initializes if Firebase App is available
+ * Returns null if config is not available (offline mode - no error)
+ * @returns Firebase Auth instance or null if not initialized
+ */
+export function getFirebaseAuth(): Auth | null {
+  return firebaseAuthClient.getAuth();
+}
+
+/**
+ * Check if Firebase Auth is initialized
+ */
+export function isFirebaseAuthInitialized(): boolean {
+  return firebaseAuthClient.isInitialized();
+}
+
+/**
+ * Get initialization error if any
+ */
+export function getFirebaseAuthInitializationError(): string | null {
+  return firebaseAuthClient.getInitializationError();
+}
+
+/**
+ * Reset Firebase Auth client instance
+ * Useful for testing
+ */
+export function resetFirebaseAuthClient(): void {
+  firebaseAuthClient.reset();
+}
+
+// Export types
+export type { Auth } from 'firebase/auth';
+export type { FirebaseAuthConfig } from '../../domain/value-objects/FirebaseAuthConfig';
+

package/src/auth/infrastructure/config/initializers/FirebaseAuthInitializer.ts

@@ -0,0 +1,148 @@
+/**
+ * Firebase Auth Initializer
+ *
+ * Single Responsibility: Initialize Firebase Auth instance
+ * Platform-agnostic: Works on all platforms (Web, iOS, Android)
+ */
+
+import { initializeAuth, getAuth } from 'firebase/auth';
+import type { Auth } from 'firebase/auth';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import type { FirebaseApp } from 'firebase/app';
+import type { FirebaseAuthConfig } from '../../../domain/value-objects/FirebaseAuthConfig';
+import {
+  trackPackageError,
+  addPackageBreadcrumb,
+  trackPackageWarning,
+} from '@umituz/react-native-sentry';
+
+declare const __DEV__: boolean;
+
+/**
+ * Initializes Firebase Auth
+ * Platform-agnostic: Works on all platforms (Web, iOS, Android)
+ */
+export class FirebaseAuthInitializer {
+  /**
+   * Initialize Firebase Auth with persistence support
+   */
+  static initialize(app: FirebaseApp, config?: FirebaseAuthConfig): Auth | null {
+    addPackageBreadcrumb('firebase-auth', 'Initializing Firebase Auth');
+
+    try {
+      // Try React Native persistence first (works on all platforms)
+      const auth = this.initializeWithPersistence(app, config);
+
+      if (auth) {
+        addPackageBreadcrumb('firebase-auth', 'Successfully initialized with persistence');
+      }
+
+      return auth;
+    } catch (error: any) {
+      // If already initialized or persistence fails, get existing instance
+      if (error.code === 'auth/already-initialized') {
+        trackPackageWarning(
+          'firebase-auth',
+          'Auth already initialized, returning existing instance',
+          { errorCode: error.code }
+        );
+
+        try {
+          return getAuth(app);
+        } catch (getAuthError) {
+          const errorObj = getAuthError instanceof Error ? getAuthError : new Error(String(getAuthError));
+          trackPackageError(errorObj, {
+            packageName: 'firebase-auth',
+            operation: 'getAuth-after-already-initialized',
+          });
+
+          if (__DEV__) {
+            console.warn('Firebase Auth: Failed to get existing auth instance:', getAuthError);
+          }
+          return null;
+        }
+      }
+
+      const errorObj = error instanceof Error ? error : new Error(String(error));
+      trackPackageError(errorObj, {
+        packageName: 'firebase-auth',
+        operation: 'initialize',
+        errorCode: error.code,
+      });
+
+      if (__DEV__) {
+        console.warn('Firebase Auth initialization error:', error);
+      }
+
+      // Try to get auth instance as fallback
+      try {
+        return getAuth(app);
+      } catch (getAuthError) {
+        const fallbackError = getAuthError instanceof Error ? getAuthError : new Error(String(getAuthError));
+        trackPackageError(fallbackError, {
+          packageName: 'firebase-auth',
+          operation: 'getAuth-fallback',
+        });
+
+        if (__DEV__) {
+          console.warn('Firebase Auth: Failed to get auth instance after initialization error:', getAuthError);
+        }
+        return null;
+      }
+    }
+  }
+
+  private static initializeWithPersistence(
+    app: FirebaseApp,
+    config?: FirebaseAuthConfig
+  ): Auth | null {
+    try {
+      const authModule = require('firebase/auth');
+      const getReactNativePersistence = authModule.getReactNativePersistence;
+
+      if (!getReactNativePersistence) {
+        trackPackageWarning(
+          'firebase-auth',
+          'getReactNativePersistence not available, using default persistence'
+        );
+
+        if (__DEV__) {
+          console.log('Firebase Auth: getReactNativePersistence not available, using default persistence');
+        }
+        try {
+          return getAuth(app);
+        } catch {
+          return null;
+        }
+      }
+
+      const storage = config?.authStorage || {
+        getItem: (key: string) => AsyncStorage.getItem(key),
+        setItem: (key: string, value: string) => AsyncStorage.setItem(key, value),
+        removeItem: (key: string) => AsyncStorage.removeItem(key),
+      };
+
+      addPackageBreadcrumb('firebase-auth', 'Initializing with AsyncStorage persistence');
+
+      return initializeAuth(app, {
+        persistence: getReactNativePersistence(storage),
+      });
+    } catch (error) {
+      const errorObj = error instanceof Error ? error : new Error(String(error));
+      trackPackageError(errorObj, {
+        packageName: 'firebase-auth',
+        operation: 'initializeWithPersistence',
+      });
+
+      if (__DEV__) {
+        console.warn('Firebase Auth: Persistence initialization failed:', error);
+      }
+      try {
+        return getAuth(app);
+      } catch {
+        return null;
+      }
+    }
+  }
+}
+