@umituz/react-native-firebase 1.12.2 → 1.13.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "1.12.2",
+  "version": "1.13.1",
   "description": "Unified Firebase package for React Native apps - Centralized initialization and core services (Analytics, Crashlytics).",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/analytics/infrastructure/adapters/native-analytics.adapter.ts

@@ -2,16 +2,21 @@
  * Native Analytics Adapter
  * Single Responsibility: Handle Firebase Analytics native implementation
  * Uses React Native Firebase v23+ modular API
+ *
+ * NOTE: This adapter uses optional import to support Expo Go.
+ * Native modules are only available in development builds or standalone apps.
  */
 
-import {
-  getAnalytics,
-  logEvent,
-  setUserId,
-  setUserProperties,
-  resetAnalyticsData,
-  setAnalyticsCollectionEnabled,
-} from '@react-native-firebase/analytics';
+// Optional import - will be null in Expo Go
+let nativeAnalytics: any = null;
+try {
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  nativeAnalytics = require('@react-native-firebase/analytics');
+} catch {
+  // Native module not available (e.g., Expo Go)
+  // eslint-disable-next-line no-console
+  if (__DEV__) console.warn('⚠️ Firebase Analytics: Native module not available');
+}
 
 export interface NativeAnalyticsAdapter {
   getAnalytics(): any;
@@ -22,33 +27,37 @@ export interface NativeAnalyticsAdapter {
   setAnalyticsCollectionEnabled(analytics: any, enabled: boolean): Promise<void>;
 }
 
-export const nativeAnalyticsAdapter: NativeAnalyticsAdapter = {
-  getAnalytics(): any {
-    return getAnalytics();
-  },
-  async logEvent(
-    analytics: any,
-    eventName: string,
-    params?: Record<string, any>,
-  ): Promise<void> {
-    await logEvent(analytics, eventName, params);
-  },
-  async setUserId(analytics: any, userId: string): Promise<void> {
-    await setUserId(analytics, userId);
-  },
-  async setUserProperties(
-    analytics: any,
-    properties: Record<string, string>,
-  ): Promise<void> {
-    await setUserProperties(analytics, properties);
-  },
-  async resetAnalyticsData(analytics: any): Promise<void> {
-    await resetAnalyticsData(analytics);
-  },
-  async setAnalyticsCollectionEnabled(
-    analytics: any,
-    enabled: boolean,
-  ): Promise<void> {
-    await setAnalyticsCollectionEnabled(analytics, enabled);
-  },
-};
+declare const __DEV__: boolean;
+
+export const nativeAnalyticsAdapter: NativeAnalyticsAdapter | null = nativeAnalytics
+  ? {
+      getAnalytics(): any {
+        return nativeAnalytics.getAnalytics();
+      },
+      async logEvent(
+        analytics: any,
+        eventName: string,
+        params?: Record<string, any>,
+      ): Promise<void> {
+        await nativeAnalytics.logEvent(analytics, eventName, params);
+      },
+      async setUserId(analytics: any, userId: string): Promise<void> {
+        await nativeAnalytics.setUserId(analytics, userId);
+      },
+      async setUserProperties(
+        analytics: any,
+        properties: Record<string, string>,
+      ): Promise<void> {
+        await nativeAnalytics.setUserProperties(analytics, properties);
+      },
+      async resetAnalyticsData(analytics: any): Promise<void> {
+        await nativeAnalytics.resetAnalyticsData(analytics);
+      },
+      async setAnalyticsCollectionEnabled(
+        analytics: any,
+        enabled: boolean,
+      ): Promise<void> {
+        await nativeAnalytics.setAnalyticsCollectionEnabled(analytics, enabled);
+      },
+    }
+  : null;

package/src/crashlytics/infrastructure/adapters/native-crashlytics.adapter.ts

@@ -2,18 +2,22 @@
  * Native Crashlytics Adapter
  * Single Responsibility: Handle Firebase Crashlytics native implementation
  * Uses React Native Firebase v23+ modular API
+ *
+ * NOTE: This adapter uses optional import to support Expo Go.
+ * Native modules are only available in development builds or standalone apps.
  */
 
-import {
-  getCrashlytics,
-  log,
-  recordError,
-  setAttribute,
-  setUserId,
-} from '@react-native-firebase/crashlytics';
-import type { FirebaseCrashlyticsTypes } from '@react-native-firebase/crashlytics';
+// Optional import - will be null in Expo Go
+let nativeCrashlytics: any = null;
+try {
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  nativeCrashlytics = require('@react-native-firebase/crashlytics');
+} catch {
+  // Native module not available (e.g., Expo Go)
+  // Silent fail - crashlytics is optional
+}
 
-export type CrashlyticsInstance = FirebaseCrashlyticsTypes.Module;
+export type CrashlyticsInstance = any;
 
 export interface NativeCrashlyticsAdapter {
   getCrashlytics(): CrashlyticsInstance;
@@ -23,54 +27,58 @@ export interface NativeCrashlyticsAdapter {
   log(crashlytics: CrashlyticsInstance, message: string): Promise<void>;
 }
 
-export const nativeCrashlyticsAdapter: NativeCrashlyticsAdapter = {
-  getCrashlytics(): CrashlyticsInstance {
-    return getCrashlytics();
-  },
-  async setUserId(crashlytics: CrashlyticsInstance, userId: string): Promise<void> {
-    try {
-      await setUserId(crashlytics, userId);
-    } catch (error) {
-      /* eslint-disable-next-line no-console */
-      if (__DEV__) {
-        console.warn('[Crashlytics] Failed to set user ID:', error);
-      }
-    }
-  },
-  async setAttributes(
-    crashlytics: CrashlyticsInstance,
-    attributes: Record<string, string>,
-  ): Promise<void> {
-    try {
-      // Set each attribute individually using the modular API
-      for (const [key, value] of Object.entries(attributes)) {
-        await setAttribute(crashlytics, key, value);
-      }
-    } catch (error) {
-      /* eslint-disable-next-line no-console */
-      if (__DEV__) {
-        console.warn('[Crashlytics] Failed to set attributes:', error);
-      }
-    }
-  },
-  async recordError(crashlytics: CrashlyticsInstance, error: Error): Promise<void> {
-    try {
-      await recordError(crashlytics, error);
-    } catch (err) {
-      /* eslint-disable-next-line no-console */
-      if (__DEV__) {
-        console.warn('[Crashlytics] Failed to record error:', err);
-      }
-    }
-  },
-  async log(crashlytics: CrashlyticsInstance, message: string): Promise<void> {
-    try {
-      await log(crashlytics, message);
-    } catch (error) {
-      /* eslint-disable-next-line no-console */
-      if (__DEV__) {
-        console.warn('[Crashlytics] Failed to log message:', error);
-      }
+declare const __DEV__: boolean;
+
+export const nativeCrashlyticsAdapter: NativeCrashlyticsAdapter | null = nativeCrashlytics
+  ? {
+      getCrashlytics(): CrashlyticsInstance {
+        return nativeCrashlytics.getCrashlytics();
+      },
+      async setUserId(crashlytics: CrashlyticsInstance, userId: string): Promise<void> {
+        try {
+          await nativeCrashlytics.setUserId(crashlytics, userId);
+        } catch (error) {
+          /* eslint-disable-next-line no-console */
+          if (__DEV__) {
+            console.warn('[Crashlytics] Failed to set user ID:', error);
+          }
+        }
+      },
+      async setAttributes(
+        crashlytics: CrashlyticsInstance,
+        attributes: Record<string, string>,
+      ): Promise<void> {
+        try {
+          // Set each attribute individually using the modular API
+          for (const [key, value] of Object.entries(attributes)) {
+            await nativeCrashlytics.setAttribute(crashlytics, key, value);
+          }
+        } catch (error) {
+          /* eslint-disable-next-line no-console */
+          if (__DEV__) {
+            console.warn('[Crashlytics] Failed to set attributes:', error);
+          }
+        }
+      },
+      async recordError(crashlytics: CrashlyticsInstance, error: Error): Promise<void> {
+        try {
+          await nativeCrashlytics.recordError(crashlytics, error);
+        } catch (err) {
+          /* eslint-disable-next-line no-console */
+          if (__DEV__) {
+            console.warn('[Crashlytics] Failed to record error:', err);
+          }
+        }
+      },
+      async log(crashlytics: CrashlyticsInstance, message: string): Promise<void> {
+        try {
+          await nativeCrashlytics.log(crashlytics, message);
+        } catch (error) {
+          /* eslint-disable-next-line no-console */
+          if (__DEV__) {
+            console.warn('[Crashlytics] Failed to log message:', error);
+          }
+        }
+      },
     }
-  },
-};
+  : null;

package/src/index.ts

@@ -38,6 +38,9 @@ export {
 
 export type {
   FirebaseApp,
+  AuthInitializer,
+  ServiceInitializationOptions,
+  ServiceInitializationResult,
 } from './infrastructure/config/FirebaseClient';
 
 // =============================================================================

package/src/infrastructure/config/FirebaseClient.ts

@@ -7,6 +7,9 @@
  * IMPORTANT: This package does NOT read from .env files.
  * Configuration must be provided by the application.
  *
+ * NOTE: Auth initialization is handled by the main app via callback.
+ * This removes the need for dynamic require() which causes issues in production.
+ *
  * SOLID Principles:
  * - Single Responsibility: Only orchestrates initialization, delegates to specialized classes
  * - Open/Closed: Extensible through configuration, closed for modification
@@ -15,154 +18,28 @@
 
 import type { FirebaseConfig } from '../../domain/value-objects/FirebaseConfig';
 import type { IFirebaseClient } from '../../application/ports/IFirebaseClient';
-import { FirebaseConfigValidator } from './validators/FirebaseConfigValidator';
+import type { FirebaseApp } from './initializers/FirebaseAppInitializer';
+import { FirebaseClientState } from './state/FirebaseClientState';
+import { FirebaseInitializationOrchestrator } from './orchestrators/FirebaseInitializationOrchestrator';
 import {
-  FirebaseAppInitializer,
-  type FirebaseApp,
-} from './initializers/FirebaseAppInitializer';
+  FirebaseServiceInitializer,
+  type AuthInitializer,
+  type ServiceInitializationOptions,
+} from './services/FirebaseServiceInitializer';
 import { loadFirebaseConfig } from './FirebaseConfigLoader';
-import { firebaseAnalyticsService } from '../../analytics';
-import { firebaseCrashlyticsService } from '../../crashlytics';
 
-export type { FirebaseApp };
+export type { FirebaseApp, AuthInitializer, ServiceInitializationOptions };
 
-// Development environment check
 declare const __DEV__: boolean;
 
 /**
- * Firebase Client State Manager
- * Manages the state of Firebase initialization
- */
-class FirebaseClientState {
-  private app: FirebaseApp | null = null;
-  private initializationError: string | null = null;
-
-  /**
-   * Get the current Firebase app instance
-   */
-  getApp(): FirebaseApp | null {
-    return this.app;
-  }
-
-  /**
-   * Set the Firebase app instance
-   */
-  setApp(app: FirebaseApp | null): void {
-    this.app = app;
-  }
-
-  /**
-   * Check if client is initialized
-   */
-  isInitialized(): boolean {
-    return this.app !== null;
-  }
-
-  /**
-   * Get initialization error if any
-   */
-  getInitializationError(): string | null {
-    return this.initializationError;
-  }
-
-  /**
-   * Set initialization error
-   */
-  setInitializationError(error: string | null): void {
-    this.initializationError = error;
-  }
-
-  /**
-   * Reset the client state
-   */
-  reset(): void {
-    this.app = null;
-    this.initializationError = null;
-  }
-}
-
-/**
- * Firebase Initialization Orchestrator
- * Handles the initialization logic
+ * Service initialization result interface
  */
-class FirebaseInitializationOrchestrator {
-  /**
-   * Initialize Firebase with configuration
-   */
-  static initialize(
-    config: FirebaseConfig,
-    state: FirebaseClientState
-  ): FirebaseApp | null {
-    // Return existing instance if already initialized
-    if (state.isInitialized()) {
-      if (__DEV__) {
-        console.log('[Firebase] Already initialized, returning existing instance');
-      }
-      return state.getApp();
-    }
-
-    // Don't retry if initialization already failed
-    if (state.getInitializationError()) {
-      if (__DEV__) {
-        console.log('[Firebase] Previous initialization failed, skipping retry');
-      }
-      return null;
-    }
-
-    try {
-      if (__DEV__) {
-        console.log('[Firebase] Initializing with projectId:', config.projectId);
-      }
-
-      // Validate configuration
-      FirebaseConfigValidator.validate(config);
-
-      // Initialize Firebase App
-      const app = FirebaseAppInitializer.initialize(config);
-      state.setApp(app);
-
-      if (__DEV__) {
-        console.log('[Firebase] Successfully initialized');
-      }
-
-      return app;
-    } catch (error) {
-      const errorMessage =
-        error instanceof Error
-          ? error.message
-          : 'Failed to initialize Firebase client';
-      state.setInitializationError(errorMessage);
-
-      if (__DEV__) {
-        console.error('[Firebase] Initialization failed:', errorMessage);
-      }
-
-      return null;
-    }
-  }
-
-  /**
-   * Auto-initialize Firebase from environment
-   */
-  static autoInitialize(state: FirebaseClientState): FirebaseApp | null {
-    if (state.isInitialized() || state.getInitializationError()) {
-      return state.getApp();
-    }
-
-    const autoConfig = loadFirebaseConfig();
-    if (autoConfig) {
-      if (__DEV__) {
-        console.log('[Firebase] Auto-initializing with environment config');
-      }
-      return this.initialize(autoConfig, state);
-    }
-
-    if (__DEV__) {
-      console.log('[Firebase] No configuration found for auto-initialization');
-    }
-
-    return null;
-  }
+export interface ServiceInitializationResult {
+  app: FirebaseApp | null;
+  auth: unknown;
+  analytics: unknown;
+  crashlytics: unknown;
 }
 
 /**
@@ -177,9 +54,6 @@ class FirebaseClientSingleton implements IFirebaseClient {
     this.state = new FirebaseClientState();
   }
 
-  /**
-   * Get singleton instance
-   */
   static getInstance(): FirebaseClientSingleton {
     if (!FirebaseClientSingleton.instance) {
       FirebaseClientSingleton.instance = new FirebaseClientSingleton();
@@ -187,86 +61,39 @@ class FirebaseClientSingleton implements IFirebaseClient {
     return FirebaseClientSingleton.instance;
   }
 
-  /**
-   * Initialize Firebase client with configuration
-   * Configuration must be provided by the application (not from .env)
-   *
-   * @param config - Firebase configuration
-   * @returns Firebase app instance or null if initialization fails
-   */
   initialize(config: FirebaseConfig): FirebaseApp | null {
     return FirebaseInitializationOrchestrator.initialize(config, this.state);
   }
 
-  /**
-   * Get the Firebase app instance
-   * Auto-initializes from Constants/environment if not already initialized
-   * Returns null if config is not available (offline mode - no error)
-   * @returns Firebase app instance or null if not initialized
-   */
   getApp(): FirebaseApp | null {
     return FirebaseInitializationOrchestrator.autoInitialize(this.state);
   }
 
-  /**
-   * Check if client is initialized
-   */
   isInitialized(): boolean {
     return this.state.isInitialized();
   }
 
-  /**
-   * Get initialization error if any
-   */
   getInitializationError(): string | null {
     return this.state.getInitializationError();
   }
 
-  /**
-   * Reset the client instance
-   * Useful for testing
-   */
   reset(): void {
     this.state.reset();
   }
 }
 
-/**
- * Singleton instance
- */
 export const firebaseClient = FirebaseClientSingleton.getInstance();
 
 /**
- * Initialize Firebase client
- * This is the main entry point for applications
- *
- * @param config - Firebase configuration (must be provided by app, not from .env)
- * @returns Firebase app instance or null if initialization fails
- *
- * @example
- * ```typescript
- * import { initializeFirebase } from '@umituz/react-native-firebase';
- *
- * const config = {
- *   apiKey: 'your-api-key',
- *   authDomain: 'your-project.firebaseapp.com',
- *   projectId: 'your-project-id',
- * };
- *
- * const app = initializeFirebase(config);
- * ```
+ * Initialize Firebase client with configuration
  */
-export function initializeFirebase(
-  config: FirebaseConfig
-): FirebaseApp | null {
+export function initializeFirebase(config: FirebaseConfig): FirebaseApp | null {
   return firebaseClient.initialize(config);
 }
 
 /**
  * Get Firebase app instance
  * Auto-initializes from Constants/environment if not already initialized
- * Returns null if config is not available (offline mode - no error)
- * @returns Firebase app instance or null if not initialized
  */
 export function getFirebaseApp(): FirebaseApp | null {
   return firebaseClient.getApp();
@@ -274,9 +101,6 @@ export function getFirebaseApp(): FirebaseApp | null {
 
 /**
  * Auto-initialize Firebase from Constants/environment
- * Called automatically when getFirebaseApp() is first accessed
- * Can be called manually to initialize early
- * @returns Firebase app instance or null if initialization fails
  */
 export function autoInitializeFirebase(): FirebaseApp | null {
   const config = loadFirebaseConfig();
@@ -286,97 +110,30 @@ export function autoInitializeFirebase(): FirebaseApp | null {
   return null;
 }
 
-/**
- * Service initialization result interface
- */
-interface ServiceInitializationResult {
-  app: FirebaseApp | null;
-  auth: any | null;
-  analytics: any | null;
-  crashlytics: any | null;
-}
-
-/**
- * Service initializer class for better separation of concerns
- */
-class ServiceInitializer {
-  /**
-   * Initialize Firebase Auth from external package
-   */
-  private static initializeAuth(): any | null {
-    try {
-      const authModule = require('@umituz/react-native-firebase-auth');
-      const initializeFirebaseAuth = authModule.initializeFirebaseAuth;
-
-      if (typeof initializeFirebaseAuth !== 'function') {
-        if (__DEV__) {
-          console.warn('[Firebase] initializeFirebaseAuth is not a function');
-        }
-        return null;
-      }
-
-      const auth = initializeFirebaseAuth();
-      return auth;
-    } catch (error) {
-      if (__DEV__) {
-        console.warn('[Firebase] Auth package not available:', error instanceof Error ? error.message : 'Unknown error');
-      }
-      return null;
-    }
-  }
-
-  /**
-   * Initialize all optional Firebase services
-   */
-  static async initializeServices(): Promise<{
-    auth: any | null;
-    analytics: any | null;
-    crashlytics: any | null;
-  }> {
-    if (__DEV__) {
-      console.log('[Firebase] Initializing optional services...');
-    }
-
-    // Initialize auth from external package
-    const auth = this.initializeAuth();
-
-    // Analytics and Crashlytics are local modules - use imported services directly
-    const analytics = firebaseAnalyticsService;
-    const crashlytics = firebaseCrashlyticsService;
-
-    if (__DEV__) {
-      console.log('[Firebase] Services initialized - Auth:', !!auth, 'Analytics:', !!analytics, 'Crashlytics:', !!crashlytics);
-    }
-
-    return { auth, analytics, crashlytics };
-  }
-}
-
 /**
  * Initialize all Firebase services (App, Auth, Analytics, Crashlytics)
  * This is the main entry point for applications - call this once at app startup
- * All services will be initialized automatically if Firebase App is available
- * 
- * @param config - Optional Firebase configuration (if not provided, will auto-load from Constants/env)
+ *
+ * IMPORTANT: Auth initialization is handled via callback to avoid require() issues.
+ * The main app should pass the authInitializer callback from react-native-firebase-auth.
+ *
+ * @param config - Optional Firebase configuration
+ * @param options - Optional service initialization options including authInitializer
  * @returns Object with initialization results for each service
- * 
+ *
  * @example
  * ```typescript
  * import { initializeAllFirebaseServices } from '@umituz/react-native-firebase';
- * 
- * // Auto-initialize from Constants/env
- * const result = await initializeAllFirebaseServices();
- * 
- * // Or provide config explicitly
- * const result = await initializeAllFirebaseServices({
- *   apiKey: 'your-api-key',
- *   projectId: 'your-project-id',
- *   // ...
+ * import { initializeFirebaseAuth } from '@umituz/react-native-firebase-auth';
+ *
+ * const result = await initializeAllFirebaseServices(undefined, {
+ *   authInitializer: () => initializeFirebaseAuth(),
  * });
  * ```
  */
 export async function initializeAllFirebaseServices(
-  config?: FirebaseConfig
+  config?: FirebaseConfig,
+  options?: ServiceInitializationOptions
 ): Promise<ServiceInitializationResult> {
   const app = config ? initializeFirebase(config) : autoInitializeFirebase();
 
@@ -389,15 +146,24 @@ export async function initializeAllFirebaseServices(
     };
   }
 
-  const { auth, analytics, crashlytics } = await ServiceInitializer.initializeServices();
+  const { auth, analytics, crashlytics } =
+    await FirebaseServiceInitializer.initializeServices(options);
 
-  // Initialize services if they have an init method
-  if (analytics && typeof analytics.init === 'function') {
-    await analytics.init();
+  if (analytics && typeof (analytics as { init?: () => Promise<void> }).init === 'function') {
+    await (analytics as { init: () => Promise<void> }).init();
   }
 
-  if (crashlytics && typeof crashlytics.init === 'function') {
-    await crashlytics.init();
+  if (crashlytics && typeof (crashlytics as { init?: () => Promise<void> }).init === 'function') {
+    await (crashlytics as { init: () => Promise<void> }).init();
+  }
+
+  if (__DEV__) {
+    console.log('[Firebase] All services initialized:', {
+      app: !!app,
+      auth: !!auth,
+      analytics: !!analytics,
+      crashlytics: !!crashlytics,
+    });
   }
 
   return {
@@ -424,8 +190,7 @@ export function getFirebaseInitializationError(): string | null {
 
 /**
  * Reset Firebase client instance
- * Useful for testing
  */
 export function resetFirebaseClient(): void {
   firebaseClient.reset();
-}
+}

package/src/infrastructure/config/orchestrators/FirebaseInitializationOrchestrator.ts

@@ -0,0 +1,84 @@
+/**
+ * Firebase Initialization Orchestrator
+ * Handles the initialization logic for Firebase App
+ *
+ * Single Responsibility: Only orchestrates Firebase App initialization
+ */
+
+import type { FirebaseConfig } from '../../../domain/value-objects/FirebaseConfig';
+import type { FirebaseApp } from '../initializers/FirebaseAppInitializer';
+import { FirebaseConfigValidator } from '../validators/FirebaseConfigValidator';
+import { FirebaseAppInitializer } from '../initializers/FirebaseAppInitializer';
+import { loadFirebaseConfig } from '../FirebaseConfigLoader';
+import type { FirebaseClientState } from '../state/FirebaseClientState';
+
+declare const __DEV__: boolean;
+
+export class FirebaseInitializationOrchestrator {
+  static initialize(
+    config: FirebaseConfig,
+    state: FirebaseClientState
+  ): FirebaseApp | null {
+    if (state.isInitialized()) {
+      if (__DEV__) {
+        console.log('[Firebase] Already initialized, returning existing instance');
+      }
+      return state.getApp();
+    }
+
+    if (state.getInitializationError()) {
+      if (__DEV__) {
+        console.log('[Firebase] Previous initialization failed, skipping retry');
+      }
+      return null;
+    }
+
+    try {
+      if (__DEV__) {
+        console.log('[Firebase] Initializing with projectId:', config.projectId);
+      }
+
+      FirebaseConfigValidator.validate(config);
+      const app = FirebaseAppInitializer.initialize(config);
+      state.setApp(app);
+
+      if (__DEV__) {
+        console.log('[Firebase] Successfully initialized');
+      }
+
+      return app;
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error
+          ? error.message
+          : 'Failed to initialize Firebase client';
+      state.setInitializationError(errorMessage);
+
+      if (__DEV__) {
+        console.error('[Firebase] Initialization failed:', errorMessage);
+      }
+
+      return null;
+    }
+  }
+
+  static autoInitialize(state: FirebaseClientState): FirebaseApp | null {
+    if (state.isInitialized() || state.getInitializationError()) {
+      return state.getApp();
+    }
+
+    const autoConfig = loadFirebaseConfig();
+    if (autoConfig) {
+      if (__DEV__) {
+        console.log('[Firebase] Auto-initializing with environment config');
+      }
+      return this.initialize(autoConfig, state);
+    }
+
+    if (__DEV__) {
+      console.log('[Firebase] No configuration found for auto-initialization');
+    }
+
+    return null;
+  }
+}

package/src/infrastructure/config/services/FirebaseServiceInitializer.ts

@@ -0,0 +1,69 @@
+/**
+ * Firebase Service Initializer
+ * Handles initialization of Firebase services (Analytics, Crashlytics)
+ *
+ * NOTE: Auth initialization is handled by the main app via callback.
+ * This removes the need for dynamic require() which causes issues in production.
+ *
+ * Single Responsibility: Only initializes Firebase services
+ */
+
+import { firebaseAnalyticsService } from '../../../analytics';
+import { firebaseCrashlyticsService } from '../../../crashlytics';
+
+declare const __DEV__: boolean;
+
+export type AuthInitializer = () => unknown;
+
+export interface ServiceInitializationOptions {
+  authInitializer?: AuthInitializer;
+}
+
+export interface ServiceInitializationResult {
+  auth: unknown;
+  analytics: typeof firebaseAnalyticsService;
+  crashlytics: typeof firebaseCrashlyticsService;
+}
+
+export class FirebaseServiceInitializer {
+  static async initializeServices(
+    options?: ServiceInitializationOptions
+  ): Promise<ServiceInitializationResult> {
+    if (__DEV__) {
+      console.log('[Firebase] Initializing services...');
+    }
+
+    let auth: unknown = null;
+    if (options?.authInitializer) {
+      try {
+        auth = options.authInitializer();
+        if (__DEV__) {
+          console.log('[Firebase] Auth initialized via callback');
+        }
+      } catch (error) {
+        if (__DEV__) {
+          console.warn(
+            '[Firebase] Auth initialization failed:',
+            error instanceof Error ? error.message : 'Unknown error'
+          );
+        }
+      }
+    }
+
+    const analytics = firebaseAnalyticsService;
+    const crashlytics = firebaseCrashlyticsService;
+
+    if (__DEV__) {
+      console.log(
+        '[Firebase] Services initialized - Auth:',
+        !!auth,
+        'Analytics:',
+        !!analytics,
+        'Crashlytics:',
+        !!crashlytics
+      );
+    }
+
+    return { auth, analytics, crashlytics };
+  }
+}

package/src/infrastructure/config/state/FirebaseClientState.ts

@@ -0,0 +1,38 @@
+/**
+ * Firebase Client State Manager
+ * Manages the state of Firebase initialization
+ *
+ * Single Responsibility: Only manages initialization state
+ */
+
+import type { FirebaseApp } from '../initializers/FirebaseAppInitializer';
+
+export class FirebaseClientState {
+  private app: FirebaseApp | null = null;
+  private initializationError: string | null = null;
+
+  getApp(): FirebaseApp | null {
+    return this.app;
+  }
+
+  setApp(app: FirebaseApp | null): void {
+    this.app = app;
+  }
+
+  isInitialized(): boolean {
+    return this.app !== null;
+  }
+
+  getInitializationError(): string | null {
+    return this.initializationError;
+  }
+
+  setInitializationError(error: string | null): void {
+    this.initializationError = error;
+  }
+
+  reset(): void {
+    this.app = null;
+    this.initializationError = null;
+  }
+}