@clix-so/react-native-sdk 0.0.1 → 0.0.2-beta.2

package/src/services/DeviceService.ts

@@ -20,8 +20,8 @@ export class DeviceService {
     private readonly deviceAPIService: DeviceAPIService
   ) {}
 
-  async getCurrentDeviceId(): Promise<string> {
-    const existingId = await this.storageService.get<string>(
+  getCurrentDeviceId(): string {
+    const existingId = this.storageService.get<string>(
       DeviceService.DEVICE_ID_KEY
     );
     if (existingId) {
@@ -29,13 +29,13 @@ export class DeviceService {
     }
 
     const newId = UUID.generate();
-    await this.storageService.set(DeviceService.DEVICE_ID_KEY, newId);
+    this.storageService.set(DeviceService.DEVICE_ID_KEY, newId);
     return newId;
   }
 
   async setProjectUserId(projectUserId: string): Promise<void> {
     try {
-      const deviceId = await this.getCurrentDeviceId();
+      const deviceId = this.getCurrentDeviceId();
       await this.deviceAPIService.setProjectUserId(deviceId, projectUserId);
       ClixLogger.debug(`Project user ID set: ${projectUserId}`);
     } catch (error) {
@@ -49,7 +49,7 @@ export class DeviceService {
 
   async removeProjectUserId(): Promise<void> {
     try {
-      const deviceId = await this.getCurrentDeviceId();
+      const deviceId = this.getCurrentDeviceId();
       await this.deviceAPIService.removeProjectUserId(deviceId);
       ClixLogger.debug('Project user ID removed');
     } catch (error) {
@@ -67,7 +67,7 @@ export class DeviceService {
         ClixUserProperty.of(key, value)
       );
 
-      const deviceId = await this.getCurrentDeviceId();
+      const deviceId = this.getCurrentDeviceId();
       await this.deviceAPIService.upsertUserProperties(
         deviceId,
         userProperties
@@ -87,7 +87,7 @@ export class DeviceService {
 
   async removeUserProperties(names: string[]): Promise<void> {
     try {
-      const deviceId = await this.getCurrentDeviceId();
+      const deviceId = this.getCurrentDeviceId();
       await this.deviceAPIService.removeUserProperties(deviceId, names);
 
       ClixLogger.debug(`User properties removed: ${names.join(', ')}`);
@@ -102,9 +102,9 @@ export class DeviceService {
 
   async upsertToken(token: string, tokenType: string = 'FCM'): Promise<void> {
     try {
-      await this.tokenService.saveToken(token);
+      this.tokenService.saveToken(token);
 
-      const deviceId = await this.getCurrentDeviceId();
+      const deviceId = this.getCurrentDeviceId();
       const device = await this.createDevice(deviceId, token);
 
       await this.deviceAPIService.registerDevice(device);
@@ -132,17 +132,27 @@ export class DeviceService {
     }
   }
 
-  private async getPushPermissionStatus(): Promise<boolean> {
+  async upsertIsPushPermissionGranted(isGranted: boolean): Promise<void> {
     try {
-      // First check stored permission status
-      const storedStatus = await this.storageService.get<string>(
-        'notification_permission_status'
+      const deviceId = this.getCurrentDeviceId();
+      const currentToken = this.tokenService.getCurrentToken();
+      const device = await this.createDevice(deviceId, currentToken, isGranted);
+
+      await this.deviceAPIService.registerDevice(device);
+      ClixLogger.debug(
+        `Push permission status upserted: ${isGranted ? 'granted' : 'denied'}`
       );
-      if (storedStatus === 'authorized' || storedStatus === 'provisional') {
-        return true;
-      }
+    } catch (error) {
+      ClixLogger.error('Failed to upsert push permission status', error);
+      throw ClixError.unknownError({
+        reason: `Failed to upsert push permission status: ${error}`,
+        cause: error,
+      });
+    }
+  }
 
-      // If no stored status, check current Firebase messaging permission
+  private async getPushPermissionStatus(): Promise<boolean> {
+    try {
       const authStatus = await messaging().hasPermission();
       const isGranted =
         authStatus === messaging.AuthorizationStatus.AUTHORIZED ||
@@ -161,7 +171,11 @@ export class DeviceService {
     }
   }
 
-  async createDevice(deviceId: string, token?: string): Promise<ClixDevice> {
+  async createDevice(
+    deviceId: string,
+    token?: string,
+    isPushPermissionGranted?: boolean
+  ): Promise<ClixDevice> {
     const platform = DeviceInfo.getSystemName();
     const osName = DeviceInfo.getSystemName();
     const osVersion = DeviceInfo.getSystemVersion();
@@ -174,7 +188,8 @@ export class DeviceService {
     const localeLanguage = locale.split('-')[0] || 'en';
     const localeRegion = locale.split('-')[1] || 'US';
     let adId: string | undefined;
-    const isPushPermissionGranted = await this.getPushPermissionStatus();
+    const pushPermissionGranted =
+      isPushPermissionGranted ?? (await this.getPushPermissionStatus());
     const sdkVersion = await ClixVersion.getVersion();
 
     return new ClixDevice({
@@ -192,7 +207,7 @@ export class DeviceService {
       sdkType: 'react-native',
       sdkVersion,
       adId,
-      isPushPermissionGranted,
+      isPushPermissionGranted: pushPermissionGranted,
       pushToken: token,
       pushTokenType: token
         ? Platform.OS === 'ios'

package/src/services/EventAPIService.ts

@@ -8,7 +8,9 @@ export class EventAPIService {
     deviceId: string,
     name: string,
     properties: Record<string, any>,
-    messageId?: string
+    messageId?: string,
+    userJourneyId?: string,
+    userJourneyNodeId?: string
   ): Promise<void> {
     try {
       ClixLogger.debug(`Tracking event: ${name} for device: ${deviceId}`);
@@ -19,6 +21,8 @@ export class EventAPIService {
         event_property: {
           custom_properties: properties,
           ...(messageId && { message_id: messageId }),
+          ...(userJourneyId && { user_journey_id: userJourneyId }),
+          ...(userJourneyNodeId && { user_journey_node_id: userJourneyNodeId }),
         },
       };
 

package/src/services/EventService.ts

@@ -1,3 +1,4 @@
+import { ClixDateFormatter } from '../utils/ClixDateFormatter';
 import { ClixLogger } from '../utils/logging/ClixLogger';
 import { DeviceService } from './DeviceService';
 import { EventAPIService } from './EventAPIService';
@@ -11,19 +12,24 @@ export class EventService {
   async trackEvent(
     name: string,
     properties?: Record<string, any>,
-    messageId?: string
+    messageId?: string,
+    userJourneyId?: string,
+    userJourneyNodeId?: string
   ): Promise<void> {
     try {
       ClixLogger.debug(`Tracking event: ${name}`);
 
-      const deviceId = await this.deviceService.getCurrentDeviceId();
+      const deviceId = this.deviceService.getCurrentDeviceId();
 
       const cleanProperties: Record<string, any> = {};
       if (properties) {
         Object.entries(properties).forEach(([key, value]) => {
-          if (value !== null && value !== undefined) {
-            cleanProperties[key] = value;
+          if (value instanceof Date) {
+            cleanProperties[key] = ClixDateFormatter.format(value);
+            return;
           }
+
+          cleanProperties[key] = value;
         });
       }
 
@@ -31,7 +37,9 @@ export class EventService {
         deviceId,
         name,
         cleanProperties,
-        messageId
+        messageId,
+        userJourneyId,
+        userJourneyNodeId
       );
 
       ClixLogger.debug(`Event tracked successfully: ${name}`);

package/src/services/NotificationService.ts

@@ -1,22 +1,20 @@
 import notifee, {
   AndroidImportance,
   AndroidStyle,
+  AuthorizationStatus,
   EventType,
   type AndroidChannel,
   type Event,
+  type NotificationSettings,
 } from '@notifee/react-native';
 import messaging, {
   FirebaseMessagingTypes,
 } from '@react-native-firebase/messaging';
 import { Linking, Platform } from 'react-native';
-import type { ClixConfig } from '../core/ClixConfig';
 import { ClixPushNotificationPayload } from '../models/ClixPushNotificationPayload';
 import { ClixLogger } from '../utils/logging/ClixLogger';
 import { UUID } from '../utils/UUID';
-import { ClixAPIClient } from './ClixAPIClient';
-import { DeviceAPIService } from './DeviceAPIService';
 import { DeviceService } from './DeviceService';
-import { EventAPIService } from './EventAPIService';
 import { EventService } from './EventService';
 import { StorageService } from './StorageService';
 import { TokenService } from './TokenService';
@@ -27,6 +25,19 @@ interface NotificationContent {
   imageUrl?: string;
 }
 
+type NotificationData = Record<string, any>;
+
+export type ForegroundMessageHandler = (
+  data: NotificationData
+) => Promise<boolean> | boolean;
+export type BackgroundMessageHandler = (
+  data: NotificationData
+) => Promise<void> | void;
+export type NotificationOpenedHandler = (
+  data: NotificationData
+) => Promise<void> | void;
+export type FcmTokenErrorHandler = (error: Error) => Promise<void> | void;
+
 export class NotificationService {
   private static instance: NotificationService | null = null;
 
@@ -50,6 +61,12 @@ export class NotificationService {
   private deviceService?: DeviceService;
   private tokenService?: TokenService;
 
+  private autoHandleLandingUrl = true;
+  private messageHandler?: ForegroundMessageHandler;
+  private backgroundMessageHandler?: BackgroundMessageHandler;
+  private openedHandler?: NotificationOpenedHandler;
+  private fcmTokenErrorHandler?: FcmTokenErrorHandler;
+
   private unsubscribeForegroundMessage?: () => void;
   private unsubscribeNotificationOpened?: () => void;
   private unsubscribeTokenRefresh?: () => void;
@@ -110,6 +127,7 @@ export class NotificationService {
       return this.currentPushToken;
     } catch (error) {
       ClixLogger.error('Failed to get push token', error);
+      await this.handleFcmTokenError(error);
       return null;
     }
   }
@@ -124,16 +142,27 @@ export class NotificationService {
     ClixLogger.debug('Notification service cleaned up');
   }
 
+  setMessageHandler(handler?: ForegroundMessageHandler): void {
+    this.messageHandler = handler;
+  }
+
+  setBackgroundMessageHandler(handler?: BackgroundMessageHandler): void {
+    this.backgroundMessageHandler = handler;
+  }
+
+  setNotificationOpenedHandler(handler?: NotificationOpenedHandler): void {
+    this.openedHandler = handler;
+  }
+
+  setFcmTokenErrorHandler(handler?: FcmTokenErrorHandler): void {
+    this.fcmTokenErrorHandler = handler;
+  }
+
+  setAutoHandleLandingUrl(enable: boolean): void {
+    this.autoHandleLandingUrl = enable;
+  }
+
   private async initializeNotificationDisplayService(): Promise<void> {
-    await notifee.requestPermission({
-      alert: true,
-      badge: true,
-      sound: true,
-      criticalAlert: false,
-      announcement: false,
-      carPlay: false,
-      provisional: false,
-    });
     if (Platform.OS === 'android') {
       await this.createNotificationChannels();
     }
@@ -194,13 +223,8 @@ export class NotificationService {
 
   private async initializeMessageService(): Promise<void> {
     this.setupMessageHandlers();
-    const settings = await this.requestMessagePermission();
-    if (settings !== messaging.AuthorizationStatus.DENIED) {
-      await this.getAndUpdateToken();
-      this.setupTokenRefreshListener();
-    } else {
-      ClixLogger.warn('Push notification permission denied');
-    }
+    await this.getAndUpdateToken();
+    this.setupTokenRefreshListener();
   }
 
   private setupMessageHandlers(): void {
@@ -226,16 +250,25 @@ export class NotificationService {
   private async handleBackgroundMessage(
     remoteMessage: FirebaseMessagingTypes.RemoteMessage
   ): Promise<void> {
+    ClixLogger.debug('Handling background message:', remoteMessage.messageId);
+
+    const data = remoteMessage.data ?? {};
     try {
-      const clixPayload = this.parseClixPayload(remoteMessage.data ?? {});
+      await this.backgroundMessageHandler?.(data);
+    } catch (error) {
+      ClixLogger.warn('Background message handler failed', error);
+    }
+
+    try {
+      const clixPayload = this.parseClixPayload(data);
       if (!clixPayload) {
         ClixLogger.warn('No Clix payload found in background message');
         return;
       }
 
-      await this.storageService.set('last_background_notification', {
+      this.storageService.set('last_background_notification', {
         messageId: remoteMessage.messageId,
-        data: remoteMessage.data ?? {},
+        data: data,
         timestamp: Date.now(),
         clixMessageId: clixPayload.messageId,
         campaignId: clixPayload.campaignId,
@@ -255,6 +288,8 @@ export class NotificationService {
   private async handleForegroundMessage(
     remoteMessage: FirebaseMessagingTypes.RemoteMessage
   ): Promise<void> {
+    ClixLogger.debug('Handling foreground message:', remoteMessage.messageId);
+
     try {
       const messageId = remoteMessage.messageId;
       if (!messageId) {
@@ -270,12 +305,24 @@ export class NotificationService {
         return;
       }
 
-      const clixPayload = this.parseClixPayload(remoteMessage.data ?? {});
+      const data = remoteMessage.data ?? {};
+      const clixPayload = this.parseClixPayload(data);
       if (clixPayload) {
         ClixLogger.debug('Parsed Clix payload:', clixPayload);
         this.processedMessageIds.add(messageId);
-        await this.handlePushReceived(remoteMessage.data ?? {});
-        await this.displayNotification(remoteMessage, clixPayload);
+        if (Platform.OS === 'android') {
+          // NOTE(nyanxyz): on iOS, Received event is tracked in NSE
+          await this.handlePushReceived(data);
+        }
+
+        if (await this.shouldDisplayForegroundNotification(data)) {
+          await this.displayNotification(remoteMessage, clixPayload);
+        } else {
+          ClixLogger.debug(
+            'Foreground message suppressed by user handler:',
+            messageId
+          );
+        }
       } else {
         ClixLogger.warn('No Clix payload found in foreground message');
       }
@@ -284,8 +331,8 @@ export class NotificationService {
     }
   }
 
-  private async requestMessagePermission(): Promise<any> {
-    const settings = await this.messagingService.requestPermission({
+  async requestPermission(): Promise<NotificationSettings> {
+    const settings = await notifee.requestPermission({
       alert: true,
       badge: true,
       sound: true,
@@ -295,13 +342,35 @@ export class NotificationService {
       criticalAlert: false,
     });
     ClixLogger.debug('Push notification permission status:', settings);
-    await this.storageService.set(
-      'notification_permission_status',
-      settings.toString()
-    );
+
+    const isGranted =
+      settings.authorizationStatus === AuthorizationStatus.AUTHORIZED ||
+      settings.authorizationStatus === AuthorizationStatus.PROVISIONAL;
+    await this.setPermissionGranted(isGranted);
+
     return settings;
   }
 
+  async setPermissionGranted(isGranted: boolean): Promise<void> {
+    if (!this.deviceService) {
+      ClixLogger.debug(
+        'Device service is not initialized, skipping push permission upsert'
+      );
+      return;
+    }
+
+    try {
+      await this.deviceService.upsertIsPushPermissionGranted(isGranted);
+      ClixLogger.debug(
+        `Push permission status reported to server: ${
+          isGranted ? 'granted' : 'denied'
+        }`
+      );
+    } catch (error) {
+      ClixLogger.warn('Failed to upsert push permission status', error);
+    }
+  }
+
   private setupTokenRefreshListener(): void {
     this.unsubscribeTokenRefresh = this.messagingService.onTokenRefresh(
       async (token: string) => {
@@ -311,6 +380,7 @@ export class NotificationService {
           await this.saveAndRegisterToken(token);
         } catch (error) {
           ClixLogger.error('Failed to handle token refresh', error);
+          await this.handleFcmTokenError(error);
         }
       }
     );
@@ -345,20 +415,23 @@ export class NotificationService {
 
   private async getOrFetchToken(): Promise<string | null> {
     if (this.tokenService) {
-      const savedToken = await this.tokenService.getCurrentToken();
+      const savedToken = this.tokenService.getCurrentToken();
       if (savedToken) return savedToken;
     }
+
+    await this.messagingService.registerDeviceForRemoteMessages();
     const token = await this.messagingService.getToken();
+
     if (token) {
       ClixLogger.debug('Got push token:', token.substring(0, 20) + '...');
-      await this.tokenService?.saveToken(token);
+      this.tokenService?.saveToken(token);
     }
     return token;
   }
 
   private async saveAndRegisterToken(token: string): Promise<void> {
     if (this.tokenService) {
-      await this.tokenService.saveToken(token);
+      this.tokenService.saveToken(token);
       ClixLogger.debug('New push token saved via TokenService');
     }
     await this.registerTokenWithServer(token);
@@ -565,7 +638,9 @@ export class NotificationService {
       if (clixPayload) {
         await this.trackPushEvent('PUSH_NOTIFICATION_TAPPED', clixPayload);
       }
-      await this.handleUrlNavigation(data);
+      if (this.autoHandleLandingUrl) {
+        await this.handleUrlNavigation(data);
+      }
       ClixLogger.debug('Push notification tapped and processed');
     } catch (error) {
       ClixLogger.error('Failed to handle push tapped', error);
@@ -575,6 +650,12 @@ export class NotificationService {
   private async handleNotificationTap(
     data: Record<string, any>
   ): Promise<void> {
+    try {
+      await this.openedHandler?.(data);
+    } catch (error) {
+      ClixLogger.error('Failed to handle notification tap', error);
+    }
+
     try {
       await this.handlePushTapped(data);
     } catch (error) {
@@ -687,35 +768,23 @@ export class NotificationService {
       return;
     }
     try {
-      const storageService = new StorageService();
-      const configData = await storageService.get<Record<string, any>>(
-        'clix_config'
-      );
+      const configData =
+        this.storageService.get<Record<string, any>>('clix_config');
       if (!configData) {
         ClixLogger.error('No Clix config found in storage');
         return;
       }
-      let deviceId = await storageService.get<string>('clix_device_id');
+      let deviceId = this.storageService.get<string>('clix_device_id');
       if (!deviceId) {
         ClixLogger.warn(
           'No device ID found in storage, generating new device ID'
         );
         deviceId = UUID.generate();
-        await storageService.set('clix_device_id', deviceId);
+        this.storageService.set('clix_device_id', deviceId);
       }
-      const config = configData as ClixConfig;
-      const apiClient = new ClixAPIClient(config);
-      const deviceAPIService = new DeviceAPIService(apiClient);
-      const eventAPIService = new EventAPIService(apiClient);
-      const tokenService = new TokenService(storageService);
-      const deviceService = new DeviceService(
-        storageService,
-        tokenService,
-        deviceAPIService
-      );
-      const eventService = new EventService(eventAPIService, deviceService);
+
       const properties = this.extractTrackingProperties(clixPayload);
-      await eventService.trackEvent(
+      await this.eventService.trackEvent(
         'PUSH_NOTIFICATION_RECEIVED',
         properties,
         messageId
@@ -727,4 +796,29 @@ export class NotificationService {
       ClixLogger.error('Error tracking event in background', error);
     }
   }
+
+  private async shouldDisplayForegroundNotification(
+    data: Record<string, any>
+  ): Promise<boolean> {
+    try {
+      const result = await this.messageHandler?.(data);
+      return result !== false;
+    } catch (error) {
+      ClixLogger.warn(
+        'Foreground message handler failed, displaying notification by default',
+        error
+      );
+      return true;
+    }
+  }
+
+  private async handleFcmTokenError(error: any): Promise<void> {
+    try {
+      const errorInstance =
+        error instanceof Error ? error : new Error(String(error));
+      await this.fcmTokenErrorHandler?.(errorInstance);
+    } catch (handlerError) {
+      ClixLogger.warn('FCM token error handler failed', handlerError);
+    }
+  }
 }

package/src/services/StorageService.ts

@@ -1,20 +1,63 @@
-import { MMKV } from 'react-native-mmkv';
+import * as MMKVModule from 'react-native-mmkv';
 import { ClixLogger } from '../utils/logging/ClixLogger';
 
+// Support both v2/v3 (MMKV class) and v4 (createMMKV function)
+type MMKVInstance = {
+  set: (key: string, value: string | number | boolean) => void;
+  getString: (key: string) => string | undefined;
+  delete?: (key: string) => void; // v2/v3
+  remove?: (key: string) => void; // v4
+  clearAll: () => void;
+  getAllKeys: () => string[];
+};
+
 export class StorageService {
-  private storage: MMKV;
+  private storage: MMKVInstance;
+
+  constructor(projectId: string) {
+    this.storage = this.initializeCompat(projectId);
+  }
+
+  private initializeCompat(projectId: string) {
+    const storageId = `clix.${projectId}`;
+
+    // v4 API (createMMKV function)
+    if (typeof MMKVModule.createMMKV === 'function') {
+      return MMKVModule.createMMKV({
+        id: storageId,
+        encryptionKey: undefined, // Add encryption if needed
+      });
+    }
+    // v2/v3 API (MMKV class)
+    else if (typeof (MMKVModule as any).MMKV === 'function') {
+      const { MMKV } = MMKVModule as any;
+      return new MMKV({
+        id: storageId,
+        encryptionKey: undefined, // Add encryption if needed
+      });
+    } else {
+      throw new Error('No compatible MMKV storage API found');
+    }
+  }
 
-  constructor() {
-    this.storage = new MMKV({
-      id: 'clix-storage',
-      encryptionKey: undefined, // Add encryption if needed
-    });
+  /**
+   * Delete a key from storage (works with both v2/v3 and v4 APIs)
+   */
+  private removeCompat(key: string): void {
+    // v4 uses remove(), v2/v3 uses delete()
+    if (typeof this.storage.remove === 'function') {
+      this.storage.remove(key);
+    } else if (typeof this.storage.delete === 'function') {
+      this.storage.delete(key);
+    } else {
+      throw new Error('No compatible delete method found on storage instance');
+    }
   }
 
-  async set<T>(key: string, value: T): Promise<void> {
-    if (value === undefined) {
+  set<T>(key: string, value: T): void {
+    if (value === undefined || value === null) {
       try {
-        this.storage.delete(key);
+        this.removeCompat(key);
       } catch (error) {
         ClixLogger.error(`Failed to remove value for key: ${key}`, error);
       }
@@ -31,10 +74,11 @@ export class StorageService {
     }
   }
 
-  async get<T>(key: string): Promise<T | undefined> {
+  get<T>(key: string): T | undefined {
     try {
       const data = this.storage.getString(key);
       if (data === null || data === undefined) return undefined;
+
       try {
         const decoded = JSON.parse(data);
         return decoded as T;
@@ -43,7 +87,7 @@ export class StorageService {
         ClixLogger.debug(
           `Found legacy string value for key: ${key}, migrating to JSON format`
         );
-        await this.set(key, data);
+        this.set(key, data);
         return data as T;
       }
     } catch (error) {
@@ -53,9 +97,9 @@ export class StorageService {
     }
   }
 
-  async remove(key: string): Promise<void> {
+  remove(key: string) {
     try {
-      this.storage.delete(key);
+      this.removeCompat(key);
     } catch (error) {
       ClixLogger.error(`Failed to remove key: ${key}`, error);
       // Don't throw to prevent initialization failure
@@ -63,7 +107,7 @@ export class StorageService {
     }
   }
 
-  async clear(): Promise<void> {
+  clear() {
     try {
       this.storage.clearAll();
     } catch (error) {
@@ -72,7 +116,7 @@ export class StorageService {
     }
   }
 
-  async getAllKeys(): Promise<string[]> {
+  getAllKeys() {
     try {
       const keys = this.storage.getAllKeys();
       return Array.from(keys);