@umituz/react-native-firebase 1.4.0 → 1.5.1

package/lib/infrastructure/config/validators/FirebaseConfigValidator.js

@@ -0,0 +1,62 @@
+/**
+ * Firebase Configuration Validator
+ *
+ * Single Responsibility: Validates Firebase configuration
+ */
+import { FirebaseConfigurationError } from '../../../domain/errors/FirebaseError';
+/**
+ * Required field validation rule
+ */
+class RequiredFieldRule {
+    constructor(fieldName, getter) {
+        this.fieldName = fieldName;
+        this.getter = getter;
+    }
+    validate(config) {
+        const value = this.getter(config);
+        if (!value || typeof value !== 'string') {
+            throw new FirebaseConfigurationError(`Firebase ${this.fieldName} is required and must be a string`);
+        }
+        if (value.trim().length === 0) {
+            throw new FirebaseConfigurationError(`Firebase ${this.fieldName} cannot be empty`);
+        }
+    }
+}
+/**
+ * Placeholder validation rule
+ */
+class PlaceholderRule {
+    constructor(fieldName, getter, placeholder) {
+        this.fieldName = fieldName;
+        this.getter = getter;
+        this.placeholder = placeholder;
+    }
+    validate(config) {
+        const value = this.getter(config);
+        if (value && value.includes(this.placeholder)) {
+            throw new FirebaseConfigurationError(`Please replace placeholder values with actual Firebase credentials for ${this.fieldName}`);
+        }
+    }
+}
+/**
+ * Firebase Configuration Validator
+ */
+export class FirebaseConfigValidator {
+    /**
+     * Validate Firebase configuration
+     * @throws {FirebaseConfigurationError} If configuration is invalid
+     */
+    static validate(config) {
+        for (const rule of this.rules) {
+            rule.validate(config);
+        }
+    }
+}
+FirebaseConfigValidator.rules = [
+    new RequiredFieldRule('API Key', config => config.apiKey),
+    new RequiredFieldRule('Auth Domain', config => config.authDomain),
+    new RequiredFieldRule('Project ID', config => config.projectId),
+    new PlaceholderRule('API Key', config => config.apiKey, 'your_firebase_api_key'),
+    new PlaceholderRule('Project ID', config => config.projectId, 'your-project-id'),
+];
+//# sourceMappingURL=FirebaseConfigValidator.js.map

package/lib/infrastructure/config/validators/FirebaseConfigValidator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FirebaseConfigValidator.js","sourceRoot":"","sources":["../../../../src/infrastructure/config/validators/FirebaseConfigValidator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,0BAA0B,EAAE,MAAM,sCAAsC,CAAC;AASlF;;GAEG;AACH,MAAM,iBAAiB;IACrB,YACU,SAAiB,EACjB,MAAsD;QADtD,cAAS,GAAT,SAAS,CAAQ;QACjB,WAAM,GAAN,MAAM,CAAgD;IAC7D,CAAC;IAEJ,QAAQ,CAAC,MAAsB;QAC7B,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAElC,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YACxC,MAAM,IAAI,0BAA0B,CAClC,YAAY,IAAI,CAAC,SAAS,mCAAmC,CAC9D,CAAC;QACJ,CAAC;QAED,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC9B,MAAM,IAAI,0BAA0B,CAAC,YAAY,IAAI,CAAC,SAAS,kBAAkB,CAAC,CAAC;QACrF,CAAC;IACH,CAAC;CACF;AAED;;GAEG;AACH,MAAM,eAAe;IACnB,YACU,SAAiB,EACjB,MAAsD,EACtD,WAAmB;QAFnB,cAAS,GAAT,SAAS,CAAQ;QACjB,WAAM,GAAN,MAAM,CAAgD;QACtD,gBAAW,GAAX,WAAW,CAAQ;IAC1B,CAAC;IAEJ,QAAQ,CAAC,MAAsB;QAC7B,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAElC,IAAI,KAAK,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAC9C,MAAM,IAAI,0BAA0B,CAClC,0EAA0E,IAAI,CAAC,SAAS,EAAE,CAC3F,CAAC;QACJ,CAAC;IACH,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,uBAAuB;IASlC;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,MAAsB;QACpC,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YAC9B,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QACxB,CAAC;IACH,CAAC;;AAhBc,6BAAK,GAAqB;IACvC,IAAI,iBAAiB,CAAC,SAAS,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC;IACzD,IAAI,iBAAiB,CAAC,aAAa,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC;IACjE,IAAI,iBAAiB,CAAC,YAAY,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC;IAC/D,IAAI,eAAe,CAAC,SAAS,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC;IAChF,IAAI,eAAe,CAAC,YAAY,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,SAAS,EAAE,iBAAiB,CAAC;CACjF,CAAC"}

package/package.json

@@ -1,12 +1,17 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "1.4.0",
+  "version": "1.5.1",
   "description": "Firebase core package for React Native apps - Centralized initialization for all Firebase services (App, Auth, Analytics, Crashlytics). Use dedicated packages for service-specific operations.",
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
   "scripts": {
+    "build": "tsc",
     "typecheck": "tsc --noEmit",
     "lint": "tsc --noEmit",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "prepublishOnly": "npm run build",
     "version:patch": "npm version patch -m 'chore: release v%s'",
     "version:minor": "npm version minor -m 'chore: release v%s'",
     "version:major": "npm version major -m 'chore: release v%s'"
@@ -31,17 +36,27 @@
     "react-native": ">=0.74.0"
   },
   "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.0.1",
     "@types/react": "^18.2.45",
     "@types/react-native": "^0.73.0",
+    "chalk": "^4.1.2",
+    "find-up": "^8.0.0",
     "firebase": "^11.0.0",
+    "jest": "^30.2.0",
+    "p-limit": "^7.2.0",
+    "p-try": "^3.0.0",
+    "path-exists": "^5.0.0",
     "react": "^18.2.0",
     "react-native": "^0.74.0",
-    "typescript": "^5.3.3"
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.9.3"
   },
   "publishConfig": {
     "access": "public"
   },
   "files": [
+    "lib",
     "src",
     "README.md",
     "LICENSE"

package/src/application/ports/IFirebaseClient.ts

@@ -5,7 +5,7 @@
  * Defines the contract for Firebase client operations
  */
 
-import type { FirebaseApp } from 'firebase/app';
+export type FirebaseApp = any;
 
 /**
  * Firebase Client Interface

package/src/infrastructure/config/FirebaseClient.ts

@@ -13,104 +13,208 @@
  * - Dependency Inversion: Depends on abstractions (interfaces), not concrete implementations
  */
 
-import type { FirebaseApp } from 'firebase/app';
 import type { FirebaseConfig } from '../../domain/value-objects/FirebaseConfig';
-import { FirebaseInitializationError } from '../../domain/errors/FirebaseError';
 import type { IFirebaseClient } from '../../application/ports/IFirebaseClient';
 import { FirebaseConfigValidator } from './validators/FirebaseConfigValidator';
 import { FirebaseAppInitializer } from './initializers/FirebaseAppInitializer';
 import { loadFirebaseConfig } from './FirebaseConfigLoader';
 
+export type FirebaseApp = any;
+
+// Development environment check
+declare const __DEV__: boolean;
+
 /**
- * Firebase Client Singleton
- * Orchestrates Firebase initialization using specialized initializers
+ * Firebase Client State Manager
+ * Manages the state of Firebase initialization
  */
-class FirebaseClientSingleton implements IFirebaseClient {
-  private static instance: FirebaseClientSingleton | null = null;
+class FirebaseClientState {
   private app: FirebaseApp | null = null;
   private initializationError: string | null = null;
 
-  private constructor() {
-    // Private constructor to enforce singleton pattern
+  /**
+   * Get the current Firebase app instance
+   */
+  getApp(): FirebaseApp | null {
+    return this.app;
   }
 
   /**
-   * Get singleton instance
+   * Set the Firebase app instance
    */
-  static getInstance(): FirebaseClientSingleton {
-    if (!FirebaseClientSingleton.instance) {
-      FirebaseClientSingleton.instance = new FirebaseClientSingleton();
-    }
-    return FirebaseClientSingleton.instance;
+  setApp(app: FirebaseApp | null): void {
+    this.app = app;
   }
 
   /**
-   * 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
+   * Check if client is initialized
    */
-  initialize(config: FirebaseConfig): FirebaseApp | null {
+  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
+ */
+class FirebaseInitializationOrchestrator {
+  /**
+   * Initialize Firebase with configuration
+   */
+  static initialize(
+    config: FirebaseConfig,
+    state: FirebaseClientState
+  ): FirebaseApp | null {
     // Return existing instance if already initialized
-    if (this.app) {
-      return this.app;
+    if (state.isInitialized()) {
+      if (__DEV__) {
+        console.log('[Firebase] Already initialized, returning existing instance');
+      }
+      return state.getApp();
     }
 
     // Don't retry if initialization already failed
-    if (this.initializationError) {
+    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
-      this.app = FirebaseAppInitializer.initialize(config);
+      const app = FirebaseAppInitializer.initialize(config);
+      state.setApp(app);
+
+      if (__DEV__) {
+        console.log('[Firebase] Successfully initialized');
+      }
 
-      return this.app;
+      return app;
     } catch (error) {
-      this.initializationError =
+      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;
     }
   }
 
   /**
-   * Get the Firebase app instance
-   * Auto-initializes from Constants/environment if not already initialized
-   * Returns null if config is not available (offline mode)
-   * @returns Firebase app instance or null if not initialized
+   * Auto-initialize Firebase from environment
    */
-  getApp(): FirebaseApp | null {
-    // Auto-initialize if not already initialized
-    if (!this.app && !this.initializationError) {
-      const autoConfig = loadFirebaseConfig();
-      if (autoConfig) {
-        this.initialize(autoConfig);
+  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;
+  }
+}
+
+/**
+ * Firebase Client Singleton
+ * Orchestrates Firebase initialization using specialized initializers
+ */
+class FirebaseClientSingleton implements IFirebaseClient {
+  private static instance: FirebaseClientSingleton | null = null;
+  private state: FirebaseClientState;
+
+  private constructor() {
+    this.state = new FirebaseClientState();
+  }
+
+  /**
+   * Get singleton instance
+   */
+  static getInstance(): FirebaseClientSingleton {
+    if (!FirebaseClientSingleton.instance) {
+      FirebaseClientSingleton.instance = new FirebaseClientSingleton();
     }
+    return FirebaseClientSingleton.instance;
+  }
 
-    // Return null if not initialized (offline mode - no error)
-    return this.app || null;
+  /**
+   * 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.app !== null;
+    return this.state.isInitialized();
   }
 
   /**
    * Get initialization error if any
    */
   getInitializationError(): string | null {
-    return this.initializationError;
+    return this.state.getInitializationError();
   }
 
   /**
@@ -118,8 +222,7 @@ class FirebaseClientSingleton implements IFirebaseClient {
    * Useful for testing
    */
   reset(): void {
-    this.app = null;
-    this.initializationError = null;
+    this.state.reset();
   }
 }
 
@@ -178,6 +281,79 @@ 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 optional Firebase service with error handling
+   */
+  private static initializeService(
+    packageName: string,
+    initializerName: string,
+    isAsync = false
+  ): any | null {
+    try {
+      const serviceModule = require(packageName);
+      const service = serviceModule[initializerName];
+      
+      if (isAsync && typeof service.init === 'function') {
+        return service;
+      }
+      
+      return typeof service === 'function' ? service() : service;
+    } catch {
+      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...');
+    }
+
+    const auth = this.initializeService(
+      '@umituz/react-native-firebase-auth',
+      'initializeFirebaseAuth'
+    );
+
+    const analytics = this.initializeService(
+      '@umituz/react-native-firebase-analytics',
+      'firebaseAnalyticsService',
+      true
+    );
+
+    const crashlytics = this.initializeService(
+      '@umituz/react-native-firebase-crashlytics',
+      'firebaseCrashlyticsService',
+      true
+    );
+
+    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
@@ -203,22 +379,10 @@ export function autoInitializeFirebase(): FirebaseApp | null {
  */
 export async function initializeAllFirebaseServices(
   config?: FirebaseConfig
-): Promise<{
-  app: FirebaseApp | null;
-  auth: any | null;
-  analytics: any | null;
-  crashlytics: any | null;
-}> {
-  // 1. Initialize Firebase App
-  let app: FirebaseApp | null = null;
-  if (config) {
-    app = initializeFirebase(config);
-  } else {
-    app = autoInitializeFirebase();
-  }
+): Promise<ServiceInitializationResult> {
+  const app = config ? initializeFirebase(config) : autoInitializeFirebase();
 
   if (!app) {
-    // Firebase App not available - return null for all services
     return {
       app: null,
       auth: null,
@@ -227,37 +391,7 @@ export async function initializeAllFirebaseServices(
     };
   }
 
-  // 2. Initialize Firebase Auth (if package is available)
-  let auth: any | null = null;
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const { initializeFirebaseAuth } = require('@umituz/react-native-firebase-auth');
-    auth = initializeFirebaseAuth();
-  } catch {
-    // @umituz/react-native-firebase-auth not available
-  }
-
-  // 3. Initialize Firebase Analytics (if package is available)
-  let analytics: any | null = null;
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const { firebaseAnalyticsService } = require('@umituz/react-native-firebase-analytics');
-    await firebaseAnalyticsService.init();
-    analytics = firebaseAnalyticsService;
-  } catch {
-    // @umituz/react-native-firebase-analytics not available
-  }
-
-  // 4. Initialize Firebase Crashlytics (if package is available)
-  let crashlytics: any | null = null;
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const { firebaseCrashlyticsService } = require('@umituz/react-native-firebase-crashlytics');
-    await firebaseCrashlyticsService.init();
-    crashlytics = firebaseCrashlyticsService;
-  } catch {
-    // @umituz/react-native-firebase-crashlytics not available
-  }
+  const { auth, analytics, crashlytics } = await ServiceInitializer.initializeServices();
 
   return {
     app,
@@ -287,8 +421,4 @@ export function getFirebaseInitializationError(): string | null {
  */
 export function resetFirebaseClient(): void {
   firebaseClient.reset();
-}
-
-// Export types
-export type { FirebaseApp } from 'firebase/app';
-export type { FirebaseConfig } from '../../domain/value-objects/FirebaseConfig';
+}