@clix-so/react-native-sdk 1.0.0 → 1.1.0

package/src/services/DeviceAPIService.ts

@@ -6,39 +6,37 @@ import { ClixAPIClient } from './ClixAPIClient';
 export class DeviceAPIService {
   constructor(private readonly apiClient: ClixAPIClient) {}
 
-  async registerDevice(device: ClixDevice): Promise<void> {
+  async upsertDevice(device: ClixDevice): Promise<void> {
     try {
       ClixLogger.debug(`Upserting device: ${device.id}`);
 
       const response = await this.apiClient.post('/devices', {
-        body: {
-          devices: [
-            {
-              id: device.id,
-              platform: device.platform,
-              model: device.model,
-              manufacturer: device.manufacturer,
-              os_name: device.osName,
-              os_version: device.osVersion,
-              locale_region: device.localeRegion,
-              locale_language: device.localeLanguage,
-              timezone: device.timezone,
-              app_name: device.appName,
-              app_version: device.appVersion,
-              sdk_type: device.sdkType,
-              sdk_version: device.sdkVersion,
-              ad_id: device.adId,
-              is_push_permission_granted: device.isPushPermissionGranted,
-              push_token: device.pushToken,
-              push_token_type: device.pushTokenType,
-            },
-          ],
-        },
+        devices: [
+          {
+            id: device.id,
+            platform: device.platform,
+            model: device.model,
+            manufacturer: device.manufacturer,
+            os_name: device.osName,
+            os_version: device.osVersion,
+            locale_region: device.localeRegion,
+            locale_language: device.localeLanguage,
+            timezone: device.timezone,
+            app_name: device.appName,
+            app_version: device.appVersion,
+            sdk_type: device.sdkType,
+            sdk_version: device.sdkVersion,
+            ad_id: device.adId,
+            is_push_permission_granted: device.isPushPermissionGranted,
+            push_token: device.pushToken,
+            push_token_type: device.pushTokenType,
+          },
+        ],
       });
 
-      if (response.status < 200 || response.status >= 300) {
+      if (response.statusCode < 200 || response.statusCode >= 300) {
         throw new Error(
-          `HTTP ${response.status}: ${JSON.stringify(response.data)}`
+          `HTTP ${response.statusCode}: ${JSON.stringify(response.data)}`
         );
       }
 
@@ -59,15 +57,13 @@ export class DeviceAPIService {
       const response = await this.apiClient.post(
         `/devices/${deviceId}/user/project-user-id`,
         {
-          body: {
-            project_user_id: projectUserId,
-          },
+          project_user_id: projectUserId,
         }
       );
 
-      if (response.status < 200 || response.status >= 300) {
+      if (response.statusCode < 200 || response.statusCode >= 300) {
         throw new Error(
-          `HTTP ${response.status}: ${JSON.stringify(response.data)}`
+          `HTTP ${response.statusCode}: ${JSON.stringify(response.data)}`
         );
       }
 
@@ -91,9 +87,9 @@ export class DeviceAPIService {
         `/devices/${deviceId}/user/project-user-id`
       );
 
-      if (response.status < 200 || response.status >= 300) {
+      if (response.statusCode < 200 || response.statusCode >= 300) {
         throw new Error(
-          `HTTP ${response.status}: ${JSON.stringify(response.data)}`
+          `HTTP ${response.statusCode}: ${JSON.stringify(response.data)}`
         );
       }
 
@@ -121,19 +117,17 @@ export class DeviceAPIService {
       const response = await this.apiClient.post(
         `/devices/${deviceId}/user/properties`,
         {
-          body: {
-            properties: properties.map((p) => ({
-              name: p.name,
-              value_string: p.valueString,
-              type: p.type,
-            })),
-          },
+          properties: properties.map((p) => ({
+            name: p.name,
+            value_string: p.valueString,
+            type: p.type,
+          })),
         }
       );
 
-      if (response.status < 200 || response.status >= 300) {
+      if (response.statusCode < 200 || response.statusCode >= 300) {
         throw new Error(
-          `HTTP ${response.status}: ${JSON.stringify(response.data)}`
+          `HTTP ${response.statusCode}: ${JSON.stringify(response.data)}`
         );
       }
 
@@ -161,15 +155,13 @@ export class DeviceAPIService {
       const response = await this.apiClient.delete(
         `/devices/${deviceId}/user/properties`,
         {
-          queryParameters: {
-            property_names: propertyNames.join(','),
-          },
+          property_names: propertyNames.join(','),
         }
       );
 
-      if (response.status < 200 || response.status >= 300) {
+      if (response.statusCode < 200 || response.statusCode >= 300) {
         throw new Error(
-          `HTTP ${response.status}: ${JSON.stringify(response.data)}`
+          `HTTP ${response.statusCode}: ${JSON.stringify(response.data)}`
         );
       }
 

package/src/services/DeviceService.ts

@@ -1,18 +1,17 @@
 import messaging from '@react-native-firebase/messaging';
-import { Platform } from 'react-native';
 import DeviceInfo from 'react-native-device-info';
 import { ClixVersion } from '../core/ClixVersion';
 import { ClixDevice } from '../models/ClixDevice';
 import { ClixUserProperty } from '../models/ClixUserProperty';
-import { ClixError } from '../utils/ClixError';
 import { ClixLogger } from '../utils/logging/ClixLogger';
 import { UUID } from '../utils/UUID';
 import { DeviceAPIService } from './DeviceAPIService';
 import { StorageService } from './StorageService';
-import { TokenService } from './TokenService';
+import type { TokenService } from './TokenService';
 
 export class DeviceService {
-  private static readonly DEVICE_ID_KEY = 'clix_device_id';
+  private deviceIdKey = 'clix_device_id';
+  private currentDevice?: ClixDevice;
 
   constructor(
     private readonly storageService: StorageService,
@@ -20,135 +19,140 @@ export class DeviceService {
     private readonly deviceAPIService: DeviceAPIService
   ) {}
 
+  async initialize(): Promise<void> {
+    this.currentDevice = await this.createDevice();
+    await this.deviceAPIService.upsertDevice(this.currentDevice);
+  }
+
+  private generateDeviceId(): string {
+    return UUID.generate();
+  }
+
   getCurrentDeviceId(): string {
-    const existingId = this.storageService.get<string>(
-      DeviceService.DEVICE_ID_KEY
-    );
+    const existingId = this.storageService.get<string>(this.deviceIdKey);
     if (existingId) {
       return existingId;
     }
 
-    const newId = UUID.generate();
-    this.storageService.set(DeviceService.DEVICE_ID_KEY, newId);
-    return newId;
-  }
+    const newDeviceId = this.generateDeviceId();
+    this.storageService.set(this.deviceIdKey, newDeviceId);
 
-  async setProjectUserId(projectUserId: string): Promise<void> {
-    try {
-      const deviceId = this.getCurrentDeviceId();
-      await this.deviceAPIService.setProjectUserId(deviceId, projectUserId);
-      ClixLogger.debug(`Project user ID set: ${projectUserId}`);
-    } catch (error) {
-      ClixLogger.error('Failed to set project user ID', error);
-      throw ClixError.unknownError({
-        reason: `Failed to set project user ID: ${error}`,
-        cause: error,
-      });
-    }
+    ClixLogger.debug(`Generated new device ID: ${newDeviceId}`);
+    return newDeviceId;
   }
 
-  async removeProjectUserId(): Promise<void> {
-    try {
-      const deviceId = this.getCurrentDeviceId();
-      await this.deviceAPIService.removeProjectUserId(deviceId);
-      ClixLogger.debug('Project user ID removed');
-    } catch (error) {
-      ClixLogger.error('Failed to remove project user ID', error);
-      throw ClixError.unknownError({
-        reason: `Failed to remove project user ID: ${error}`,
-        cause: error,
-      });
-    }
+  async createDevice(): Promise<ClixDevice> {
+    const deviceId = this.getCurrentDeviceId();
+    const platform = DeviceInfo.getSystemName();
+    const osName = DeviceInfo.getSystemName();
+    const osVersion = DeviceInfo.getSystemVersion();
+    const manufacturer = await DeviceInfo.getManufacturer();
+    const model = DeviceInfo.getModel();
+    const appName = DeviceInfo.getApplicationName();
+    const appVersion = DeviceInfo.getVersion();
+    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const locale = Intl.DateTimeFormat().resolvedOptions().locale || 'en-US';
+    const localeLanguage = locale.split('-')[0] || 'en';
+    const localeRegion = locale.split('-')[1] || 'US';
+    const adId: string | undefined = undefined; // TODO: Implement Ad ID
+    const isPushPermissionGranted = await this.getPushPermissionStatus();
+    const sdkType = 'react-native';
+    const sdkVersion = await ClixVersion.getVersion();
+    const pushToken = await this.getPushToken();
+    const pushTokenType = pushToken ? 'FCM' : undefined;
+
+    const device = new ClixDevice({
+      id: deviceId,
+      platform,
+      model,
+      manufacturer,
+      osName,
+      osVersion,
+      localeRegion,
+      localeLanguage,
+      timezone,
+      appName,
+      appVersion,
+      sdkType,
+      sdkVersion,
+      adId,
+      isPushPermissionGranted,
+      pushToken,
+      pushTokenType,
+    });
+
+    return device;
   }
 
-  async updateUserProperties(properties: Record<string, any>): Promise<void> {
-    try {
-      const userProperties = Object.entries(properties).map(([key, value]) =>
-        ClixUserProperty.of(key, value)
-      );
+  async upsertDevice(device: ClixDevice): Promise<void> {
+    return this.deviceAPIService.upsertDevice(device);
+  }
 
-      const deviceId = this.getCurrentDeviceId();
-      await this.deviceAPIService.upsertUserProperties(
-        deviceId,
-        userProperties
-      );
+  async updatePushToken(
+    pushToken: string,
+    pushTokenType: string
+  ): Promise<void> {
+    if (!this.currentDevice) {
+      ClixLogger.warn('Device not initialized yet, cannot update push token');
+      return;
+    }
 
-      ClixLogger.debug(
-        `User properties updated: ${Object.keys(properties).join(', ')}`
-      );
-    } catch (error) {
-      ClixLogger.error('Failed to update user properties', error);
-      throw ClixError.unknownError({
-        reason: `Failed to update user properties: ${error}`,
-        cause: error,
-      });
+    if (
+      this.currentDevice.pushToken === pushToken &&
+      this.currentDevice.pushTokenType === pushTokenType
+    ) {
+      ClixLogger.debug('Push token and type are unchanged, skipping update');
+      return;
     }
+
+    const newDevice = this.currentDevice.copyWith({ pushToken, pushTokenType });
+    this.currentDevice = newDevice;
+
+    return this.deviceAPIService.upsertDevice(newDevice);
   }
 
-  async removeUserProperties(names: string[]): Promise<void> {
-    try {
-      const deviceId = this.getCurrentDeviceId();
-      await this.deviceAPIService.removeUserProperties(deviceId, names);
+  async updatePushPermission(isGranted: boolean): Promise<void> {
+    if (!this.currentDevice) {
+      ClixLogger.warn(
+        'Device not initialized yet, cannot update push permission status'
+      );
+      return;
+    }
 
-      ClixLogger.debug(`User properties removed: ${names.join(', ')}`);
-    } catch (error) {
-      ClixLogger.error('Failed to remove user properties', error);
-      throw ClixError.unknownError({
-        reason: `Failed to remove user properties: ${error}`,
-        cause: error,
-      });
+    if (this.currentDevice.isPushPermissionGranted === isGranted) {
+      ClixLogger.debug('Push permission status is unchanged, skipping update');
+      return;
     }
-  }
 
-  async upsertToken(token: string, tokenType: string = 'FCM'): Promise<void> {
-    try {
-      this.tokenService.saveToken(token);
+    const newDevice = this.currentDevice.copyWith({
+      isPushPermissionGranted: isGranted,
+    });
+    this.currentDevice = newDevice;
 
-      const deviceId = this.getCurrentDeviceId();
-      const device = await this.createDevice(deviceId, token);
+    return this.deviceAPIService.upsertDevice(newDevice);
+  }
 
-      await this.deviceAPIService.registerDevice(device);
+  async setProjectUserId(projectUserId: string): Promise<void> {
+    const deviceId = this.getCurrentDeviceId();
+    return this.deviceAPIService.setProjectUserId(deviceId, projectUserId);
+  }
 
-      ClixLogger.debug(`Token upserted: ${tokenType}`);
-    } catch (error) {
-      ClixLogger.error('Failed to upsert token', error);
-
-      // Don't throw for token upsert failures during initialization
-      // This allows the SDK to continue initializing even if token registration fails
-      if (
-        error instanceof Error &&
-        error.message.includes('crypto.getRandomValues')
-      ) {
-        ClixLogger.warn(
-          'Token upsert failed due to crypto polyfill issue, will retry later'
-        );
-        return;
-      }
-
-      throw ClixError.unknownError({
-        reason: `Failed to upsert token: ${error}`,
-        cause: error,
-      });
-    }
+  async removeProjectUserId(): Promise<void> {
+    const deviceId = this.getCurrentDeviceId();
+    return this.deviceAPIService.removeProjectUserId(deviceId);
   }
 
-  async upsertIsPushPermissionGranted(isGranted: boolean): Promise<void> {
-    try {
-      const deviceId = this.getCurrentDeviceId();
-      const currentToken = this.tokenService.getCurrentToken();
-      const device = await this.createDevice(deviceId, currentToken, isGranted);
+  async updateUserProperties(properties: Record<string, any>): Promise<void> {
+    const deviceId = this.getCurrentDeviceId();
+    const userProperties = Object.entries(properties).map(([key, value]) =>
+      ClixUserProperty.of(key, value)
+    );
+    return this.deviceAPIService.upsertUserProperties(deviceId, userProperties);
+  }
 
-      await this.deviceAPIService.registerDevice(device);
-      ClixLogger.debug(
-        `Push permission status upserted: ${isGranted ? 'granted' : 'denied'}`
-      );
-    } catch (error) {
-      ClixLogger.error('Failed to upsert push permission status', error);
-      throw ClixError.unknownError({
-        reason: `Failed to upsert push permission status: ${error}`,
-        cause: error,
-      });
-    }
+  async removeUserProperties(names: string[]): Promise<void> {
+    const deviceId = this.getCurrentDeviceId();
+    return this.deviceAPIService.removeUserProperties(deviceId, names);
   }
 
   private async getPushPermissionStatus(): Promise<boolean> {
@@ -158,9 +162,6 @@ export class DeviceService {
         authStatus === messaging.AuthorizationStatus.AUTHORIZED ||
         authStatus === messaging.AuthorizationStatus.PROVISIONAL;
 
-      ClixLogger.debug(
-        `Push permission status: ${isGranted ? 'granted' : 'denied'}`
-      );
       return isGranted;
     } catch (error) {
       ClixLogger.warn(
@@ -171,49 +172,14 @@ export class DeviceService {
     }
   }
 
-  async createDevice(
-    deviceId: string,
-    token?: string,
-    isPushPermissionGranted?: boolean
-  ): Promise<ClixDevice> {
-    const platform = DeviceInfo.getSystemName();
-    const osName = DeviceInfo.getSystemName();
-    const osVersion = DeviceInfo.getSystemVersion();
-    const manufacturer = await DeviceInfo.getManufacturer();
-    const model = DeviceInfo.getModel();
-    const appName = DeviceInfo.getApplicationName();
-    const appVersion = DeviceInfo.getVersion();
-    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-    const locale = Intl.DateTimeFormat().resolvedOptions().locale || 'en-US';
-    const localeLanguage = locale.split('-')[0] || 'en';
-    const localeRegion = locale.split('-')[1] || 'US';
-    let adId: string | undefined;
-    const pushPermissionGranted =
-      isPushPermissionGranted ?? (await this.getPushPermissionStatus());
-    const sdkVersion = await ClixVersion.getVersion();
-
-    return new ClixDevice({
-      id: deviceId,
-      platform,
-      model,
-      manufacturer,
-      osName,
-      osVersion,
-      localeRegion,
-      localeLanguage,
-      timezone,
-      appName,
-      appVersion,
-      sdkType: 'react-native',
-      sdkVersion,
-      adId,
-      isPushPermissionGranted: pushPermissionGranted,
-      pushToken: token,
-      pushTokenType: token
-        ? Platform.OS === 'ios'
-          ? 'APNS'
-          : 'FCM'
-        : undefined,
-    });
+  private async getPushToken(): Promise<string | undefined> {
+    try {
+      const token = await messaging().getToken();
+      this.tokenService.saveToken(token);
+      return token;
+    } catch (error) {
+      ClixLogger.warn('Failed to get push token', error);
+      return undefined;
+    }
   }
 }

package/src/services/EventAPIService.ts

@@ -27,14 +27,12 @@ export class EventAPIService {
       };
 
       const response = await this.apiClient.post('/events', {
-        body: {
-          events: [eventRequestBody],
-        },
+        events: [eventRequestBody],
       });
 
-      if (response.status < 200 || response.status >= 300) {
+      if (response.statusCode < 200 || response.statusCode >= 300) {
         throw new Error(
-          `HTTP ${response.status}: ${JSON.stringify(response.data)}`
+          `HTTP ${response.statusCode}: ${JSON.stringify(response.data)}`
         );
       }
 

package/src/services/EventService.ts

@@ -1,5 +1,4 @@
 import { ClixDateFormatter } from '../utils/ClixDateFormatter';
-import { ClixLogger } from '../utils/logging/ClixLogger';
 import { DeviceService } from './DeviceService';
 import { EventAPIService } from './EventAPIService';
 
@@ -9,6 +8,23 @@ export class EventService {
     private readonly deviceService: DeviceService
   ) {}
 
+  private serializeProperties(
+    properties: Record<string, any> = {}
+  ): Record<string, any> {
+    const cleanProperties: Record<string, any> = {};
+
+    Object.entries(properties).forEach(([key, value]) => {
+      if (value instanceof Date) {
+        cleanProperties[key] = ClixDateFormatter.format(value);
+        return;
+      }
+
+      cleanProperties[key] = value;
+    });
+
+    return cleanProperties;
+  }
+
   async trackEvent(
     name: string,
     properties?: Record<string, any>,
@@ -16,38 +32,15 @@ export class EventService {
     userJourneyId?: string,
     userJourneyNodeId?: string
   ): Promise<void> {
-    try {
-      ClixLogger.debug(`Tracking event: ${name}`);
-
-      const deviceId = this.deviceService.getCurrentDeviceId();
-
-      const cleanProperties: Record<string, any> = {};
-      if (properties) {
-        Object.entries(properties).forEach(([key, value]) => {
-          if (value instanceof Date) {
-            cleanProperties[key] = ClixDateFormatter.format(value);
-            return;
-          }
-
-          cleanProperties[key] = value;
-        });
-      }
-
-      await this.eventAPIService.trackEvent(
-        deviceId,
-        name,
-        cleanProperties,
-        messageId,
-        userJourneyId,
-        userJourneyNodeId
-      );
+    const deviceId = this.deviceService.getCurrentDeviceId();
 
-      ClixLogger.debug(`Event tracked successfully: ${name}`);
-    } catch (error) {
-      ClixLogger.error(
-        `Failed to track event '${name}': ${error}. Make sure Clix.initialize() has been called.`
-      );
-      throw error;
-    }
+    await this.eventAPIService.trackEvent(
+      deviceId,
+      name,
+      this.serializeProperties(properties),
+      messageId,
+      userJourneyId,
+      userJourneyNodeId
+    );
   }
 }