@umituz/react-native-firebase 1.7.0 → 1.7.3

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

@@ -0,0 +1,125 @@
+/**
+ * Native Crashlytics Adapter
+ * Single Responsibility: Handle Firebase Crashlytics native implementation
+ */
+
+export interface CrashlyticsInstance {
+  setUserId(userId: string): Promise<void>;
+  setAttributes(attributes: Record<string, string>): Promise<void>;
+  recordError(error: Error): Promise<void>;
+  log(message: string): Promise<void>;
+}
+
+export interface NativeCrashlyticsAdapter {
+  getCrashlytics(): CrashlyticsInstance;
+  setUserId(crashlytics: CrashlyticsInstance, userId: string): Promise<void>;
+  setAttributes(crashlytics: CrashlyticsInstance, attributes: Record<string, string>): Promise<void>;
+  recordError(crashlytics: CrashlyticsInstance, error: Error): Promise<void>;
+  log(crashlytics: CrashlyticsInstance, message: string): Promise<void>;
+}
+
+interface NativeCrashlyticsModuleFunction {
+  (): CrashlyticsInstance;
+}
+
+interface NativeCrashlyticsModuleObject {
+  default: () => CrashlyticsInstance;
+}
+
+type NativeCrashlyticsModule = NativeCrashlyticsModuleFunction | NativeCrashlyticsModuleObject;
+
+let nativeCrashlyticsModule: NativeCrashlyticsModule | null = null;
+let isModuleLoaded = false;
+
+function loadCrashlyticsModule(): void {
+  if (isModuleLoaded) return;
+  
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    require('@react-native-firebase/app');
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const crashlytics = require('@react-native-firebase/crashlytics');
+    nativeCrashlyticsModule = crashlytics;
+  } catch {
+    // @react-native-firebase/crashlytics not available
+  } finally {
+    isModuleLoaded = true;
+  }
+}
+
+function getCrashlyticsInstance(): CrashlyticsInstance | null {
+  if (!isModuleLoaded) {
+    loadCrashlyticsModule();
+  }
+  
+  if (!nativeCrashlyticsModule) return null;
+
+  try {
+    if (typeof nativeCrashlyticsModule === 'function') {
+      return nativeCrashlyticsModule();
+    }
+    if ('default' in nativeCrashlyticsModule && typeof nativeCrashlyticsModule.default === 'function') {
+      return nativeCrashlyticsModule.default();
+    }
+  } catch (error) {
+    /* eslint-disable-next-line no-console */
+    if (__DEV__) {
+      console.warn('[Crashlytics] Failed to get instance:', error);
+    }
+  }
+  
+  return null;
+}
+
+export const nativeCrashlyticsAdapter: NativeCrashlyticsAdapter | null = {
+  getCrashlytics(): CrashlyticsInstance {
+    const instance = getCrashlyticsInstance();
+    if (!instance) {
+      throw new Error('Crashlytics not initialized');
+    }
+    return instance;
+  },
+  async setUserId(crashlytics: CrashlyticsInstance, userId: string): Promise<void> {
+    try {
+      await crashlytics.setUserId(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 {
+      await crashlytics.setAttributes(attributes);
+    } 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 crashlytics.recordError(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 crashlytics.log(message);
+    } catch (error) {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.warn('[Crashlytics] Failed to log message:', error);
+      }
+    }
+  },
+};

package/src/crashlytics/infrastructure/services/FirebaseCrashlyticsService.ts

@@ -0,0 +1,99 @@
+/**
+ * Firebase Crashlytics Service
+ * Single Responsibility: Orchestrate Crashlytics operations
+ */
+
+import { crashlyticsInitializerService } from './crashlytics-initializer.service';
+import { crashlyticsErrorService } from './crashlytics-error.service';
+import { crashlyticsUserService } from './crashlytics-user.service';
+import type { CrashlyticsInstance } from '../adapters/native-crashlytics.adapter';
+
+export interface ICrashlyticsService {
+  init(userId?: string, attributes?: Record<string, string>): Promise<void>;
+  logError(error: Error, context?: string): Promise<void>;
+  log(message: string): Promise<void>;
+  setAttribute(key: string, value: string): Promise<void>;
+  setAttributes(attributes: Record<string, string>): Promise<void>;
+  clearUserData(): Promise<void>;
+  destroy(): Promise<void>;
+}
+
+class FirebaseCrashlyticsService implements ICrashlyticsService {
+  private isInitialized = false;
+  private userId: string | null = null;
+  private attributes: Record<string, string> = {};
+  private crashlytics: CrashlyticsInstance | null = null;
+  private isDestroyed = false;
+
+  async init(userId?: string, attributes?: Record<string, string>): Promise<void> {
+    if (this.isDestroyed) {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.warn('[Crashlytics] Cannot initialize destroyed service');
+      }
+      return;
+    }
+
+    try {
+      this.crashlytics = crashlyticsInitializerService.initialize();
+
+      if (this.crashlytics) {
+        if (userId) {
+          this.userId = userId;
+          await crashlyticsUserService.setUserId(this.crashlytics, userId);
+        }
+        
+        if (attributes) {
+          await this.setAttributes(attributes);
+        }
+      }
+    } catch (err) {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.warn('[Crashlytics] Init failed:', err);
+      }
+    } finally {
+      this.isInitialized = true;
+    }
+  }
+
+  async logError(error: Error, context?: string): Promise<void> {
+    if (this.isDestroyed) return;
+    await crashlyticsErrorService.logError(this.crashlytics, error, context);
+  }
+
+  async log(message: string): Promise<void> {
+    if (this.isDestroyed) return;
+    await crashlyticsErrorService.log(this.crashlytics, message);
+  }
+
+  async setAttribute(key: string, value: string): Promise<void> {
+    if (this.isDestroyed) return;
+    this.attributes[key] = value;
+    await crashlyticsUserService.setAttribute(this.crashlytics, key, value);
+  }
+
+  async setAttributes(attributes: Record<string, string>): Promise<void> {
+    if (this.isDestroyed) return;
+    await crashlyticsUserService.setAttributes(this.crashlytics, attributes);
+    Object.assign(this.attributes, attributes);
+  }
+
+  async clearUserData(): Promise<void> {
+    if (this.isDestroyed) return;
+    await crashlyticsUserService.clearUserData(this.crashlytics);
+    this.userId = null;
+    this.attributes = {};
+    this.isInitialized = false;
+  }
+
+  async destroy(): Promise<void> {
+    if (this.isDestroyed) return;
+    
+    await this.clearUserData();
+    this.crashlytics = null;
+    this.isDestroyed = true;
+  }
+}
+
+export const firebaseCrashlyticsService = new FirebaseCrashlyticsService();

package/src/crashlytics/infrastructure/services/crashlytics-error.service.ts

@@ -0,0 +1,67 @@
+/**
+ * Crashlytics Error Service
+ * Single Responsibility: Handle error logging operations
+ */
+
+import { nativeCrashlyticsAdapter } from '../adapters/native-crashlytics.adapter';
+import type { CrashlyticsInstance } from '../adapters/native-crashlytics.adapter';
+
+export class CrashlyticsErrorService {
+  /**
+   * Log error to Crashlytics
+   */
+  async logError(
+    crashlytics: CrashlyticsInstance | null,
+    error: Error,
+    context?: string,
+  ): Promise<void> {
+    try {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.error(`[Crashlytics] Error${context ? ` in ${context}` : ''}:`, error);
+      }
+
+      if (!crashlytics || !nativeCrashlyticsAdapter) {
+        return;
+      }
+
+      if (context) {
+        await nativeCrashlyticsAdapter.log(crashlytics, `Context: ${context}`);
+      }
+      await nativeCrashlyticsAdapter.log(
+        crashlytics,
+        `Error: ${error.name} - ${error.message}`,
+      );
+      await nativeCrashlyticsAdapter.recordError(crashlytics, error);
+    } catch (err) {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.warn('[Crashlytics] Failed to log error:', err);
+      }
+    }
+  }
+
+  /**
+   * Log message to Crashlytics
+   */
+  async log(crashlytics: CrashlyticsInstance | null, message: string): Promise<void> {
+    try {
+      if (!crashlytics || !nativeCrashlyticsAdapter) {
+        /* eslint-disable-next-line no-console */
+        if (__DEV__) {
+          console.log(`[Crashlytics] ${message}`);
+        }
+        return;
+      }
+
+      await nativeCrashlyticsAdapter.log(crashlytics, message);
+    } catch (err) {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.warn('[Crashlytics] Failed to log message:', err);
+      }
+    }
+  }
+}
+
+export const crashlyticsErrorService = new CrashlyticsErrorService();

package/src/crashlytics/infrastructure/services/crashlytics-initializer.service.ts

@@ -0,0 +1,31 @@
+/**
+ * Crashlytics Initializer Service
+ * Single Responsibility: Handle Crashlytics initialization logic
+ */
+
+import { nativeCrashlyticsAdapter } from '../adapters/native-crashlytics.adapter';
+import type { CrashlyticsInstance } from '../adapters/native-crashlytics.adapter';
+
+export class CrashlyticsInitializerService {
+  /**
+   * Initialize Crashlytics instance
+   * Returns null if Crashlytics is not available (e.g., on web)
+   */
+  initialize(): CrashlyticsInstance | null {
+    if (!nativeCrashlyticsAdapter) {
+      return null;
+    }
+
+    try {
+      return nativeCrashlyticsAdapter.getCrashlytics();
+    } catch (error) {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.warn('[Crashlytics] Initialization failed:', error);
+      }
+      return null;
+    }
+  }
+}
+
+export const crashlyticsInitializerService = new CrashlyticsInitializerService();

package/src/crashlytics/infrastructure/services/crashlytics-user.service.ts

@@ -0,0 +1,91 @@
+/**
+ * Crashlytics User Service
+ * Single Responsibility: Handle user-related Crashlytics operations
+ */
+
+import { nativeCrashlyticsAdapter } from '../adapters/native-crashlytics.adapter';
+import type { CrashlyticsInstance } from '../adapters/native-crashlytics.adapter';
+
+export class CrashlyticsUserService {
+  /**
+   * Set user ID
+   */
+  async setUserId(crashlytics: CrashlyticsInstance | null, userId: string): Promise<void> {
+    try {
+      if (!crashlytics || !nativeCrashlyticsAdapter) {
+        return;
+      }
+
+      await nativeCrashlyticsAdapter.setUserId(crashlytics, userId);
+    } catch (err) {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.warn('[Crashlytics] Failed to set user ID:', err);
+      }
+    }
+  }
+
+  /**
+   * Set attribute
+   */
+  async setAttribute(
+    crashlytics: CrashlyticsInstance | null,
+    key: string,
+    value: string,
+  ): Promise<void> {
+    try {
+      if (!crashlytics || !nativeCrashlyticsAdapter) {
+        return;
+      }
+
+      await nativeCrashlyticsAdapter.setAttributes(crashlytics, { [key]: value });
+    } catch (err) {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.warn('[Crashlytics] Failed to set attribute:', err);
+      }
+    }
+  }
+
+  /**
+   * Set multiple attributes
+   */
+  async setAttributes(
+    crashlytics: CrashlyticsInstance | null,
+    attributes: Record<string, string>,
+  ): Promise<void> {
+    try {
+      if (!crashlytics || !nativeCrashlyticsAdapter) {
+        return;
+      }
+
+      await nativeCrashlyticsAdapter.setAttributes(crashlytics, attributes);
+    } catch (err) {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.warn('[Crashlytics] Failed to set attributes:', err);
+      }
+    }
+  }
+
+  /**
+   * Clear user data
+   */
+  async clearUserData(crashlytics: CrashlyticsInstance | null): Promise<void> {
+    try {
+      if (!crashlytics || !nativeCrashlyticsAdapter) {
+        return;
+      }
+
+      await nativeCrashlyticsAdapter.setUserId(crashlytics, '');
+      await nativeCrashlyticsAdapter.setAttributes(crashlytics, {});
+    } catch (err) {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.warn('[Crashlytics] Failed to clear user data:', err);
+      }
+    }
+  }
+}
+
+export const crashlyticsUserService = new CrashlyticsUserService();

package/src/crashlytics/infrastructure/services/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Crashlytics Infrastructure Services
+ * Public API exports
+ */
+
+export { firebaseCrashlyticsService } from './FirebaseCrashlyticsService';
+export type { ICrashlyticsService } from './FirebaseCrashlyticsService';
+export { crashlyticsInitializerService } from './crashlytics-initializer.service';
+export { crashlyticsErrorService } from './crashlytics-error.service';
+export { crashlyticsUserService } from './crashlytics-user.service';
+

package/src/domain/errors/FirebaseError.ts

@@ -1,56 +1,38 @@
 /**
  * Firebase Domain Errors
- *
- * Domain-Driven Design: Error types for Firebase operations
+ * 
+ * Domain-Driven Design: Specialized error types for the Firebase domain
  */
 
 /**
- * Base Firebase Error
+ * Base Firebase error class
  */
 export class FirebaseError extends Error {
-  constructor(
-    message: string,
-    public readonly code?: string,
-    public readonly originalError?: unknown
-  ) {
-    super(message);
-    this.name = 'FirebaseError';
-    Object.setPrototypeOf(this, FirebaseError.prototype);
-  }
+    constructor(message: string, public code?: string, public cause?: any) {
+        super(message);
+        this.name = 'FirebaseError';
+        Object.setPrototypeOf(this, FirebaseError.prototype);
+    }
 }
 
 /**
- * Initialization Error
- * Thrown when Firebase client fails to initialize
+ * Initialization specific error
  */
 export class FirebaseInitializationError extends FirebaseError {
-  constructor(message: string, originalError?: unknown) {
-    super(message, 'INITIALIZATION_ERROR', originalError);
-    this.name = 'FirebaseInitializationError';
-    Object.setPrototypeOf(this, FirebaseInitializationError.prototype);
-  }
+    constructor(message: string, cause?: any) {
+        super(message, 'INITIALIZATION_ERROR', cause);
+        this.name = 'FirebaseInitializationError';
+        Object.setPrototypeOf(this, FirebaseInitializationError.prototype);
+    }
 }
 
 /**
- * Configuration Error
- * Thrown when required configuration is missing or invalid
+ * Configuration specific error
  */
 export class FirebaseConfigurationError extends FirebaseError {
-  constructor(message: string, originalError?: unknown) {
-    super(message, 'CONFIGURATION_ERROR', originalError);
-    this.name = 'FirebaseConfigurationError';
-    Object.setPrototypeOf(this, FirebaseConfigurationError.prototype);
-  }
+    constructor(message: string, cause?: any) {
+        super(message, 'CONFIGURATION_ERROR', cause);
+        this.name = 'FirebaseConfigurationError';
+        Object.setPrototypeOf(this, FirebaseConfigurationError.prototype);
+    }
 }
-
-// Note: FirebaseAnalyticsError, FirebaseCrashlyticsError, FirebaseAuthError, and FirebaseFirestoreError
-// have been moved to their respective packages:
-// - @umituz/react-native-firebase-analytics
-// - @umituz/react-native-firebase-crashlytics
-// - @umituz/react-native-firebase-auth
-// - @umituz/react-native-firestore
-
-
-
-
-

package/src/domain/value-objects/FirebaseConfig.ts

@@ -1,44 +1,14 @@
 /**
- * Firebase Configuration Value Object
- *
- * Domain-Driven Design: Value object for Firebase configuration
- */
-
-/**
- * Firebase Configuration
- * Required configuration for initializing Firebase client
+ * Firebase Config - Domain Layer
+ * 
+ * Domain-Driven Design: Value Object representing Firebase configuration parameters
  */
 export interface FirebaseConfig {
-  /**
-   * Firebase API Key
-   */
-  apiKey: string;
-
-  /**
-   * Firebase Auth Domain
-   */
-  authDomain: string;
-
-  /**
-   * Firebase Project ID
-   */
-  projectId: string;
-
-  /**
-   * Firebase Storage Bucket
-   */
-  storageBucket?: string;
-
-  /**
-   * Firebase Messaging Sender ID
-   */
-  messagingSenderId?: string;
-
-  /**
-   * Firebase App ID
-   */
-  appId?: string;
+    apiKey: string;
+    authDomain: string;
+    projectId: string;
+    storageBucket?: string;
+    messagingSenderId?: string;
+    appId?: string;
+    measurementId?: string;
 }
-
-// Validation moved to FirebaseConfigValidator class (SOLID: Single Responsibility)
-

package/src/index.ts

@@ -1,26 +1,19 @@
 /**
- * React Native Firebase - Minimal Core Package
+ * React Native Firebase - Unified Package
  *
  * Domain-Driven Design (DDD) Architecture
  *
- * This package provides ONLY Firebase App initialization.
- * For other Firebase services, use dedicated packages:
- * - @umituz/react-native-firebase-auth - Firebase Authentication
- * - @umituz/react-native-firebase-analytics - Firebase Analytics
- * - @umituz/react-native-firebase-crashlytics - Firebase Crashlytics
- * - @umituz/react-native-firestore - Firestore initialization and utilities
- *
- * Architecture:
- * - domain: Entities, value objects, errors (business logic)
- * - application: Ports (interfaces)
- * - infrastructure: Firebase client implementation
+ * This package provides Firebase App initialization and core services:
+ * - Analytics
+ * - Crashlytics
  *
  * Usage:
  *   import { initializeFirebase, getFirebaseApp } from '@umituz/react-native-firebase';
+ *   import { firebaseAnalyticsService } from '@umituz/react-native-firebase';
  */
 
 // =============================================================================
-// DOMAIN LAYER - Business Logic
+// CORE - App Initialization & Type Definitions
 // =============================================================================
 
 export {
@@ -30,17 +23,8 @@ export {
 } from './domain/errors/FirebaseError';
 
 export type { FirebaseConfig } from './domain/value-objects/FirebaseConfig';
-
-// =============================================================================
-// APPLICATION LAYER - Ports
-// =============================================================================
-
 export type { IFirebaseClient } from './application/ports/IFirebaseClient';
 
-// =============================================================================
-// INFRASTRUCTURE LAYER - Implementation
-// =============================================================================
-
 export {
   initializeFirebase,
   getFirebaseApp,
@@ -56,3 +40,15 @@ export type {
   FirebaseApp,
 } from './infrastructure/config/FirebaseClient';
 
+// =============================================================================
+// ANALYTICS MODULE
+// =============================================================================
+
+export * from './analytics';
+
+// =============================================================================
+// CRASHLYTICS MODULE
+// =============================================================================
+
+export * from './crashlytics';
+

package/src/infrastructure/config/FirebaseClient.ts

@@ -309,11 +309,11 @@ class ServiceInitializer {
     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;
@@ -396,6 +396,15 @@ export async function initializeAllFirebaseServices(
 
   const { auth, analytics, crashlytics } = await ServiceInitializer.initializeServices();
 
+  // Initialize services if they have an init method
+  if (analytics && typeof analytics.init === 'function') {
+    await analytics.init();
+  }
+
+  if (crashlytics && typeof crashlytics.init === 'function') {
+    await crashlytics.init();
+  }
+
   return {
     app,
     auth,