@savers_app/react-native-sandbox-sdk 1.2.6

package/src/data/network/apiRepository.ts

@@ -0,0 +1,130 @@
+// Services / API clients
+import { ApiClient } from './apiClient';
+
+// Types / Models
+import type { ApiResponse } from '../models/apiResponse';
+import { apiError, apiSuccess } from '../models/apiResponse';
+
+// Storage
+import {
+  get as storageGet,
+  save as storageSave,
+} from '../storage/storageManager';
+
+export enum CacheStrategy {
+  cache = 'cache',
+  cacheOnly = 'cacheOnly',
+  network = 'network',
+  normal = 'normal',
+}
+
+export class ApiRepository {
+  private readonly apiClient: ApiClient;
+
+  constructor(apiClient: ApiClient) {
+    this.apiClient = apiClient;
+  }
+
+  async *getData<T>(
+    endpoint: string,
+    opts?: {
+      cacheStrategy?: CacheStrategy;
+      params?: Record<string, any>;
+      storageKeyPrefix?: string;
+      method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
+      body?: any;
+    }
+  ): AsyncGenerator<ApiResponse<T | null>, void, unknown> {
+    const cacheStrategy = opts?.cacheStrategy ?? CacheStrategy.normal;
+    const cacheKey =
+      (opts?.storageKeyPrefix ?? '') +
+      endpoint +
+      JSON.stringify({
+        params: opts?.params ?? {},
+        method: opts?.method ?? 'GET',
+        body: opts?.body ?? null,
+      });
+
+    if (cacheStrategy === CacheStrategy.cache) {
+      const cached = await storageGet(cacheKey);
+      if (cached !== null && cached !== undefined) {
+        yield apiSuccess<T>(cached as T, 'Data fetched from cache', true);
+      } else {
+        const res = await this.fetchFromNetwork<T>(
+          endpoint,
+          opts?.params,
+          cacheKey,
+          opts?.method,
+          opts?.body
+        );
+        yield res;
+      }
+      return;
+    }
+
+    if (cacheStrategy === CacheStrategy.cacheOnly) {
+      const cached = await storageGet(cacheKey);
+      if (cached !== null && cached !== undefined) {
+        yield apiSuccess<T>(cached as T, 'Data fetched from cache', true);
+      } else {
+        yield apiError('No cached data found') as ApiResponse<T | null>;
+      }
+      return;
+    }
+
+    if (cacheStrategy === CacheStrategy.network) {
+      const res = await this.fetchFromNetwork<T>(
+        endpoint,
+        opts?.params,
+        cacheKey,
+        opts?.method,
+        opts?.body
+      );
+      yield res;
+      return;
+    }
+
+    const cached = await storageGet(cacheKey);
+    if (cached !== null && cached !== undefined) {
+      yield apiSuccess<T>(cached as T, 'Data fetched from cache', true);
+    }
+    const res = await this.fetchFromNetwork<T>(
+      endpoint,
+      opts?.params,
+      cacheKey,
+      opts?.method,
+      opts?.body
+    );
+    yield res;
+  }
+
+  private async fetchFromNetwork<T>(
+    endpoint: string,
+    params?: Record<string, any>,
+    cacheKey?: string,
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE',
+    body?: any
+  ): Promise<ApiResponse<T | null>> {
+    try {
+      const m = (method || 'GET').toUpperCase();
+      let response: any;
+      if (m === 'POST') {
+        response = await this.apiClient.post(endpoint, body, params);
+      } else if (m === 'PUT') {
+        response = await this.apiClient.put(endpoint, body, params);
+      } else if (m === 'DELETE') {
+        response = await this.apiClient.delete(endpoint, body, params);
+      } else {
+        response = await this.apiClient.get(endpoint, params);
+      }
+      const data = response?.data ?? null;
+      const message = response?.message ?? response?.statusText ?? 'No message';
+      if (data !== null && cacheKey) {
+        await storageSave(cacheKey, data);
+      }
+      return apiSuccess<T>(data, message, false);
+    } catch (e) {
+      return apiError(`Network request failed: ${e}`) as ApiResponse<T | null>;
+    }
+  }
+}

package/src/data/network/apiService.ts

@@ -0,0 +1,113 @@
+// Utilities
+import { logger } from '../../utils/logger';
+
+// Types / Models
+import type { ApiResponse } from '../models/apiResponse';
+import {
+  type OnBoardingData,
+  onBoardingDataFromJson,
+} from '../models/onboardingModel';
+import {
+  type TokenResponse,
+  tokenResponseFromJson,
+} from '../models/tokenModel';
+
+// Storage
+import { clearAll as storageClearAll } from '../storage/storageManager';
+
+// API
+import { ApiEndpoints } from './apiEndpoints';
+import { ApiRepository, CacheStrategy } from './apiRepository';
+import { Environment, ApiClient } from './apiClient';
+
+export class ApiService {
+  private repository: ApiRepository;
+
+  constructor(environment: Environment = Environment.production) {
+    const apiClient = new ApiClient(environment);
+    this.repository = new ApiRepository(apiClient);
+    logger.info(`ApiService initialized with environment: ${environment}`);
+  }
+
+  /**
+   * Get onboarding data using GenericRepository with stream
+   */
+  async *getOnBoarding(opts?: {
+    cacheStrategy?: CacheStrategy;
+  }): AsyncGenerator<ApiResponse<OnBoardingData | null>, void, unknown> {
+    const generator = this.repository.getData<any>(ApiEndpoints.onboarding, {
+      cacheStrategy: opts?.cacheStrategy ?? CacheStrategy.normal,
+    });
+
+    for await (const response of generator) {
+      if (response.status === true && response.data) {
+        try {
+          const parsedData = onBoardingDataFromJson(response.data);
+          yield {
+            ...response,
+            data: parsedData,
+          };
+        } catch (e) {
+          yield {
+            status: false,
+            message: `Failed to parse onboarding data: ${e}`,
+            data: null,
+            fromCache: response.fromCache,
+          };
+        }
+      } else {
+        yield {
+          status: false,
+          message: response.message ?? 'Failed to load onboarding data',
+          data: null,
+          fromCache: response.fromCache,
+        };
+      }
+    }
+  }
+
+  async *getNonce({
+    cacheStrategy = CacheStrategy.network,
+    extUserId = '',
+    partnerCode = '',
+  }): AsyncGenerator<TokenResponse, void, unknown> {
+    const generator = this.repository.getData<any>(ApiEndpoints.get_nonce, {
+      cacheStrategy,
+      method: 'POST',
+      body: {
+        extUserId,
+        partnerCode,
+      },
+    });
+
+    for await (const response of generator) {
+      if (response.data) {
+        try {
+          yield tokenResponseFromJson(response.data);
+        } catch (e) {
+          yield {
+            token: null,
+            statusCode: null,
+            error: `Failed to parse nonce: ${e}`,
+            messages: null,
+          };
+        }
+      } else {
+        yield {
+          token: null,
+          statusCode: null,
+          error: response.message ?? 'Failed to load nonce',
+          messages: null,
+        };
+      }
+    }
+  }
+
+  /**
+   * Clear all cached data
+   */
+  async clearCache(): Promise<void> {
+    await storageClearAll();
+    logger.info('Cache cleared');
+  }
+}

package/src/data/network/dataTypeUtils.ts

@@ -0,0 +1,78 @@
+export function parseToString(value: any): string | null {
+  if (value === null || value === undefined) return null;
+  if (typeof value === 'string') return value;
+  if (typeof value === 'number') return String(value);
+  if (typeof value === 'boolean') return String(value);
+  return String(value);
+}
+
+export function parseToInt(value: any): number | null {
+  if (value === null || value === undefined) return null;
+  if (typeof value === 'number') return Math.trunc(value);
+  if (typeof value === 'string') {
+    const n = Number(value);
+    if (!Number.isNaN(n)) return Math.trunc(n);
+  }
+  return null;
+}
+
+export function parseToDouble(value: any): number | null {
+  if (value === null || value === undefined) return null;
+  if (typeof value === 'number') return value;
+  if (typeof value === 'string') {
+    const n = Number(value);
+    if (!Number.isNaN(n)) return n;
+  }
+  return null;
+}
+
+export function parseToBool(value: any): boolean | null {
+  if (value === null || value === undefined) return null;
+  if (typeof value === 'boolean') return value;
+  if (typeof value === 'number') return value === 1;
+  if (typeof value === 'string') {
+    const v = value.toLowerCase();
+    if (v === 'true' || v === '1' || v === 'yes') return true;
+    if (v === 'false' || v === '0' || v === 'no') return false;
+  }
+  return null;
+}
+
+export function parseToMap(value: any): Record<string, any> | null {
+  if (value === null || value === undefined) return null;
+  if (typeof value === 'object' && !Array.isArray(value)) {
+    return { ...value };
+  }
+  return null;
+}
+
+export function parseToList(value: any): any[] | null {
+  if (Array.isArray(value)) return value;
+  return null;
+}
+
+export function parseToStringList(value: any): string[] | null {
+  if (!Array.isArray(value)) return null;
+  const out: string[] = [];
+  for (const item of value) {
+    const s = parseToString(item);
+    if (s !== null) out.push(s);
+  }
+  return out;
+}
+
+export function isNullOrEmpty(value: any): boolean {
+  if (value === null || value === undefined) return true;
+  if (typeof value === 'string') return value.length === 0;
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === 'object') return Object.keys(value).length === 0;
+  return false;
+}
+
+export function safeParseForModel(data: any): any {
+  if (data === null || data === undefined) return null;
+  if (typeof data === 'object' && !Array.isArray(data)) {
+    return { ...data };
+  }
+  return data;
+}

package/src/data/network/interceptors/authInterceptor.ts

@@ -0,0 +1,86 @@
+/* eslint-disable no-unreachable */
+
+// Utilities
+import { logger } from '../../../utils/logger';
+
+export class AuthInterceptor {
+  private static readonly xApiKey = 'x-api-key';
+  private static readonly oauthSubIdKey = 'oauthSubId';
+  private static readonly bodyMethods = new Set(['POST', 'PUT', 'PATCH']);
+  private static readonly excludedApis = new Set<string>();
+
+  async onRequest(options: any): Promise<any> {
+    try {
+      if (this.shouldExcludeApi(options.url)) {
+        return options;
+      }
+
+      this.addApiKeyHeader(
+        options,
+        AuthInterceptor.xApiKey,
+        '3xqpYp6CPn899166YXbEB1YLJIhfdj08BbCdfQdg'
+      );
+
+      const userId = await this.getCurrentUserId();
+      if (userId) {
+        this.addAuthenticationData(options, userId);
+      }
+    } catch (e) {
+      logger.error('AuthInterceptor error:', e);
+    }
+
+    return options;
+  }
+
+  private addAuthenticationData(options: any, userId: string) {
+    const method = (options.method || 'GET').toUpperCase();
+
+    if (AuthInterceptor.bodyMethods.has(method)) {
+      this.addToQueryParametersAndBody(options, userId);
+    } else {
+      this.addToQueryParameters(options, userId);
+    }
+  }
+
+  private addToQueryParameters(options: any, userId: string) {
+    options.params = options.params || {};
+    options.params[AuthInterceptor.oauthSubIdKey] = userId;
+  }
+
+  private addToQueryParametersAndBody(options: any, userId: string) {
+    this.addToQueryParameters(options, userId);
+    this.addToRequestBody(options, userId);
+  }
+
+  private addToRequestBody(options: any, userId: string) {
+    if (options.body instanceof FormData) {
+      options.body.append(AuthInterceptor.oauthSubIdKey, userId);
+    } else if (typeof options.body === 'object' && options.body !== null) {
+      options.body[AuthInterceptor.oauthSubIdKey] = userId;
+    }
+  }
+
+  private addApiKeyHeader(options: any, key: string, value: string) {
+    options.headers = options.headers || {};
+    options.headers[key] = value;
+  }
+
+  private shouldExcludeApi(apiPath: string): boolean {
+    if (!apiPath) return false;
+    for (const excludedPath of AuthInterceptor.excludedApis) {
+      if (apiPath.includes(excludedPath)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private async getCurrentUserId(): Promise<string | null> {
+    try {
+      return null;
+    } catch (e) {
+      logger.error('Failed to get current user ID:', e);
+      return null;
+    }
+  }
+}

package/src/data/network/interceptors/errorInterceptor.ts

@@ -0,0 +1,13 @@
+// Utilities / Helpers
+import { getErrorMessage } from '../apiExceptionHandler';
+
+export class ErrorInterceptor {
+  onError(err: any, handler: any) {
+    const unifiedMessage = getErrorMessage(err?.status, err?.type);
+    const newError = {
+      ...err,
+      error: unifiedMessage,
+    };
+    handler.reject(newError);
+  }
+}

package/src/data/network/interceptors/loggingInterceptor.ts

@@ -0,0 +1,16 @@
+// Utilities
+import { logger } from '../../../utils/logger';
+
+export class LoggingInterceptor {
+  onRequest(options: any) {
+    logger.info(`➡️ [REQUEST] ${options.method} ${options.url}`);
+    logger.info('Headers:', options.headers);
+    logger.info('Body:', options.body);
+    return options;
+  }
+
+  onResponse(response: any) {
+    logger.info(`✅ [RESPONSE] ${response.status}:`, response.data);
+    return response;
+  }
+}

package/src/data/network/interceptors/networkInterceptor.ts

@@ -0,0 +1,20 @@
+// Third-party libraries
+import NetInfo from '@react-native-community/netinfo';
+
+// Utilities / Helpers
+import { noInternetError } from '../apiExceptionHandler';
+
+export class NetworkInterceptor {
+  async onRequest(options: any): Promise<any> {
+    const state = await NetInfo.fetch();
+    if (!state.isConnected) {
+      throw {
+        requestOptions: options,
+        type: 'connectionError',
+        error: noInternetError(),
+        message: noInternetError(), // Unified message
+      };
+    }
+    return options;
+  }
+}

package/src/data/network/interceptors/retryInterceptor.ts

@@ -0,0 +1,24 @@
+export class RetryInterceptor {
+  private readonly retries: number;
+
+  constructor(retries: number = 1) {
+    this.retries = retries;
+  }
+
+  async onError(err: any, handler: any): Promise<any> {
+    const attempt = err.config?.retry_attempt ?? 0;
+
+    if (attempt < this.retries && this.shouldRetry(err)) {
+      // Retry logic implementation depends on the HTTP client (axios/fetch)
+      // This is a placeholder for the logic
+      return handler.next(err);
+    }
+    return handler.next(err);
+  }
+
+  private shouldRetry(err: any): boolean {
+    // Check for timeout or network errors
+    // Placeholder logic
+    return err.code === 'ECONNABORTED' || err.message?.includes('timeout');
+  }
+}

package/src/data/storage/asyncStorageManager.ts

@@ -0,0 +1,56 @@
+// Utilities / Helpers
+import { resolveNativeDependencies } from '../../utils/dependencyManager';
+
+function ensureStorage() {
+  const { AsyncStorage } = resolveNativeDependencies();
+  if (!AsyncStorage) throw new Error('ASYNC_STORAGE_NOT_AVAILABLE');
+  return AsyncStorage as any;
+}
+
+export async function storageGet(key: string): Promise<string | null> {
+  const storage = ensureStorage();
+  return storage.getItem(key);
+}
+
+export async function storageSet(key: string, value: string): Promise<void> {
+  const storage = ensureStorage();
+  await storage.setItem(key, value);
+}
+
+export async function storageRemove(key: string): Promise<void> {
+  const storage = ensureStorage();
+  if (typeof storage.removeItem === 'function') {
+    await storage.removeItem(key);
+    return;
+  }
+  throw new Error('ASYNC_STORAGE_REMOVE_NOT_SUPPORTED');
+}
+
+export async function storageGetJSON<T>(key: string): Promise<T | undefined> {
+  const raw = await storageGet(key);
+  if (!raw) return undefined;
+  try {
+    return JSON.parse(raw) as T;
+  } catch {
+    return undefined;
+  }
+}
+
+export async function storageSetJSON(
+  key: string,
+  value: unknown
+): Promise<void> {
+  await storageSet(key, JSON.stringify(value));
+}
+
+export function createStorageNamespace(ns: string) {
+  const prefix = ns ? `${ns}:` : '';
+  return {
+    get: (key: string) => storageGet(prefix + key),
+    set: (key: string, value: string) => storageSet(prefix + key, value),
+    remove: (key: string) => storageRemove(prefix + key),
+    getJSON: <T>(key: string) => storageGetJSON<T>(prefix + key),
+    setJSON: (key: string, value: unknown) =>
+      storageSetJSON(prefix + key, value),
+  };
+}

package/src/data/storage/deviceIdManager.ts

@@ -0,0 +1,46 @@
+// Storage Utilities
+import { storageGet, storageSet } from './asyncStorageManager';
+import { SDK_DEVICE_ID } from './storageKeys';
+
+// Utilities / Helpers
+import { resolveNativeDependencies } from '../../utils/dependencyManager';
+
+let cachedDeviceId: string | null = null;
+
+async function getFromStorage(): Promise<string | null> {
+  const key = SDK_DEVICE_ID;
+  try {
+    const existing = await storageGet(key);
+    return existing ?? null;
+  } catch {
+    return null;
+  }
+}
+
+async function saveToStorage(id: string): Promise<void> {
+  const key = SDK_DEVICE_ID;
+  try {
+    await storageSet(key, id);
+  } catch {}
+}
+
+export async function getDeviceId(): Promise<string> {
+  if (cachedDeviceId) return cachedDeviceId;
+  const stored = await getFromStorage();
+  if (stored) {
+    cachedDeviceId = stored;
+    return stored;
+  }
+  try {
+    const { DeviceInfo } = resolveNativeDependencies();
+    if (DeviceInfo?.getUniqueId) {
+      const uniqueId = await DeviceInfo.getUniqueId();
+      cachedDeviceId = uniqueId;
+      await saveToStorage(uniqueId);
+      return uniqueId;
+    }
+  } catch {}
+  throw new Error(
+    'DEVICE_ID_UNAVAILABLE: install react-native-device-info or provide a custom id'
+  );
+}

package/src/data/storage/keysManager.ts

@@ -0,0 +1,89 @@
+class KeysManager {
+  private apiKey: string | null = null;
+  private encryptionKey: string | null = null;
+  private pRefCode: string | null = null;
+  private authMode: string | null = null;
+
+  setApiKey(apiKey: string): void {
+    this.apiKey = apiKey;
+  }
+
+  getApiKey(): string | null {
+    return this.apiKey ?? null;
+  }
+
+  setEncryptionKey(encryptionKey: string): void {
+    this.encryptionKey = encryptionKey;
+  }
+
+  getEncryptionKey(): string | null {
+    return this.encryptionKey ?? null;
+  }
+
+  setPRefCode(pRefCode: string): void {
+    this.pRefCode = pRefCode;
+  }
+
+  getPRefCode(): string | null {
+    return this.pRefCode ?? null;
+  }
+
+  setAuthMode(authMode: string): void {
+    this.authMode = authMode;
+  }
+
+  getAuthMode(): string | null {
+    return this.authMode ?? null;
+  }
+}
+
+export const keysManager = new KeysManager();
+
+export const setApiKey = async (apiKey: string): Promise<void> => {
+  keysManager.setApiKey(apiKey);
+};
+
+export async function getApiKey(): Promise<string> {
+  return keysManager.getApiKey() ?? '-';
+}
+
+export const setEncryptionKey = async (
+  encryptionKey: string
+): Promise<void> => {
+  keysManager.setEncryptionKey(encryptionKey);
+};
+export async function getEncryptionKey(): Promise<string> {
+  return keysManager.getEncryptionKey() ?? '-';
+}
+
+export function getApiKeySync(): string | null {
+  return keysManager.getApiKey();
+}
+
+export function getEncryptionKeySync(): string | null {
+  return keysManager.getEncryptionKey();
+}
+
+export const setPRefCode = async (pRefCode: string): Promise<void> => {
+  keysManager.setPRefCode(pRefCode);
+};
+
+export async function getPRefCode(): Promise<string> {
+  return keysManager.getPRefCode() ?? '-';
+}
+
+export function getPRefCodeSync(): string | null {
+  return keysManager.getPRefCode();
+}
+
+export const setAuthMode = async (authMode: string): Promise<void> => {
+  keysManager.setAuthMode(authMode);
+};
+
+export async function getAuthMode(): Promise<string> {
+  return keysManager.getAuthMode() ?? '-';
+}
+
+export function getAuthModeSync(): string | null {
+  return keysManager.getAuthMode();
+}