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

package/src/services/TokenService.ts

@@ -1,82 +1,15 @@
-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;
+  private currentTokenKey = 'clix_current_push_token';
 
   constructor(private readonly storageService: StorageService) {}
 
   getCurrentToken(): string | undefined {
-    try {
-      return this.storageService.get<string>(TokenService.CURRENT_TOKEN_KEY);
-    } catch (error) {
-      ClixLogger.error('Failed to get current token', error);
-      return undefined;
-    }
+    return this.storageService.get<string>(this.currentTokenKey);
   }
 
-  getPreviousTokens(): string[] {
-    try {
-      const result = 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 [];
-    }
-  }
-
-  saveToken(token: string) {
-    try {
-      this.storageService.set(TokenService.CURRENT_TOKEN_KEY, token);
-
-      let tokens = 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);
-      }
-
-      this.storageService.set(TokenService.PREVIOUS_TOKENS_KEY, tokens);
-      ClixLogger.debug('Token saved successfully');
-    } catch (error) {
-      ClixLogger.error('Failed to save token', error);
-      throw error;
-    }
-  }
-
-  clearTokens() {
-    try {
-      this.storageService.remove(TokenService.PREVIOUS_TOKENS_KEY);
-      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('');
-  }
-
-  reset() {
-    this.clearTokens();
+  saveToken(token: string): void {
+    this.storageService.set(this.currentTokenKey, token);
   }
 }

package/src/utils/http/HTTPClient.ts

@@ -0,0 +1,141 @@
+import { HTTPMethod } from './HTTPMethod';
+import type { HTTPRequest } from './HTTPRequest';
+import type { HTTPResponse } from './HTTPResponse';
+
+export class HTTPClient {
+  static shared = new HTTPClient();
+
+  async request<T>(request: HTTPRequest): Promise<HTTPResponse<T>> {
+    const url = this.buildUrlWithParams(request.url, request.params);
+    const headers = { ...(request.headers || {}) };
+    const init: RequestInit = { method: request.method, headers };
+
+    const body = this.prepareBody(request.data);
+    if (
+      body !== undefined &&
+      request.method !== HTTPMethod.GET &&
+      request.method !== HTTPMethod.DELETE
+    ) {
+      init.body = body;
+    }
+
+    const response = await fetch(url, init);
+    const data = await this.parseResponse<T>(response);
+
+    return {
+      data,
+      statusCode: response.status,
+      headers: this.headersToRecord(response.headers),
+    };
+  }
+
+  async get<T>(
+    url: string,
+    params?: Record<string, any>,
+    headers?: Record<string, string>
+  ): Promise<HTTPResponse<T>> {
+    return this.request<T>({ method: HTTPMethod.GET, url, params, headers });
+  }
+
+  async post<T>(
+    url: string,
+    data?: any,
+    params?: Record<string, any>,
+    headers?: Record<string, string>
+  ): Promise<HTTPResponse<T>> {
+    return this.request<T>({
+      method: HTTPMethod.POST,
+      url,
+      data,
+      params,
+      headers,
+    });
+  }
+
+  async put<T>(
+    url: string,
+    data?: any,
+    params?: Record<string, any>,
+    headers?: Record<string, string>
+  ): Promise<HTTPResponse<T>> {
+    return this.request<T>({
+      method: HTTPMethod.PUT,
+      url,
+      data,
+      params,
+      headers,
+    });
+  }
+
+  async delete<T>(
+    url: string,
+    params?: Record<string, any>,
+    headers?: Record<string, string>
+  ): Promise<HTTPResponse<T>> {
+    return this.request<T>({ method: HTTPMethod.DELETE, url, params, headers });
+  }
+
+  private buildUrlWithParams(
+    url: string,
+    params?: Record<string, any>
+  ): string {
+    if (!params || Object.keys(params).length === 0) {
+      return url;
+    }
+
+    const queryString = Object.entries(params)
+      .flatMap(([key, value]) => {
+        if (value === null || value === undefined) {
+          return [];
+        }
+
+        if (Array.isArray(value)) {
+          return value
+            .filter((item) => item !== null && item !== undefined)
+            .map(
+              (item) =>
+                `${encodeURIComponent(key)}=${encodeURIComponent(String(item))}`
+            );
+        }
+
+        return `${encodeURIComponent(key)}=${encodeURIComponent(
+          String(value)
+        )}`;
+      })
+      .filter(Boolean)
+      .join('&');
+
+    if (!queryString) {
+      return url;
+    }
+
+    const separator = url.includes('?') ? '&' : '?';
+    return `${url}${separator}${queryString}`;
+  }
+
+  private prepareBody(data: any): BodyInit | undefined {
+    if (data === undefined || data === null) {
+      return undefined;
+    }
+
+    return JSON.stringify(data);
+  }
+
+  private async parseResponse<T>(response: Response): Promise<T> {
+    const contentType = response.headers.get('content-type');
+
+    if (contentType && contentType.includes('application/json')) {
+      return (await response.json()) as T;
+    }
+
+    return (await response.text()) as unknown as T;
+  }
+
+  private headersToRecord(headers: Headers): Record<string, string> {
+    const record: Record<string, string> = {};
+    headers.forEach((value: string, key: string) => {
+      record[key] = value;
+    });
+    return record;
+  }
+}

package/src/utils/http/HTTPMethod.ts

@@ -0,0 +1,6 @@
+export enum HTTPMethod {
+  GET = 'GET',
+  POST = 'POST',
+  PUT = 'PUT',
+  DELETE = 'DELETE',
+}

package/src/utils/http/HTTPRequest.ts

@@ -0,0 +1,9 @@
+import { HTTPMethod } from './HTTPMethod';
+
+export interface HTTPRequest {
+  url: string;
+  method: HTTPMethod;
+  params?: Record<string, any>;
+  headers?: Record<string, string>;
+  data?: any;
+}

package/src/utils/http/HTTPResponse.ts

@@ -0,0 +1,5 @@
+export interface HTTPResponse<T> {
+  data: T;
+  statusCode: number;
+  headers: Record<string, string>;
+}

package/src/utils/types.ts

@@ -0,0 +1,7 @@
+export type Prettify<T> = {
+  [K in keyof T]: T[K];
+} & {};
+
+export type PickPartial<T, K extends keyof T> = Prettify<
+  Omit<T, K> & Partial<Pick<T, K>>
+>;