@umituz/react-native-firebase 1.7.0 → 1.7.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "1.7.0",
-  "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.",
+  "version": "1.7.2",
+  "description": "Unified Firebase package for React Native apps - Centralized initialization and core services (Analytics, Crashlytics).",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "scripts": {
@@ -12,7 +12,8 @@
     "react-native",
     "firebase",
     "firebase-core",
-    "firestore",
+    "analytics",
+    "crashlytics",
     "ddd",
     "domain-driven-design"
   ],
@@ -23,6 +24,10 @@
     "url": "https://github.com/umituz/react-native-firebase"
   },
   "peerDependencies": {
+    "@react-native-firebase/analytics": ">=23.0.0",
+    "@react-native-firebase/app": ">=23.0.0",
+    "@react-native-firebase/crashlytics": ">=23.0.0",
+    "@react-navigation/native": ">=6.0.0",
     "firebase": ">=11.0.0",
     "react": ">=18.2.0",
     "react-native": ">=0.74.0"

package/src/analytics/application/ports/IAnalyticsService.ts

@@ -0,0 +1,92 @@
+/**
+ * Analytics Service Interface
+ * 
+ * Application Layer - Port
+ * Defines the contract for analytics operations
+ */
+
+export interface IAnalyticsService {
+    /**
+     * Initialize the analytics service
+     * @param userId Optional user ID to associate with analytics
+     */
+    init(userId?: string): Promise<void>;
+
+    /**
+     * Set the current user ID
+     * @param userId The unique user identifier
+     */
+    setUserId(userId: string): Promise<void>;
+
+    /**
+     * Log a custom event
+     * @param eventName Name of the event
+     * @param params Optional key-value pairs of parameters
+     */
+    logEvent(
+        eventName: string,
+        params?: Record<string, string | number | boolean | null>,
+    ): Promise<void>;
+
+    /**
+     * Set a user property
+     * @param key Property key
+     * @param value Property value
+     */
+    setUserProperty(key: string, value: string): Promise<void>;
+
+    /**
+     * Set multiple user properties at once
+     * @param properties Key-value pairs of user properties
+     */
+    setUserProperties(properties: Record<string, string>): Promise<void>;
+
+    /**
+     * Clear all user data and reset initialization state
+     */
+    clearUserData(): Promise<void>;
+
+    /**
+     * Get the current user ID if set
+     */
+    getCurrentUserId(): string | null;
+
+    /**
+     * Log a screen view event
+     */
+    logScreenView(params: { screen_name: string; screen_class?: string }): Promise<void>;
+
+    /**
+     * Log time spent on a screen
+     */
+    logScreenTime(params: {
+        screen_name: string;
+        screen_class?: string;
+        time_spent_seconds: number;
+    }): Promise<void>;
+
+    /**
+     * Log a navigation event between screens
+     */
+    logNavigation(params: {
+        from_screen: string;
+        to_screen: string;
+        screen_class?: string;
+    }): Promise<void>;
+
+    /**
+     * Log a button click event
+     */
+    logButtonClick(params: {
+        button_id: string;
+        button_name?: string;
+        screen_name: string;
+        screen_class?: string;
+    }): Promise<void>;
+
+    /**
+     * Enable or disable analytics collection
+     * @param enabled Whether collection should be enabled
+     */
+    setAnalyticsCollectionEnabled(enabled: boolean): Promise<void>;
+}

package/src/analytics/index.ts

@@ -0,0 +1,19 @@
+/**
+ * Firebase Analytics Module
+ */
+
+export { firebaseAnalyticsService } from './infrastructure/services/FirebaseAnalyticsService';
+export type { IAnalyticsService } from './infrastructure/services/FirebaseAnalyticsService';
+export { analyticsInitializerService } from './infrastructure/services/analytics-initializer.service';
+export type { AnalyticsInstance } from './infrastructure/services/analytics-initializer.service';
+export { analyticsEventService } from './infrastructure/services/analytics-event.service';
+export { analyticsUserService } from './infrastructure/services/analytics-user.service';
+export { performanceTracker } from './infrastructure/services/PerformanceTracker';
+
+// Hooks
+export { useScreenView } from './presentation/hooks/useScreenView';
+export { useScreenTime } from './presentation/hooks/useScreenTime';
+export { useNavigationTracking } from './presentation/hooks/useNavigationTracking';
+
+// Utility Functions
+export { trackButtonClick, trackCRUDOperation } from './presentation/utils/analyticsUtils';

package/src/analytics/infrastructure/adapters/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Analytics Adapters
+ * Platform-specific implementations
+ */
+
+export { webAnalyticsAdapter } from './web-analytics.adapter';
+export type { WebAnalyticsAdapter } from './web-analytics.adapter';
+export { nativeAnalyticsAdapter } from './native-analytics.adapter';
+export type { NativeAnalyticsAdapter } from './native-analytics.adapter';
+

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

@@ -0,0 +1,91 @@
+/**
+ * Native Analytics Adapter
+ * Single Responsibility: Handle Firebase Analytics native implementation
+ */
+
+export interface NativeAnalyticsAdapter {
+  getAnalytics(): any;
+  logEvent(analytics: any, eventName: string, params?: Record<string, any>): Promise<void>;
+  setUserId(analytics: any, userId: string): Promise<void>;
+  setUserProperties(analytics: any, properties: Record<string, string>): Promise<void>;
+  resetAnalyticsData(analytics: any): Promise<void>;
+  setAnalyticsCollectionEnabled(analytics: any, enabled: boolean): Promise<void>;
+}
+
+let nativeAnalyticsModule: any = null;
+
+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 analyticsModule = require('@react-native-firebase/analytics');
+
+  // @react-native-firebase/analytics returns a factory function via createModuleNamespace
+  // Handle CommonJS (require) and ES6 (import) module formats
+  // The module can be:
+  // 1. Direct function: analyticsModule()
+  // 2. Object with default: analyticsModule.default()
+  // 3. Object with __esModule: analyticsModule.default() or analyticsModule()
+
+  if (typeof analyticsModule === 'function') {
+    // Direct function export
+    nativeAnalyticsModule = analyticsModule;
+  } else if (analyticsModule && typeof analyticsModule.default === 'function') {
+    // ES6 default export in CommonJS format
+    nativeAnalyticsModule = analyticsModule.default;
+  } else if (analyticsModule && typeof analyticsModule === 'object') {
+    // Try to use the module itself if it's callable
+    // Some bundlers wrap the function in an object
+    nativeAnalyticsModule = analyticsModule;
+  }
+} catch (error) {
+  /* eslint-disable-next-line no-console */
+  if (__DEV__) {
+    console.warn('⚠️ Firebase Analytics: Native module not available', error);
+  }
+}
+
+export const nativeAnalyticsAdapter: NativeAnalyticsAdapter | null =
+  nativeAnalyticsModule && (typeof nativeAnalyticsModule === 'function' || typeof nativeAnalyticsModule === 'object')
+    ? {
+      getAnalytics(): any {
+        // Try calling as function first, then as object method
+        if (typeof nativeAnalyticsModule === 'function') {
+          return nativeAnalyticsModule();
+        }
+        // If it's an object, try calling it directly (some modules are callable objects)
+        if (typeof nativeAnalyticsModule === 'object' && nativeAnalyticsModule.default) {
+          return typeof nativeAnalyticsModule.default === 'function'
+            ? nativeAnalyticsModule.default()
+            : nativeAnalyticsModule.default;
+        }
+        return nativeAnalyticsModule;
+      },
+      async logEvent(
+        analytics: any,
+        eventName: string,
+        params?: Record<string, any>,
+      ): Promise<void> {
+        await analytics.logEvent(eventName, params);
+      },
+      async setUserId(analytics: any, userId: string): Promise<void> {
+        await analytics.setUserId(userId);
+      },
+      async setUserProperties(
+        analytics: any,
+        properties: Record<string, string>,
+      ): Promise<void> {
+        await analytics.setUserProperties(properties);
+      },
+      async resetAnalyticsData(analytics: any): Promise<void> {
+        await analytics.resetAnalyticsData();
+      },
+      async setAnalyticsCollectionEnabled(
+        analytics: any,
+        enabled: boolean,
+      ): Promise<void> {
+        await analytics.setAnalyticsCollectionEnabled(enabled);
+      },
+    }
+    : null;
+

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

@@ -0,0 +1,63 @@
+/**
+ * Web Analytics Adapter
+ * Single Responsibility: Handle Firebase Analytics web implementation
+ */
+
+export interface WebAnalyticsAdapter {
+  isSupported(): Promise<boolean>;
+  getAnalytics(app: any): any;
+  logEvent(analytics: any, eventName: string, params?: Record<string, any>): Promise<void>;
+  setUserId(analytics: any, userId: string): Promise<void>;
+  setUserProperties(analytics: any, properties: Record<string, string>): Promise<void>;
+}
+
+let webAnalyticsModule: any = null;
+
+try {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const {
+    getAnalytics,
+    logEvent,
+    setUserId,
+    setUserProperties,
+    isSupported,
+  } = require('firebase/analytics');
+  webAnalyticsModule = {
+    getAnalytics,
+    logEvent,
+    setUserId,
+    setUserProperties,
+    isSupported,
+  };
+} catch {
+  // firebase/analytics not available
+}
+
+export const webAnalyticsAdapter: WebAnalyticsAdapter | null = webAnalyticsModule
+  ? {
+      async isSupported(): Promise<boolean> {
+        if (!webAnalyticsModule.isSupported) return true;
+        return webAnalyticsModule.isSupported();
+      },
+      getAnalytics(app: any): any {
+        return webAnalyticsModule.getAnalytics(app);
+      },
+      async logEvent(
+        analytics: any,
+        eventName: string,
+        params?: Record<string, any>,
+      ): Promise<void> {
+        await webAnalyticsModule.logEvent(analytics, eventName, params);
+      },
+      async setUserId(analytics: any, userId: string): Promise<void> {
+        await webAnalyticsModule.setUserId(analytics, userId);
+      },
+      async setUserProperties(
+        analytics: any,
+        properties: Record<string, string>,
+      ): Promise<void> {
+        await webAnalyticsModule.setUserProperties(analytics, properties);
+      },
+    }
+  : null;
+

package/src/analytics/infrastructure/services/FirebaseAnalyticsService.ts

@@ -0,0 +1,187 @@
+/**
+ * Firebase Analytics Service
+ * Single Responsibility: Orchestrate analytics operations
+ * Delegates to specialized services for initialization, events, and user management
+ */
+
+import { analyticsInitializerService } from './analytics-initializer.service';
+import { analyticsEventService } from './analytics-event.service';
+import { analyticsUserService } from './analytics-user.service';
+import type { AnalyticsInstance } from './analytics-initializer.service';
+import type { IAnalyticsService } from '../../application/ports/IAnalyticsService';
+import { nativeAnalyticsAdapter } from '../adapters/native-analytics.adapter';
+
+export type { IAnalyticsService };
+
+class FirebaseAnalyticsService implements IAnalyticsService {
+  private isInitialized = false;
+  private userId: string | null = null;
+  private userProperties: Record<string, string> = {};
+  private analyticsInstance: AnalyticsInstance | null = null;
+
+  async init(userId?: string): Promise<void> {
+    if (this.isInitialized) {
+      if (userId && userId !== this.userId) {
+        await this.setUserId(userId);
+      }
+      return;
+    }
+
+    try {
+      this.analyticsInstance = await analyticsInitializerService.initialize();
+
+      if (this.analyticsInstance) {
+        if (userId) {
+          this.userId = userId;
+          await analyticsUserService.setUserId(this.analyticsInstance, userId);
+        }
+
+        // Explicitly enable analytics collection to ensure it's active
+        await this.setAnalyticsCollectionEnabled(true);
+
+        /* eslint-disable-next-line no-console */
+        if (__DEV__) {
+          console.log('✅ Firebase Analytics initialized successfully', {
+            platform: this.analyticsInstance.platform,
+            userId: userId || 'guest',
+          });
+        }
+      } else {
+        /* eslint-disable-next-line no-console */
+        if (__DEV__) {
+          console.warn('⚠️ Firebase Analytics: Initialization returned null instance', {
+            reason: 'Native module not available or web analytics not supported',
+            note: 'Events will be logged to console but not sent to Firebase',
+          });
+        }
+      }
+    } catch (_error) {
+      // Analytics is non-critical, fail silently
+    } finally {
+      this.isInitialized = true;
+    }
+  }
+
+  async setAnalyticsCollectionEnabled(enabled: boolean): Promise<void> {
+    if (!this.analyticsInstance) {
+      return;
+    }
+
+    try {
+      if (this.analyticsInstance.platform === 'native' && nativeAnalyticsAdapter) {
+        await nativeAnalyticsAdapter.setAnalyticsCollectionEnabled(
+          this.analyticsInstance.instance,
+          enabled,
+        );
+      }
+    } catch (_error) {
+      // Fail silently
+    }
+  }
+
+  async setUserId(userId: string): Promise<void> {
+    if (!this.isInitialized || !this.analyticsInstance) {
+      // Not initialized yet, will be set during init
+      return;
+    }
+
+    if (this.userId === userId) {
+      // Already set to this user ID
+      return;
+    }
+
+    try {
+      this.userId = userId;
+      await analyticsUserService.setUserId(this.analyticsInstance, userId);
+    } catch (_error) {
+      // Analytics is non-critical, fail silently
+    }
+  }
+
+  async logEvent(
+    eventName: string,
+    params?: Record<string, string | number | boolean | null>,
+  ): Promise<void> {
+    if (!this.isInitialized) {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.warn('⚠️ Firebase Analytics: Cannot log event - Service not initialized', {
+          eventName,
+        });
+      }
+      return;
+    }
+    await analyticsEventService.logEvent(this.analyticsInstance, eventName, params);
+  }
+
+  async setUserProperty(key: string, value: string): Promise<void> {
+    this.userProperties[key] = value;
+    await analyticsUserService.setUserProperty(this.analyticsInstance, key, value);
+  }
+
+  async setUserProperties(properties: Record<string, string>): Promise<void> {
+    await analyticsUserService.setUserProperties(this.analyticsInstance, properties);
+    Object.assign(this.userProperties, properties);
+  }
+
+  async clearUserData(): Promise<void> {
+    await analyticsUserService.clearUserData(this.analyticsInstance);
+    this.userId = null;
+    this.userProperties = {};
+    this.isInitialized = false;
+  }
+
+  getCurrentUserId(): string | null {
+    return this.userId;
+  }
+
+  async logScreenView(params: {
+    screen_name: string;
+    screen_class?: string;
+  }): Promise<void> {
+    await this.logEvent('screen_view', {
+      screen_name: params.screen_name,
+      screen_class: params.screen_class || params.screen_name,
+    });
+  }
+
+  async logScreenTime(params: {
+    screen_name: string;
+    screen_class?: string;
+    time_spent_seconds: number;
+  }): Promise<void> {
+    await this.logEvent('screen_time', {
+      screen_name: params.screen_name,
+      screen_class: params.screen_class || params.screen_name,
+      time_spent_seconds: params.time_spent_seconds,
+    });
+  }
+
+  async logNavigation(params: {
+    from_screen: string;
+    to_screen: string;
+    screen_class?: string;
+  }): Promise<void> {
+    await this.logEvent('navigation', {
+      from_screen: params.from_screen,
+      to_screen: params.to_screen,
+      screen_class: params.screen_class || params.to_screen,
+    });
+  }
+
+  async logButtonClick(params: {
+    button_id: string;
+    button_name?: string;
+    screen_name: string;
+    screen_class?: string;
+  }): Promise<void> {
+    await this.logEvent('button_click', {
+      button_id: params.button_id,
+      button_name: params.button_name || params.button_id,
+      screen_name: params.screen_name,
+      screen_class: params.screen_class || params.screen_name,
+    });
+  }
+}
+
+export const firebaseAnalyticsService = new FirebaseAnalyticsService();

package/src/analytics/infrastructure/services/PerformanceTracker.ts

@@ -0,0 +1,49 @@
+/**
+ * Performance Tracker Service
+ * 
+ * Single Responsibility: Track performance metrics of operations
+ */
+
+export class PerformanceTracker {
+    private activeTracks = new Map<string, number>();
+
+    /**
+     * Start tracking an operation
+     */
+    start(trackingId: string): void {
+        this.activeTracks.set(trackingId, Date.now());
+    }
+
+    /**
+     * End tracking and return duration
+     */
+    async end(trackingId: string, params: Record<string, any> = {}): Promise<number> {
+        const startTime = this.activeTracks.get(trackingId);
+        if (!startTime) return 0;
+
+        const duration = Date.now() - startTime;
+        this.activeTracks.delete(trackingId);
+
+        // In a full implementation, this could send to Firebase Performance
+        // For now, we just log it or handle it as a custom metric
+        if (__DEV__) {
+            console.log(`⏱️ [Performance] ${trackingId}: ${duration}ms`, params);
+        }
+
+        return duration;
+    }
+
+    /**
+     * Track a function execution
+     */
+    async track<T>(trackingId: string, fn: () => Promise<T>): Promise<T> {
+        this.start(trackingId);
+        try {
+            return await fn();
+        } finally {
+            await this.end(trackingId);
+        }
+    }
+}
+
+export const performanceTracker = new PerformanceTracker();

package/src/analytics/infrastructure/services/analytics-event.service.ts

@@ -0,0 +1,72 @@
+/**
+ * Analytics Event Service
+ * Single Responsibility: Handle event logging operations
+ */
+
+import { webAnalyticsAdapter } from '../adapters/web-analytics.adapter';
+import { nativeAnalyticsAdapter } from '../adapters/native-analytics.adapter';
+import type { AnalyticsInstance } from './analytics-initializer.service';
+
+export class AnalyticsEventService {
+  /**
+   * Log event to analytics
+   */
+  async logEvent(
+    analyticsInstance: AnalyticsInstance | null,
+    eventName: string,
+    params?: Record<string, string | number | boolean | null>,
+  ): Promise<void> {
+    if (!analyticsInstance) {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.warn('⚠️ Firebase Analytics: Cannot log event - Analytics not initialized', {
+          eventName,
+          reason: 'Analytics instance is null (native module not available in Expo Go)',
+        });
+      }
+      return;
+    }
+
+    try {
+      if (analyticsInstance.platform === 'native' && nativeAnalyticsAdapter) {
+        await nativeAnalyticsAdapter.logEvent(
+          analyticsInstance.instance,
+          eventName,
+          params,
+        );
+        /* eslint-disable-next-line no-console */
+        if (__DEV__) {
+          console.log('📊 Firebase Analytics Event (native):', {
+            eventName,
+            params,
+            platform: 'iOS/Android',
+          });
+        }
+      } else if (analyticsInstance.platform === 'web' && webAnalyticsAdapter) {
+        await webAnalyticsAdapter.logEvent(
+          analyticsInstance.instance,
+          eventName,
+          params,
+        );
+        /* eslint-disable-next-line no-console */
+        if (__DEV__) {
+          console.log('📊 Firebase Analytics Event:', {
+            eventName,
+            params,
+          });
+        }
+      }
+    } catch (error) {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.warn('⚠️ Firebase Analytics: Failed to log event', {
+          eventName,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+  }
+}
+
+export const analyticsEventService = new AnalyticsEventService();
+