@clix-so/react-native-sdk 0.0.2-beta.5 → 1.1.0

package/src/core/ClixNotification.ts

@@ -1,9 +1,10 @@
 import { type NotificationSettings } from '@notifee/react-native';
 import type {
   BackgroundMessageHandler,
-  FcmTokenErrorHandler,
-  ForegroundMessageHandler,
-  NotificationOpenedHandler,
+  ForegroundEventHandler,
+  MessageHandler,
+  NotificationOpenedAppHandler,
+  TokenRefreshHandler,
 } from '../services/NotificationService';
 import { ClixLogger } from '../utils/logging/ClixLogger';
 import { Clix } from './Clix';
@@ -34,7 +35,7 @@ export class ClixNotification {
         return;
       }
 
-      notificationService.setAutoHandleLandingUrl(autoHandleLandingURL);
+      notificationService.autoHandleLandingUrl = autoHandleLandingURL;
 
       if (autoRequestPermission) {
         await notificationService.requestPermission();
@@ -44,32 +45,22 @@ export class ClixNotification {
     }
   }
 
-  async requestPermission(): Promise<NotificationSettings | null> {
+  async requestPermission(): Promise<NotificationSettings | undefined> {
     try {
       await Clix.initCoordinator.waitForInitialization();
-      const notificationService = Clix.shared?.notificationService;
-      if (!notificationService) {
-        ClixLogger.warn('Notification service is not initialized');
-        return null;
-      }
-
-      return await notificationService.requestPermission();
+      return await Clix.shared?.notificationService?.requestPermission();
     } catch (error) {
       ClixLogger.error('Failed to request notification permission', error);
-      return null;
+      return undefined;
     }
   }
 
   async setPermissionGranted(isGranted: boolean): Promise<void> {
     try {
       await Clix.initCoordinator.waitForInitialization();
-      const notificationService = Clix.shared?.notificationService;
-      if (!notificationService) {
-        ClixLogger.warn('Notification service is not initialized');
-        return;
-      }
-
-      await notificationService.setPermissionGranted(isGranted);
+      return await Clix.shared?.notificationService?.setPermissionGranted(
+        isGranted
+      );
     } catch (error) {
       ClixLogger.error(
         'Failed to update push permission status on server',
@@ -81,21 +72,14 @@ export class ClixNotification {
   async getToken(): Promise<string | undefined> {
     try {
       await Clix.initCoordinator.waitForInitialization();
-      const notificationService = Clix.shared?.notificationService;
-      if (!notificationService) {
-        ClixLogger.warn('Notification service is not initialized');
-        return undefined;
-      }
-
-      const token = await notificationService.getCurrentToken();
-      return token ?? undefined;
+      return Clix.shared?.tokenService?.getCurrentToken();
     } catch (error) {
       ClixLogger.error('Failed to get push token', error);
       return undefined;
     }
   }
 
-  async onMessage(handler?: ForegroundMessageHandler): Promise<void> {
+  async onMessage(handler?: MessageHandler): Promise<void> {
     try {
       await Clix.initCoordinator.waitForInitialization();
       const notificationService = Clix.shared?.notificationService;
@@ -103,7 +87,7 @@ export class ClixNotification {
         ClixLogger.warn('Notification service is not initialized');
         return;
       }
-      notificationService.setMessageHandler(handler);
+      notificationService.messageHandler = handler;
     } catch (error) {
       ClixLogger.error('Failed to register onMessage handler', error);
     }
@@ -117,14 +101,14 @@ export class ClixNotification {
         ClixLogger.warn('Notification service is not initialized');
         return;
       }
-      notificationService.setBackgroundMessageHandler(handler);
+      notificationService.backgroundMessageHandler = handler;
     } catch (error) {
       ClixLogger.error('Failed to register onBackgroundMessage handler', error);
     }
   }
 
-  async onNotificationOpened(
-    handler?: NotificationOpenedHandler
+  async onNotificationOpenedApp(
+    handler?: NotificationOpenedAppHandler
   ): Promise<void> {
     try {
       await Clix.initCoordinator.waitForInitialization();
@@ -133,7 +117,7 @@ export class ClixNotification {
         ClixLogger.warn('Notification service is not initialized');
         return;
       }
-      notificationService.setNotificationOpenedHandler(handler);
+      notificationService.notificationOpenedAppHandler = handler;
     } catch (error) {
       ClixLogger.error(
         'Failed to register onNotificationOpened handler',
@@ -141,7 +125,22 @@ export class ClixNotification {
       );
     }
   }
-  async onFcmTokenError(handler?: FcmTokenErrorHandler): Promise<void> {
+
+  async onTokenRefresh(handler?: TokenRefreshHandler): Promise<void> {
+    try {
+      await Clix.initCoordinator.waitForInitialization();
+      const notificationService = Clix.shared?.notificationService;
+      if (!notificationService) {
+        ClixLogger.warn('Notification service is not initialized');
+        return;
+      }
+      notificationService.tokenRefreshHandler = handler;
+    } catch (error) {
+      ClixLogger.error('Failed to register onTokenRefresh handler', error);
+    }
+  }
+
+  async onForegroundEvent(handler?: ForegroundEventHandler): Promise<void> {
     try {
       await Clix.initCoordinator.waitForInitialization();
       const notificationService = Clix.shared?.notificationService;
@@ -149,9 +148,9 @@ export class ClixNotification {
         ClixLogger.warn('Notification service is not initialized');
         return;
       }
-      notificationService.setFcmTokenErrorHandler(handler);
+      notificationService.foregroundEventHandler = handler;
     } catch (error) {
-      ClixLogger.error('Failed to register onFcmTokenError handler', error);
+      ClixLogger.error('Failed to register onForegroundEvent handler', error);
     }
   }
 }

package/src/models/ClixDevice.ts

@@ -1,21 +1,21 @@
 export class ClixDevice {
-  public readonly id: string;
-  public readonly platform: string;
-  public readonly model: string;
-  public readonly manufacturer: string;
-  public readonly osName: string;
-  public readonly osVersion: string;
-  public readonly localeRegion: string;
-  public readonly localeLanguage: string;
-  public readonly timezone: string;
-  public readonly appName: string;
-  public readonly appVersion: string;
-  public readonly sdkType: string;
-  public readonly sdkVersion: string;
-  public readonly adId?: string;
-  public readonly isPushPermissionGranted: boolean;
-  public readonly pushToken?: string;
-  public readonly pushTokenType?: string;
+  readonly id: string;
+  readonly platform: string;
+  readonly model: string;
+  readonly manufacturer: string;
+  readonly osName: string;
+  readonly osVersion: string;
+  readonly localeRegion: string;
+  readonly localeLanguage: string;
+  readonly timezone: string;
+  readonly appName: string;
+  readonly appVersion: string;
+  readonly sdkType: string;
+  readonly sdkVersion: string;
+  readonly adId?: string;
+  readonly isPushPermissionGranted: boolean;
+  readonly pushToken?: string;
+  readonly pushTokenType?: string;
 
   constructor(device: {
     id: string;
@@ -77,12 +77,4 @@ export class ClixDevice {
       pushTokenType: updates.pushTokenType ?? this.pushTokenType,
     });
   }
-
-  equals(other: ClixDevice): boolean {
-    return this.id === other.id;
-  }
-
-  toString(): string {
-    return `ClixDevice(id: ${this.id}, platform: ${this.platform}, model: ${this.model})`;
-  }
 }

package/src/models/ClixPushNotificationPayload.ts

@@ -1,38 +1,9 @@
-export class ClixPushNotificationPayload {
-  public readonly messageId: string;
-  public readonly campaignId?: string;
-  public readonly userId?: string;
-  public readonly deviceId?: string;
-  public readonly trackingId?: string;
-  public readonly landingUrl?: string;
-  public readonly imageUrl?: string;
-  public readonly customProperties?: Record<string, any>;
-
-  constructor(payload: {
-    messageId: string;
-    campaignId?: string;
-    userId?: string;
-    deviceId?: string;
-    trackingId?: string;
-    landingUrl?: string;
-    imageUrl?: string;
-    customProperties?: Record<string, any>;
-  }) {
-    this.messageId = payload.messageId;
-    this.campaignId = payload.campaignId;
-    this.userId = payload.userId;
-    this.deviceId = payload.deviceId;
-    this.trackingId = payload.trackingId;
-    this.landingUrl = payload.landingUrl;
-    this.imageUrl = payload.imageUrl;
-    this.customProperties = payload.customProperties;
-  }
-
-  equals(other: ClixPushNotificationPayload): boolean {
-    return this.messageId === other.messageId;
-  }
-
-  toString(): string {
-    return `ClixPushNotificationPayload(messageId: ${this.messageId}, campaignId: ${this.campaignId})`;
-  }
+export interface ClixPushNotificationPayload {
+  messageId: string;
+  title: string;
+  body: string;
+  imageUrl?: string;
+  landingUrl?: string;
+  userJourneyId?: string;
+  userJourneyNodeId?: string;
 }

package/src/services/ClixAPIClient.ts

@@ -1,5 +1,7 @@
 import type { ClixConfig } from '../core/ClixConfig';
 import { ClixVersion } from '../core/ClixVersion';
+import { HTTPClient } from '../utils/http/HTTPClient';
+import type { HTTPResponse } from '../utils/http/HTTPResponse';
 import { ClixLogger } from '../utils/logging/ClixLogger';
 
 export interface APIResponse {
@@ -9,23 +11,20 @@ export interface APIResponse {
 }
 
 export class ClixAPIClient {
-  private static readonly API_BASE_PATH = '/api/v1';
-
   constructor(private readonly config: ClixConfig) {}
 
+  private static readonly API_BASE_PATH = '/api/v1';
+
   private async getCommonHeaders(): Promise<Record<string, string>> {
     const version = await ClixVersion.getVersion();
     const headers: Record<string, string> = {
       'Content-Type': 'application/json',
       'X-Clix-Project-ID': this.config.projectId,
       'X-Clix-API-Key': this.config.apiKey,
-      'User-Agent': `clix-react-native-sdk/${version}`,
+      'User-Agent': `clix-react-native-sdk@${version}`,
+      ...this.config.extraHeaders,
     };
 
-    if (this.config.extraHeaders) {
-      Object.assign(headers, this.config.extraHeaders);
-    }
-
     return headers;
   }
 
@@ -37,212 +36,153 @@ export class ClixAPIClient {
     return `${baseUrl}${ClixAPIClient.API_BASE_PATH}${fullPath}`;
   }
 
-  private buildUrlWithQuery(
+  async get<T>(
     path: string,
-    queryParameters?: Record<string, any>
-  ): string {
+    params?: Record<string, any>,
+    headers?: Record<string, string>
+  ): Promise<HTTPResponse<T>> {
     const url = this.buildUrl(path);
-
-    if (queryParameters && Object.keys(queryParameters).length > 0) {
-      const searchParams = new URLSearchParams();
-      Object.entries(queryParameters).forEach(([key, value]) => {
-        if (value !== null && value !== undefined) {
-          searchParams.append(key, String(value));
-        }
-      });
-      return `${url}?${searchParams.toString()}`;
-    }
-
-    return url;
-  }
-
-  async get(
-    path: string,
-    options?: {
-      headers?: Record<string, string>;
-      queryParameters?: Record<string, any>;
-    }
-  ): Promise<APIResponse> {
-    const url = this.buildUrlWithQuery(path, options?.queryParameters);
     const commonHeaders = await this.getCommonHeaders();
     const requestHeaders = {
       ...commonHeaders,
-      ...options?.headers,
+      ...headers,
     };
 
     ClixLogger.debug(`API GET ${path}`);
     ClixLogger.debug(`Making request to: ${url}`);
+    if (params && Object.keys(params).length > 0) {
+      ClixLogger.debug(`Query Parameters: ${JSON.stringify(params)}`);
+    }
 
     try {
-      const response = await fetch(url, {
-        method: 'GET',
-        headers: requestHeaders,
-      });
-
-      const data = await this.parseResponse(response);
+      const response = await HTTPClient.shared.get<T>(
+        url,
+        params,
+        requestHeaders
+      );
 
-      ClixLogger.debug(`Response Status: ${response.status}`);
-      ClixLogger.debug(`Response Body: ${JSON.stringify(data)}`);
+      ClixLogger.debug(`Response Status: ${response.statusCode}`);
+      ClixLogger.debug(`Response Body: ${JSON.stringify(response.data)}`);
 
-      return {
-        status: response.status,
-        data,
-        headers: this.headersToRecord(response.headers),
-      };
+      return response;
     } catch (error) {
       ClixLogger.error(`GET ${path} failed`, error);
       throw error;
     }
   }
 
-  async post(
+  async post<T>(
     path: string,
-    options?: {
-      headers?: Record<string, string>;
-      queryParameters?: Record<string, any>;
-      body?: any;
-    }
-  ): Promise<APIResponse> {
-    const url = this.buildUrlWithQuery(path, options?.queryParameters);
+    data?: any,
+    params?: Record<string, any>,
+    headers?: Record<string, string>
+  ): Promise<HTTPResponse<T>> {
+    const url = this.buildUrl(path);
     const commonHeaders = await this.getCommonHeaders();
     const requestHeaders = {
       ...commonHeaders,
-      ...options?.headers,
+      ...headers,
     };
 
     ClixLogger.debug(`API POST ${path}`);
-    if (options?.body) {
-      ClixLogger.debug(`Request Body: ${JSON.stringify(options.body)}`);
+    ClixLogger.debug(`Making request to: ${url}`);
+    if (data) {
+      ClixLogger.debug(`Request Body: ${JSON.stringify(data)}`);
     }
-    if (
-      options?.queryParameters &&
-      Object.keys(options.queryParameters).length > 0
-    ) {
-      ClixLogger.debug(
-        `Query Parameters: ${JSON.stringify(options.queryParameters)}`
-      );
+    if (params && Object.keys(params).length > 0) {
+      ClixLogger.debug(`Query Parameters: ${JSON.stringify(params)}`);
     }
 
-    const body = options?.body ? JSON.stringify(options.body) : undefined;
-
     try {
-      const response = await fetch(url, {
-        method: 'POST',
-        headers: requestHeaders,
-        body,
-      });
-
-      const data = await this.parseResponse(response);
+      const response = await HTTPClient.shared.post<T>(
+        url,
+        data,
+        params,
+        requestHeaders
+      );
 
-      ClixLogger.debug(`Response Status: ${response.status}`);
-      ClixLogger.debug(`Response Body: ${JSON.stringify(data)}`);
+      ClixLogger.debug(`Response Status: ${response.statusCode}`);
+      ClixLogger.debug(`Response Body: ${JSON.stringify(response.data)}`);
 
-      return {
-        status: response.status,
-        data,
-        headers: this.headersToRecord(response.headers),
-      };
+      return response;
     } catch (error) {
       ClixLogger.error(`POST ${path} failed`, error);
       throw error;
     }
   }
 
-  async put(
+  async put<T>(
     path: string,
-    options?: {
-      headers?: Record<string, string>;
-      queryParameters?: Record<string, any>;
-      body?: any;
-    }
-  ): Promise<APIResponse> {
-    const url = this.buildUrlWithQuery(path, options?.queryParameters);
+    data?: any,
+    params?: Record<string, any>,
+    headers?: Record<string, string>
+  ): Promise<HTTPResponse<T>> {
+    const url = this.buildUrl(path);
     const commonHeaders = await this.getCommonHeaders();
     const requestHeaders = {
       ...commonHeaders,
-      ...options?.headers,
+      ...headers,
     };
 
     ClixLogger.debug(`API PUT ${path}`);
-
-    const body = options?.body ? JSON.stringify(options.body) : undefined;
+    ClixLogger.debug(`Making request to: ${url}`);
+    if (data) {
+      ClixLogger.debug(`Request Body: ${JSON.stringify(data)}`);
+    }
+    if (params && Object.keys(params).length > 0) {
+      ClixLogger.debug(`Query Parameters: ${JSON.stringify(params)}`);
+    }
 
     try {
-      const response = await fetch(url, {
-        method: 'PUT',
-        headers: requestHeaders,
-        body,
-      });
-
-      const data = await this.parseResponse(response);
+      const response = await HTTPClient.shared.put<T>(
+        url,
+        data,
+        params,
+        requestHeaders
+      );
 
-      ClixLogger.debug(`Response Status: ${response.status}`);
-      ClixLogger.debug(`Response Body: ${JSON.stringify(data)}`);
+      ClixLogger.debug(`Response Status: ${response.statusCode}`);
+      ClixLogger.debug(`Response Body: ${JSON.stringify(response.data)}`);
 
-      return {
-        status: response.status,
-        data,
-        headers: this.headersToRecord(response.headers),
-      };
+      return response;
     } catch (error) {
       ClixLogger.error(`PUT ${path} failed`, error);
       throw error;
     }
   }
 
-  async delete(
+  async delete<T>(
     path: string,
-    options?: {
-      headers?: Record<string, string>;
-      queryParameters?: Record<string, any>;
-    }
-  ): Promise<APIResponse> {
-    const url = this.buildUrlWithQuery(path, options?.queryParameters);
+    params?: Record<string, any>,
+    headers?: Record<string, string>
+  ): Promise<HTTPResponse<T>> {
+    const url = this.buildUrl(path);
     const commonHeaders = await this.getCommonHeaders();
     const requestHeaders = {
       ...commonHeaders,
-      ...options?.headers,
+      ...headers,
     };
 
     ClixLogger.debug(`API DELETE ${path}`);
+    ClixLogger.debug(`Making request to: ${url}`);
+    if (params && Object.keys(params).length > 0) {
+      ClixLogger.debug(`Query Parameters: ${JSON.stringify(params)}`);
+    }
 
     try {
-      const response = await fetch(url, {
-        method: 'DELETE',
-        headers: requestHeaders,
-      });
-
-      const data = await this.parseResponse(response);
+      const response = await HTTPClient.shared.delete<T>(
+        url,
+        params,
+        requestHeaders
+      );
 
-      ClixLogger.debug(`Response Status: ${response.status}`);
-      ClixLogger.debug(`Response Body: ${JSON.stringify(data)}`);
+      ClixLogger.debug(`Response Status: ${response.statusCode}`);
+      ClixLogger.debug(`Response Body: ${JSON.stringify(response.data)}`);
 
-      return {
-        status: response.status,
-        data,
-        headers: this.headersToRecord(response.headers),
-      };
+      return response;
     } catch (error) {
       ClixLogger.error(`DELETE ${path} failed`, error);
       throw error;
     }
   }
-
-  private async parseResponse(response: Response): Promise<any> {
-    const contentType = response.headers.get('content-type');
-
-    if (contentType && contentType.includes('application/json')) {
-      return await response.json();
-    }
-
-    return await response.text();
-  }
-
-  private headersToRecord(headers: Headers): Record<string, string> {
-    const record: Record<string, string> = {};
-    headers.forEach((value: any, key: string) => {
-      record[key] = value;
-    });
-    return record;
-  }
 }