@clix-so/react-native-sdk 0.0.1

package/src/core/ClixInitCoordinator.ts

@@ -0,0 +1,65 @@
+import { ClixLogger } from '../utils/logging/ClixLogger';
+
+export class ClixInitCoordinator {
+  private promise: Promise<void>;
+  private resolve: (() => void) | null = null;
+  private reject: ((error: Error) => void) | null = null;
+  private isCompleted = false;
+  private isFailed = false;
+
+  constructor() {
+    this.promise = new Promise<void>((resolve, reject) => {
+      this.resolve = resolve;
+      this.reject = reject;
+    });
+  }
+
+  async waitForInitialization(): Promise<void> {
+    if (this.isCompleted) {
+      return Promise.resolve();
+    }
+    return this.promise;
+  }
+
+  isInitializationFailed(): boolean {
+    return this.isFailed;
+  }
+
+  isInitializationCompleted(): boolean {
+    return this.isCompleted;
+  }
+
+  completeInitialization(): void {
+    if (this.isAlreadyFinalized()) {
+      return;
+    }
+    this.isCompleted = true;
+    this.resolve?.();
+  }
+
+  failInitialization(error: Error): void {
+    if (this.isAlreadyFinalized()) {
+      return;
+    }
+    this.isFailed = true;
+    ClixLogger.warn('Clix initialization failed:', error);
+    this.reject?.(error);
+  }
+
+  reset(): void {
+    this.isCompleted = false;
+    this.isFailed = false;
+    this.promise = new Promise<void>((resolve, reject) => {
+      this.resolve = resolve;
+      this.reject = reject;
+    });
+  }
+
+  private isAlreadyFinalized(): boolean {
+    if (this.isCompleted || this.isFailed) {
+      ClixLogger.warn('Initialization already completed or failed');
+      return true;
+    }
+    return false;
+  }
+}

package/src/core/ClixVersion.ts

@@ -0,0 +1,17 @@
+export class ClixVersion {
+  private static cachedVersion?: string;
+  private static fallBackVersion: string = '0.0.0';
+
+  static async getVersion(): Promise<string> {
+    if (this.cachedVersion) {
+      return this.cachedVersion;
+    }
+    try {
+      this.cachedVersion =
+        require('../../../package.json').version || this.fallBackVersion;
+      return this.cachedVersion!;
+    } catch (error) {
+      return '0.0.0';
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+import { Clix } from './core/Clix';
+import { ClixLogLevel } from './utils/logging/ClixLogger';
+
+export { ClixLogLevel };
+export default Clix;

package/src/models/ClixDevice.ts

@@ -0,0 +1,88 @@
+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;
+
+  constructor(device: {
+    id: string;
+    platform: string;
+    model: string;
+    manufacturer: string;
+    osName: string;
+    osVersion: string;
+    localeRegion: string;
+    localeLanguage: string;
+    timezone: string;
+    appName: string;
+    appVersion: string;
+    sdkType: string;
+    sdkVersion: string;
+    adId?: string;
+    isPushPermissionGranted: boolean;
+    pushToken?: string;
+    pushTokenType?: string;
+  }) {
+    this.id = device.id;
+    this.platform = device.platform;
+    this.model = device.model;
+    this.manufacturer = device.manufacturer;
+    this.osName = device.osName;
+    this.osVersion = device.osVersion;
+    this.localeRegion = device.localeRegion;
+    this.localeLanguage = device.localeLanguage;
+    this.timezone = device.timezone;
+    this.appName = device.appName;
+    this.appVersion = device.appVersion;
+    this.sdkType = device.sdkType;
+    this.sdkVersion = device.sdkVersion;
+    this.adId = device.adId;
+    this.isPushPermissionGranted = device.isPushPermissionGranted;
+    this.pushToken = device.pushToken;
+    this.pushTokenType = device.pushTokenType;
+  }
+
+  copyWith(updates: Partial<ClixDevice>): ClixDevice {
+    return new ClixDevice({
+      id: updates.id ?? this.id,
+      platform: updates.platform ?? this.platform,
+      model: updates.model ?? this.model,
+      manufacturer: updates.manufacturer ?? this.manufacturer,
+      osName: updates.osName ?? this.osName,
+      osVersion: updates.osVersion ?? this.osVersion,
+      localeRegion: updates.localeRegion ?? this.localeRegion,
+      localeLanguage: updates.localeLanguage ?? this.localeLanguage,
+      timezone: updates.timezone ?? this.timezone,
+      appName: updates.appName ?? this.appName,
+      appVersion: updates.appVersion ?? this.appVersion,
+      sdkType: updates.sdkType ?? this.sdkType,
+      sdkVersion: updates.sdkVersion ?? this.sdkVersion,
+      adId: updates.adId ?? this.adId,
+      isPushPermissionGranted:
+        updates.isPushPermissionGranted ?? this.isPushPermissionGranted,
+      pushToken: updates.pushToken ?? this.pushToken,
+      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

@@ -0,0 +1,38 @@
+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})`;
+  }
+}

package/src/models/ClixUserProperty.ts

@@ -0,0 +1,58 @@
+export enum PropertyType {
+  String = 'USER_PROPERTY_TYPE_STRING',
+  Number = 'USER_PROPERTY_TYPE_NUMBER',
+  Boolean = 'USER_PROPERTY_TYPE_BOOLEAN',
+}
+
+export class ClixUserProperty {
+  public readonly name: string;
+  public readonly valueString: any;
+  public readonly type: PropertyType;
+
+  constructor(property: {
+    name: string;
+    valueString: any;
+    type: PropertyType;
+  }) {
+    this.name = property.name;
+    this.valueString = property.valueString;
+    this.type = property.type;
+  }
+
+  static of(name: string, value: any): ClixUserProperty {
+    let type: PropertyType;
+    let codableValue: any;
+
+    if (typeof value === 'boolean') {
+      type = PropertyType.Boolean;
+      codableValue = value;
+    } else if (typeof value === 'number') {
+      type = PropertyType.Number;
+      codableValue = value;
+    } else if (typeof value === 'string') {
+      type = PropertyType.String;
+      codableValue = value;
+    } else {
+      type = PropertyType.String;
+      codableValue = value.toString();
+    }
+
+    return new ClixUserProperty({
+      name,
+      valueString: codableValue,
+      type,
+    });
+  }
+
+  equals(other: ClixUserProperty): boolean {
+    return (
+      this.name === other.name &&
+      this.valueString === other.valueString &&
+      this.type === other.type
+    );
+  }
+
+  toString(): string {
+    return `ClixUserProperty(name: ${this.name}, value: ${this.valueString}, type: ${this.type})`;
+  }
+}

package/src/services/ClixAPIClient.ts

@@ -0,0 +1,248 @@
+import type { ClixConfig } from '../core/ClixConfig';
+import { ClixVersion } from '../core/ClixVersion';
+import { ClixLogger } from '../utils/logging/ClixLogger';
+
+export interface APIResponse {
+  status: number;
+  data: any;
+  headers: Record<string, string>;
+}
+
+export class ClixAPIClient {
+  private static readonly API_BASE_PATH = '/api/v1';
+
+  constructor(private readonly config: ClixConfig) {}
+
+  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}`,
+    };
+
+    if (this.config.extraHeaders) {
+      Object.assign(headers, this.config.extraHeaders);
+    }
+
+    return headers;
+  }
+
+  private buildUrl(path: string): string {
+    const endpoint = this.config.endpoint || 'https://api.clix.so';
+    const baseUrl = endpoint.endsWith('/') ? endpoint.slice(0, -1) : endpoint;
+
+    const fullPath = path.startsWith('/') ? path : `/${path}`;
+    return `${baseUrl}${ClixAPIClient.API_BASE_PATH}${fullPath}`;
+  }
+
+  private buildUrlWithQuery(
+    path: string,
+    queryParameters?: Record<string, any>
+  ): string {
+    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,
+    };
+
+    ClixLogger.debug(`API GET ${path}`);
+    ClixLogger.debug(`Making request to: ${url}`);
+
+    try {
+      const response = await fetch(url, {
+        method: 'GET',
+        headers: requestHeaders,
+      });
+
+      const data = await this.parseResponse(response);
+
+      ClixLogger.debug(`Response Status: ${response.status}`);
+      ClixLogger.debug(`Response Body: ${JSON.stringify(data)}`);
+
+      return {
+        status: response.status,
+        data,
+        headers: this.headersToRecord(response.headers),
+      };
+    } catch (error) {
+      ClixLogger.error(`GET ${path} failed`, error);
+      throw error;
+    }
+  }
+
+  async post(
+    path: string,
+    options?: {
+      headers?: Record<string, string>;
+      queryParameters?: Record<string, any>;
+      body?: any;
+    }
+  ): Promise<APIResponse> {
+    const url = this.buildUrlWithQuery(path, options?.queryParameters);
+    const commonHeaders = await this.getCommonHeaders();
+    const requestHeaders = {
+      ...commonHeaders,
+      ...options?.headers,
+    };
+
+    ClixLogger.debug(`API POST ${path}`);
+    if (options?.body) {
+      ClixLogger.debug(`Request Body: ${JSON.stringify(options.body)}`);
+    }
+    if (
+      options?.queryParameters &&
+      Object.keys(options.queryParameters).length > 0
+    ) {
+      ClixLogger.debug(
+        `Query Parameters: ${JSON.stringify(options.queryParameters)}`
+      );
+    }
+
+    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);
+
+      ClixLogger.debug(`Response Status: ${response.status}`);
+      ClixLogger.debug(`Response Body: ${JSON.stringify(data)}`);
+
+      return {
+        status: response.status,
+        data,
+        headers: this.headersToRecord(response.headers),
+      };
+    } catch (error) {
+      ClixLogger.error(`POST ${path} failed`, error);
+      throw error;
+    }
+  }
+
+  async put(
+    path: string,
+    options?: {
+      headers?: Record<string, string>;
+      queryParameters?: Record<string, any>;
+      body?: any;
+    }
+  ): Promise<APIResponse> {
+    const url = this.buildUrlWithQuery(path, options?.queryParameters);
+    const commonHeaders = await this.getCommonHeaders();
+    const requestHeaders = {
+      ...commonHeaders,
+      ...options?.headers,
+    };
+
+    ClixLogger.debug(`API PUT ${path}`);
+
+    const body = options?.body ? JSON.stringify(options.body) : undefined;
+
+    try {
+      const response = await fetch(url, {
+        method: 'PUT',
+        headers: requestHeaders,
+        body,
+      });
+
+      const data = await this.parseResponse(response);
+
+      ClixLogger.debug(`Response Status: ${response.status}`);
+      ClixLogger.debug(`Response Body: ${JSON.stringify(data)}`);
+
+      return {
+        status: response.status,
+        data,
+        headers: this.headersToRecord(response.headers),
+      };
+    } catch (error) {
+      ClixLogger.error(`PUT ${path} failed`, error);
+      throw error;
+    }
+  }
+
+  async delete(
+    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,
+    };
+
+    ClixLogger.debug(`API DELETE ${path}`);
+
+    try {
+      const response = await fetch(url, {
+        method: 'DELETE',
+        headers: requestHeaders,
+      });
+
+      const data = await this.parseResponse(response);
+
+      ClixLogger.debug(`Response Status: ${response.status}`);
+      ClixLogger.debug(`Response Body: ${JSON.stringify(data)}`);
+
+      return {
+        status: response.status,
+        data,
+        headers: this.headersToRecord(response.headers),
+      };
+    } 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;
+  }
+}

package/src/services/DeviceAPIService.ts

@@ -0,0 +1,187 @@
+import { ClixDevice } from '../models/ClixDevice';
+import { ClixUserProperty } from '../models/ClixUserProperty';
+import { ClixLogger } from '../utils/logging/ClixLogger';
+import { ClixAPIClient } from './ClixAPIClient';
+
+export class DeviceAPIService {
+  constructor(private readonly apiClient: ClixAPIClient) {}
+
+  async registerDevice(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,
+            },
+          ],
+        },
+      });
+
+      if (response.status < 200 || response.status >= 300) {
+        throw new Error(
+          `HTTP ${response.status}: ${JSON.stringify(response.data)}`
+        );
+      }
+
+      ClixLogger.debug(`Device upserted successfully: ${device.id}`);
+    } catch (error) {
+      ClixLogger.error(`Failed to upsert device: ${device.id}`, error);
+      throw error;
+    }
+  }
+
+  async setProjectUserId(
+    deviceId: string,
+    projectUserId: string
+  ): Promise<void> {
+    try {
+      ClixLogger.debug(`Setting project user ID for device: ${deviceId}`);
+
+      const response = await this.apiClient.post(
+        `/devices/${deviceId}/user/project-user-id`,
+        {
+          body: {
+            project_user_id: projectUserId,
+          },
+        }
+      );
+
+      if (response.status < 200 || response.status >= 300) {
+        throw new Error(
+          `HTTP ${response.status}: ${JSON.stringify(response.data)}`
+        );
+      }
+
+      ClixLogger.debug(
+        `Project user ID set successfully for device: ${deviceId}`
+      );
+    } catch (error) {
+      ClixLogger.error(
+        `Failed to set project user ID for device: ${deviceId}`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  async removeProjectUserId(deviceId: string): Promise<void> {
+    try {
+      ClixLogger.debug(`Removing project user ID for device: ${deviceId}`);
+
+      const response = await this.apiClient.delete(
+        `/devices/${deviceId}/user/project-user-id`
+      );
+
+      if (response.status < 200 || response.status >= 300) {
+        throw new Error(
+          `HTTP ${response.status}: ${JSON.stringify(response.data)}`
+        );
+      }
+
+      ClixLogger.debug(
+        `Project user ID removed successfully for device: ${deviceId}`
+      );
+    } catch (error) {
+      ClixLogger.error(
+        `Failed to remove project user ID for device: ${deviceId}`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  async upsertUserProperties(
+    deviceId: string,
+    properties: ClixUserProperty[]
+  ): Promise<void> {
+    try {
+      ClixLogger.debug(
+        `Upserting ${properties.length} user properties for device: ${deviceId}`
+      );
+
+      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,
+            })),
+          },
+        }
+      );
+
+      if (response.status < 200 || response.status >= 300) {
+        throw new Error(
+          `HTTP ${response.status}: ${JSON.stringify(response.data)}`
+        );
+      }
+
+      ClixLogger.debug(
+        `User properties upserted successfully for device: ${deviceId}`
+      );
+    } catch (error) {
+      ClixLogger.error(
+        `Failed to upsert user properties for device: ${deviceId}`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  async removeUserProperties(
+    deviceId: string,
+    propertyNames: string[]
+  ): Promise<void> {
+    try {
+      ClixLogger.debug(
+        `Removing ${propertyNames.length} user properties for device: ${deviceId}`
+      );
+
+      const response = await this.apiClient.delete(
+        `/devices/${deviceId}/user/properties`,
+        {
+          queryParameters: {
+            property_names: propertyNames.join(','),
+          },
+        }
+      );
+
+      if (response.status < 200 || response.status >= 300) {
+        throw new Error(
+          `HTTP ${response.status}: ${JSON.stringify(response.data)}`
+        );
+      }
+
+      ClixLogger.debug(
+        `User properties removed successfully for device: ${deviceId}`
+      );
+    } catch (error) {
+      ClixLogger.error(
+        `Failed to remove user properties for device: ${deviceId}`,
+        error
+      );
+      throw error;
+    }
+  }
+}