@clix-so/react-native-sdk 0.0.1

package/src/services/StorageService.ts

@@ -0,0 +1,84 @@
+import { MMKV } from 'react-native-mmkv';
+import { ClixLogger } from '../utils/logging/ClixLogger';
+
+export class StorageService {
+  private storage: MMKV;
+
+  constructor() {
+    this.storage = new MMKV({
+      id: 'clix-storage',
+      encryptionKey: undefined, // Add encryption if needed
+    });
+  }
+
+  async set<T>(key: string, value: T): Promise<void> {
+    if (value === undefined) {
+      try {
+        this.storage.delete(key);
+      } catch (error) {
+        ClixLogger.error(`Failed to remove value for key: ${key}`, error);
+      }
+      return;
+    }
+
+    try {
+      const encoded = JSON.stringify(value);
+      this.storage.set(key, encoded);
+    } catch (error) {
+      ClixLogger.error(`Failed to set value for key: ${key}`, error);
+      // Don't throw storage errors to prevent initialization failure
+      return;
+    }
+  }
+
+  async get<T>(key: string): Promise<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;
+      } catch (jsonError) {
+        // Handle legacy string values
+        ClixLogger.debug(
+          `Found legacy string value for key: ${key}, migrating to JSON format`
+        );
+        await this.set(key, data);
+        return data as T;
+      }
+    } catch (error) {
+      ClixLogger.error(`Failed to get value for key: ${key}`, error);
+      // Return undefined instead of throwing to prevent initialization failure
+      return undefined;
+    }
+  }
+
+  async remove(key: string): Promise<void> {
+    try {
+      this.storage.delete(key);
+    } catch (error) {
+      ClixLogger.error(`Failed to remove key: ${key}`, error);
+      // Don't throw to prevent initialization failure
+      return;
+    }
+  }
+
+  async clear(): Promise<void> {
+    try {
+      this.storage.clearAll();
+    } catch (error) {
+      ClixLogger.error('Failed to clear storage', error);
+      throw error;
+    }
+  }
+
+  async getAllKeys(): Promise<string[]> {
+    try {
+      const keys = this.storage.getAllKeys();
+      return Array.from(keys);
+    } catch (error) {
+      ClixLogger.error('Failed to get all keys', error);
+      return [];
+    }
+  }
+}

package/src/services/TokenService.ts

@@ -0,0 +1,84 @@
+import { ClixLogger } from '../utils/logging/ClixLogger';
+import { StorageService } from './StorageService';
+
+export class TokenService {
+  private static readonly CURRENT_TOKEN_KEY = 'clix_current_push_token';
+  private static readonly PREVIOUS_TOKENS_KEY = 'clix_push_tokens';
+  private static readonly MAX_TOKENS = 5;
+
+  constructor(private readonly storageService: StorageService) {}
+
+  async getCurrentToken(): Promise<string | undefined> {
+    try {
+      return await this.storageService.get<string>(
+        TokenService.CURRENT_TOKEN_KEY
+      );
+    } catch (error) {
+      ClixLogger.error('Failed to get current token', error);
+      return undefined;
+    }
+  }
+
+  async getPreviousTokens(): Promise<string[]> {
+    try {
+      const result = await this.storageService.get<string[]>(
+        TokenService.PREVIOUS_TOKENS_KEY
+      );
+      if (result === undefined) return [];
+
+      return Array.isArray(result) ? result : [];
+    } catch (error) {
+      ClixLogger.error('Failed to get previous tokens', error);
+      return [];
+    }
+  }
+
+  async saveToken(token: string): Promise<void> {
+    try {
+      await this.storageService.set(TokenService.CURRENT_TOKEN_KEY, token);
+
+      let tokens = await this.getPreviousTokens();
+
+      // Remove existing token if present
+      const currentIndex = tokens.indexOf(token);
+      if (currentIndex !== -1) {
+        tokens.splice(currentIndex, 1);
+      }
+
+      // Add new token
+      tokens.push(token);
+
+      // Keep only the last MAX_TOKENS
+      if (tokens.length > TokenService.MAX_TOKENS) {
+        tokens = tokens.slice(-TokenService.MAX_TOKENS);
+      }
+
+      await this.storageService.set(TokenService.PREVIOUS_TOKENS_KEY, tokens);
+      ClixLogger.debug('Token saved successfully');
+    } catch (error) {
+      ClixLogger.error('Failed to save token', error);
+      throw error;
+    }
+  }
+
+  async clearTokens(): Promise<void> {
+    try {
+      await this.storageService.remove(TokenService.PREVIOUS_TOKENS_KEY);
+      await this.storageService.remove(TokenService.CURRENT_TOKEN_KEY);
+      ClixLogger.debug('All tokens cleared');
+    } catch (error) {
+      ClixLogger.error('Failed to clear tokens', error);
+      throw error;
+    }
+  }
+
+  convertTokenToString(deviceToken: number[]): string {
+    return deviceToken
+      .map((data) => data.toString(16).padStart(2, '0'))
+      .join('');
+  }
+
+  async reset(): Promise<void> {
+    await this.clearTokens();
+  }
+}

package/src/utils/ClixError.ts

@@ -0,0 +1,78 @@
+export enum ClixErrorCode {
+  NOT_INITIALIZED = 'NOT_INITIALIZED',
+  INVALID_CONFIGURATION = 'INVALID_CONFIGURATION',
+  INVALID_URL = 'INVALID_URL',
+  INVALID_RESPONSE = 'INVALID_RESPONSE',
+  ENCODING_ERROR = 'ENCODING_ERROR',
+  DECODING_ERROR = 'DECODING_ERROR',
+  NETWORK_ERROR = 'NETWORK_ERROR',
+  UNKNOWN_ERROR = 'UNKNOWN_ERROR',
+}
+
+const ClixErrorMessages: Record<ClixErrorCode, string> = {
+  [ClixErrorCode.NOT_INITIALIZED]:
+    'Clix SDK is not initialized. Call Clix.initialize() first.',
+  [ClixErrorCode.INVALID_CONFIGURATION]: 'Invalid SDK configuration.',
+  [ClixErrorCode.INVALID_URL]: 'The provided URL is invalid.',
+  [ClixErrorCode.INVALID_RESPONSE]:
+    'The response was invalid or permission was denied.',
+  [ClixErrorCode.ENCODING_ERROR]: 'Failed to encode request body.',
+  [ClixErrorCode.DECODING_ERROR]: 'Failed to decode response body.',
+  [ClixErrorCode.NETWORK_ERROR]: 'Network request failed.',
+  [ClixErrorCode.UNKNOWN_ERROR]: 'An unknown error occurred.',
+};
+
+export class ClixError extends Error {
+  readonly code: ClixErrorCode;
+  override cause?: unknown;
+
+  constructor(
+    code: ClixErrorCode,
+    message?: string,
+    options?: { cause?: unknown }
+  ) {
+    super(message ?? ClixErrorMessages[code]);
+    this.name = 'ClixError';
+    this.code = code;
+    if (options?.cause) {
+      this.cause = options.cause;
+    }
+  }
+
+  static notInitialized(options?: { cause?: unknown }) {
+    return new ClixError(ClixErrorCode.NOT_INITIALIZED, undefined, options);
+  }
+  static invalidConfiguration(options?: { cause?: unknown }) {
+    return new ClixError(
+      ClixErrorCode.INVALID_CONFIGURATION,
+      undefined,
+      options
+    );
+  }
+  static invalidURL(options?: { cause?: unknown }) {
+    return new ClixError(ClixErrorCode.INVALID_URL, undefined, options);
+  }
+  static invalidResponse(options?: { cause?: unknown }) {
+    return new ClixError(ClixErrorCode.INVALID_RESPONSE, undefined, options);
+  }
+  static encodingError(options?: { cause?: unknown }) {
+    return new ClixError(ClixErrorCode.ENCODING_ERROR, undefined, options);
+  }
+  static decodingError(options?: { cause?: unknown }) {
+    return new ClixError(ClixErrorCode.DECODING_ERROR, undefined, options);
+  }
+  static networkError(underlyingError: unknown) {
+    return new ClixError(ClixErrorCode.NETWORK_ERROR, undefined, {
+      cause: underlyingError,
+    });
+  }
+  static unknownError(options?: { cause?: unknown; reason?: string }) {
+    const msg =
+      options?.reason != null
+        ? `${ClixErrorMessages[ClixErrorCode.UNKNOWN_ERROR]}: ${options.reason}`
+        : undefined;
+    return new ClixError(ClixErrorCode.UNKNOWN_ERROR, msg, {
+      cause: options?.cause,
+    });
+  }
+}

package/src/utils/UUID.ts

@@ -0,0 +1,29 @@
+import 'react-native-get-random-values';
+import { v4 as uuidv4 } from 'uuid';
+import { ClixLogger } from './logging/ClixLogger';
+
+export class UUID {
+  /**
+   * Generates a new UUID v4
+   * @returns A new UUID string
+   */
+  static generate(): string {
+    try {
+      return uuidv4();
+    } catch (error) {
+      ClixLogger.warn(
+        'UUID generation failed, using fallback ID generation',
+        error
+      );
+      return this.generateFallbackId();
+    }
+  }
+
+  /**
+   * Generates a fallback ID when UUID generation fails
+   * @returns A fallback ID string
+   */
+  private static generateFallbackId(): string {
+    return `clix_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+}

package/src/utils/logging/ClixLogger.ts

@@ -0,0 +1,61 @@
+export enum ClixLogLevel {
+  NONE = 0,
+  ERROR = 1,
+  WARN = 2,
+  INFO = 3,
+  DEBUG = 4,
+}
+
+export class ClixLogger {
+  private static logLevel: ClixLogLevel = ClixLogLevel.INFO;
+
+  static setLogLevel(level: ClixLogLevel): void {
+    this.logLevel = level;
+  }
+
+  static shouldLog(level: ClixLogLevel): boolean {
+    return this.logLevel >= level;
+  }
+
+  static log(level: ClixLogLevel, message: string, error?: any): void {
+    if (level > this.logLevel) {
+      return;
+    }
+
+    const timestamp = new Date().toISOString();
+    const messages = [`[Clix][${timestamp}] ${message}`, error].filter(Boolean);
+
+    switch (level) {
+      case ClixLogLevel.DEBUG:
+        console.debug(...messages);
+        break;
+      case ClixLogLevel.INFO:
+        console.info(...messages);
+        break;
+      case ClixLogLevel.WARN:
+        console.warn(...messages);
+        break;
+      case ClixLogLevel.ERROR:
+        console.error(...messages);
+        break;
+      case ClixLogLevel.NONE:
+        return;
+    }
+  }
+
+  static error(message: string, error?: any): void {
+    this.log(ClixLogLevel.ERROR, message, error);
+  }
+
+  static warn(message: string, error?: any): void {
+    this.log(ClixLogLevel.WARN, message, error);
+  }
+
+  static info(message: string, error?: any): void {
+    this.log(ClixLogLevel.INFO, message, error);
+  }
+
+  static debug(message: string, error?: any): void {
+    this.log(ClixLogLevel.DEBUG, message, error);
+  }
+}