@umituz/react-native-firebase 1.4.0 → 1.5.1

package/src/infrastructure/config/FirebaseConfigLoader.ts

@@ -10,56 +10,151 @@
 
 import type { FirebaseConfig } from '../../domain/value-objects/FirebaseConfig';
 
+/**
+ * Configuration source interface
+ */
+interface ConfigSource {
+  getApiKey(): string;
+  getAuthDomain(): string;
+  getProjectId(): string;
+  getStorageBucket(): string;
+  getMessagingSenderId(): string;
+  getAppId(): string;
+}
+
+/**
+ * Expo Constants configuration source
+ */
+class ExpoConfigSource implements ConfigSource {
+  private extra: any;
+
+  constructor() {
+    let Constants: any;
+    
+    try {
+      Constants = require('expo-constants');
+    } catch {
+      // expo-constants not available
+    }
+
+    const expoConfig = Constants?.expoConfig || Constants?.default?.expoConfig;
+    this.extra = expoConfig?.extra || {};
+  }
+
+  getApiKey(): string {
+    return this.extra?.firebaseApiKey || '';
+  }
+
+  getAuthDomain(): string {
+    return this.extra?.firebaseAuthDomain || '';
+  }
+
+  getProjectId(): string {
+    return this.extra?.firebaseProjectId || '';
+  }
+
+  getStorageBucket(): string {
+    return this.extra?.firebaseStorageBucket || '';
+  }
+
+  getMessagingSenderId(): string {
+    return this.extra?.firebaseMessagingSenderId || '';
+  }
+
+  getAppId(): string {
+    return this.extra?.firebaseAppId || '';
+  }
+}
+
+/**
+ * Environment variables configuration source
+ */
+class EnvironmentConfigSource implements ConfigSource {
+  getApiKey(): string {
+    return process.env.EXPO_PUBLIC_FIREBASE_API_KEY || 
+           process.env.FIREBASE_API_KEY || 
+           '';
+  }
+
+  getAuthDomain(): string {
+    return process.env.EXPO_PUBLIC_FIREBASE_AUTH_DOMAIN || 
+           process.env.FIREBASE_AUTH_DOMAIN || 
+           '';
+  }
+
+  getProjectId(): string {
+    return process.env.EXPO_PUBLIC_FIREBASE_PROJECT_ID || 
+           process.env.FIREBASE_PROJECT_ID || 
+           '';
+  }
+
+  getStorageBucket(): string {
+    return process.env.EXPO_PUBLIC_FIREBASE_STORAGE_BUCKET || 
+           process.env.FIREBASE_STORAGE_BUCKET || 
+           '';
+  }
+
+  getMessagingSenderId(): string {
+    return process.env.EXPO_PUBLIC_FIREBASE_MESSAGING_SENDER_ID || 
+           process.env.FIREBASE_MESSAGING_SENDER_ID || 
+           '';
+  }
+
+  getAppId(): string {
+    return process.env.EXPO_PUBLIC_FIREBASE_APP_ID || 
+           process.env.FIREBASE_APP_ID || 
+           '';
+  }
+}
+
+/**
+ * Configuration aggregator
+ */
+class ConfigAggregator {
+  private sources: ConfigSource[];
+
+  constructor() {
+    this.sources = [
+      new ExpoConfigSource(),
+      new EnvironmentConfigSource(),
+    ];
+  }
+
+  /**
+   * Get configuration value from first available source
+   */
+  private getValue(getter: (source: ConfigSource) => string): string {
+    for (const source of this.sources) {
+      const value = getter(source);
+      if (value && value.trim() !== '') {
+        return value;
+      }
+    }
+    return '';
+  }
+
+  /**
+   * Build Firebase configuration from all sources
+   */
+  buildConfig(): Partial<FirebaseConfig> {
+    return {
+      apiKey: this.getValue(source => source.getApiKey()),
+      authDomain: this.getValue(source => source.getAuthDomain()),
+      projectId: this.getValue(source => source.getProjectId()),
+      storageBucket: this.getValue(source => source.getStorageBucket()),
+      messagingSenderId: this.getValue(source => source.getMessagingSenderId()),
+      appId: this.getValue(source => source.getAppId()),
+    };
+  }
+}
+
 /**
  * Load Firebase configuration from Constants and environment variables
  * Returns null if no valid configuration is found
  */
 export function loadFirebaseConfig(): FirebaseConfig | null {
-  let Constants: any;
-  
-  // Try to load expo-constants (optional dependency)
-  try {
-    Constants = require('expo-constants');
-  } catch {
-    // expo-constants not available, skip
-  }
-
-  // Try both Constants.expoConfig and Constants.default.expoConfig
-  const expoConfig = Constants?.expoConfig || Constants?.default?.expoConfig;
-  const extra = expoConfig?.extra;
-
-  const config: Partial<FirebaseConfig> = {
-    apiKey:
-      extra?.firebaseApiKey ||
-      process.env.EXPO_PUBLIC_FIREBASE_API_KEY ||
-      process.env.FIREBASE_API_KEY ||
-      '',
-    authDomain:
-      extra?.firebaseAuthDomain ||
-      process.env.EXPO_PUBLIC_FIREBASE_AUTH_DOMAIN ||
-      process.env.FIREBASE_AUTH_DOMAIN ||
-      '',
-    projectId:
-      extra?.firebaseProjectId ||
-      process.env.EXPO_PUBLIC_FIREBASE_PROJECT_ID ||
-      process.env.FIREBASE_PROJECT_ID ||
-      '',
-    storageBucket:
-      extra?.firebaseStorageBucket ||
-      process.env.EXPO_PUBLIC_FIREBASE_STORAGE_BUCKET ||
-      process.env.FIREBASE_STORAGE_BUCKET ||
-      '',
-    messagingSenderId:
-      extra?.firebaseMessagingSenderId ||
-      process.env.EXPO_PUBLIC_FIREBASE_MESSAGING_SENDER_ID ||
-      process.env.FIREBASE_MESSAGING_SENDER_ID ||
-      '',
-    appId:
-      extra?.firebaseAppId ||
-      process.env.EXPO_PUBLIC_FIREBASE_APP_ID ||
-      process.env.FIREBASE_APP_ID ||
-      '',
-  };
+  const aggregator = new ConfigAggregator();
+  const config = aggregator.buildConfig();
 
   // Only return config if required fields are present and not empty
   if (

package/src/infrastructure/config/initializers/FirebaseAppInitializer.ts

@@ -4,34 +4,67 @@
  * Single Responsibility: Initialize Firebase App instance
  */
 
-import { initializeApp, getApps, FirebaseApp } from 'firebase/app';
 import type { FirebaseConfig } from '../../../domain/value-objects/FirebaseConfig';
 import { FirebaseInitializationError } from '../../../domain/errors/FirebaseError';
 
+export type FirebaseApp = any;
+
+declare const initializeApp: any;
+declare const getApps: any;
+
 /**
- * Initializes Firebase App
+ * Firebase configuration mapper
  */
-export class FirebaseAppInitializer {
+class FirebaseConfigMapper {
   /**
-   * Initialize or get existing Firebase App
+   * Map domain config to Firebase SDK config
    */
-  static initialize(config: FirebaseConfig): FirebaseApp {
-    // Return existing app if already initialized
-    const existingApps = getApps();
-    if (existingApps.length > 0) {
-      return existingApps[0];
+  static toFirebaseConfig(config: FirebaseConfig): Record<string, any> {
+    return {
+      apiKey: config.apiKey,
+      authDomain: config.authDomain,
+      projectId: config.projectId,
+      storageBucket: config.storageBucket,
+      messagingSenderId: config.messagingSenderId,
+      appId: config.appId,
+    };
+  }
+}
+
+/**
+ * Firebase App manager
+ */
+class FirebaseAppManager {
+  /**
+   * Check if Firebase App is already initialized
+   */
+  static isInitialized(): boolean {
+    try {
+      const existingApps = getApps();
+      return existingApps.length > 0;
+    } catch {
+      return false;
     }
+  }
 
+  /**
+   * Get existing Firebase App instance
+   */
+  static getExistingApp(): FirebaseApp | null {
     try {
-      const firebaseConfig = {
-        apiKey: config.apiKey,
-        authDomain: config.authDomain,
-        projectId: config.projectId,
-        storageBucket: config.storageBucket,
-        messagingSenderId: config.messagingSenderId,
-        appId: config.appId,
-      };
+      const existingApps = getApps();
+      return existingApps.length > 0 ? existingApps[0] : null;
+    } catch {
+      return null;
+    }
+  }
 
+  /**
+   * Create new Firebase App instance
+   */
+  static createApp(config: FirebaseConfig): FirebaseApp {
+    try {
+      const firebaseConfig = FirebaseConfigMapper.toFirebaseConfig(config);
       return initializeApp(firebaseConfig);
     } catch (error) {
       throw new FirebaseInitializationError(
@@ -44,14 +77,21 @@ export class FirebaseAppInitializer {
   }
 }
 
+/**
+ * Initializes Firebase App
+ */
+export class FirebaseAppInitializer {
+  /**
+   * Initialize or get existing Firebase App
+   */
+  static initialize(config: FirebaseConfig): FirebaseApp {
+    // Return existing app if already initialized
+    const existingApp = FirebaseAppManager.getExistingApp();
+    if (existingApp) {
+      return existingApp;
+    }
 
-
-
-
-
-
-
-
-
-
-
+    // Create new app
+    return FirebaseAppManager.createApp(config);
+  }
+}

package/src/infrastructure/config/validators/FirebaseConfigValidator.ts

@@ -8,43 +8,76 @@ import type { FirebaseConfig } from '../../../domain/value-objects/FirebaseConfi
 import { FirebaseConfigurationError } from '../../../domain/errors/FirebaseError';
 
 /**
- * Validates Firebase configuration
+ * Validation rule interface
  */
-export class FirebaseConfigValidator {
-  /**
-   * Validate Firebase configuration
-   * @throws {FirebaseConfigurationError} If configuration is invalid
-   */
-  static validate(config: FirebaseConfig): void {
-    if (!config.apiKey || typeof config.apiKey !== 'string') {
+interface ValidationRule {
+  validate(config: FirebaseConfig): void;
+}
+
+/**
+ * Required field validation rule
+ */
+class RequiredFieldRule implements ValidationRule {
+  constructor(
+    private fieldName: string,
+    private getter: (config: FirebaseConfig) => string | undefined
+  ) {}
+
+  validate(config: FirebaseConfig): void {
+    const value = this.getter(config);
+    
+    if (!value || typeof value !== 'string') {
       throw new FirebaseConfigurationError(
-        'Firebase API Key is required and must be a string'
+        `Firebase ${this.fieldName} is required and must be a string`
       );
     }
 
-    if (!config.authDomain || typeof config.authDomain !== 'string') {
-      throw new FirebaseConfigurationError(
-        'Firebase Auth Domain is required and must be a string'
-      );
+    if (value.trim().length === 0) {
+      throw new FirebaseConfigurationError(`Firebase ${this.fieldName} cannot be empty`);
     }
+  }
+}
 
-    if (!config.projectId || typeof config.projectId !== 'string') {
+/**
+ * Placeholder validation rule
+ */
+class PlaceholderRule implements ValidationRule {
+  constructor(
+    private fieldName: string,
+    private getter: (config: FirebaseConfig) => string | undefined,
+    private placeholder: string
+  ) {}
+
+  validate(config: FirebaseConfig): void {
+    const value = this.getter(config);
+    
+    if (value && value.includes(this.placeholder)) {
       throw new FirebaseConfigurationError(
-        'Firebase Project ID is required and must be a string'
+        `Please replace placeholder values with actual Firebase credentials for ${this.fieldName}`
       );
     }
+  }
+}
 
-    if (config.apiKey.trim().length === 0) {
-      throw new FirebaseConfigurationError('Firebase API Key cannot be empty');
-    }
+/**
+ * Firebase Configuration Validator
+ */
+export class FirebaseConfigValidator {
+  private static rules: ValidationRule[] = [
+    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'),
+  ];
 
-    if (
-      config.apiKey.includes('your_firebase_api_key') ||
-      config.projectId.includes('your-project-id')
-    ) {
-      throw new FirebaseConfigurationError(
-        'Please replace placeholder values with actual Firebase credentials'
-      );
+  /**
+   * Validate Firebase configuration
+   * @throws {FirebaseConfigurationError} If configuration is invalid
+   */
+  static validate(config: FirebaseConfig): void {
+    for (const rule of this.rules) {
+      rule.validate(config);
     }
   }
 }