@savers_app/react-native-sdk 1.1.0

package/src/core/runtime.ts

@@ -0,0 +1,80 @@
+// Utilities
+import { logger } from '../utils/logger';
+import { SDKRequirements } from '../utils/dependencyManager';
+
+// Data / Storage
+import {
+  setApiKey,
+  setEncryptionKey,
+  setPRefCode,
+  setAuthMode,
+} from '../data/storage/keysManager';
+import { getDeviceId } from '../data/storage/deviceIdManager';
+
+// Services
+// import { getDeviceLocation } from '../services/device/location';
+
+export function initializeSDK(providedKeys: {
+  apiKey: string;
+  encryptionKey: string;
+  pRefCode: string;
+  authMode: string;
+}) {
+  const keys = providedKeys;
+  const missing: string[] = [];
+  if (!keys.apiKey) missing.push('apiKey');
+  if (!keys.encryptionKey) missing.push('encryptionKey');
+  if (!keys.pRefCode) missing.push('pRefCode');
+  if (!keys.authMode) missing.push('authMode');
+
+  if (missing.length) {
+    const msg = `[SDK] Missing required keys: ${missing.join(', ')}`;
+    logger.warn(msg);
+    throw new Error(msg);
+  }
+  setApiKey(keys.apiKey);
+  setEncryptionKey(keys.encryptionKey);
+  setPRefCode(keys.pRefCode);
+  setAuthMode(keys.authMode);
+
+  getDeviceId()
+    .then((id) => {
+      logger.info('[SDK] Device ID availability', { deviceId: Boolean(id) });
+    })
+    .catch(() => {
+      logger.warn('[SDK] Device ID unavailable');
+    });
+
+  // getDeviceLocation()
+  //   .then((loc) => {
+  //     logger.info('[SDK] Device location availability', {
+  //       location: Boolean(loc),
+  //     });
+  //   })
+  //   .catch(() => {
+  //     logger.warn('[SDK] Device location unavailable');
+  //   });
+
+  const { asyncStorage, geolocation, deviceInfo } = SDKRequirements;
+  if (asyncStorage && geolocation && deviceInfo) return;
+  if (!asyncStorage) {
+    logger.warn(
+      '[SDK] Missing AsyncStorage. Install @react-native-async-storage/async-storage for session/device features.'
+    );
+  }
+  if (!geolocation) {
+    logger.warn(
+      '[SDK] Missing Geolocation. Install @react-native-community/geolocation for location features.'
+    );
+  }
+
+  if (!deviceInfo) {
+    logger.warn(
+      '[SDK] Missing DeviceInfo. Install react-native-device-info for device identification.'
+    );
+  }
+}
+
+export const SaversAppSDK = {
+  initialized: initializeSDK,
+};

package/src/data/models/apiResponse.ts

@@ -0,0 +1,28 @@
+export type ApiResponse<T> = {
+  data?: T | null;
+  status?: boolean;
+  message?: string;
+  fromCache: boolean;
+};
+
+export function apiError(message?: string): ApiResponse<null> {
+  return {
+    data: null,
+    status: false,
+    message: message ?? '',
+    fromCache: false,
+  };
+}
+
+export function apiSuccess<T>(
+  data: T,
+  message?: string,
+  fromCache?: boolean
+): ApiResponse<T> {
+  return {
+    data,
+    status: true,
+    message: message ?? '',
+    fromCache: !!fromCache,
+  };
+}

package/src/data/models/onboardingModel.ts

@@ -0,0 +1,99 @@
+export type OnBoardingImage = {
+  id?: number | null;
+  url?: string | null;
+};
+
+export function onBoardingImageFromJson(
+  json: Record<string, any>
+): OnBoardingImage {
+  return {
+    id: typeof json['id'] === 'number' ? json['id'] : null,
+    url: typeof json['url'] === 'string' ? json['url'] : null,
+  };
+}
+
+export function onBoardingImageListFromJson(list: any[]): OnBoardingImage[] {
+  const out: OnBoardingImage[] = [];
+  for (const item of list) {
+    if (item && typeof item === 'object' && !Array.isArray(item)) {
+      try {
+        out.push(onBoardingImageFromJson(item as Record<string, any>));
+      } catch {}
+    }
+  }
+  return out;
+}
+
+export type OnBoardingThemeData = {
+  total?: number | null;
+  images?: OnBoardingImage[] | null;
+};
+
+export function onBoardingThemeFromJson(json: any): OnBoardingThemeData {
+  const map = { ...(json as Record<string, any>) };
+  const imagesRaw = Array.isArray(map['images'])
+    ? (map['images'] as any[])
+    : [];
+  const images = onBoardingImageListFromJson(imagesRaw);
+  const total =
+    typeof map['total'] === 'number'
+      ? map['total']
+      : typeof map['total'] === 'string'
+      ? Number(map['total'])
+      : null;
+  return {
+    total: total ?? null,
+    images: images.length > 0 ? images : null,
+  };
+}
+
+export type OnBoardingData = {
+  day?: OnBoardingThemeData | null;
+  night?: OnBoardingThemeData | null;
+};
+
+export function onBoardingDataFromJson(json: any): OnBoardingData {
+  const map = { ...(json as Record<string, any>) };
+  const hasDayNight = 'day' in map || 'night' in map;
+  if (hasDayNight) {
+    const day = map['day'] ? onBoardingThemeFromJson(map['day']) : null;
+    const night = map['night'] ? onBoardingThemeFromJson(map['night']) : null;
+    return { day, night };
+  }
+  const legacyImages = Array.isArray(map['images'])
+    ? onBoardingImageListFromJson(map['images'] as any[])
+    : [];
+  const legacyTotal =
+    typeof map['total'] === 'number'
+      ? map['total']
+      : typeof map['total'] === 'string'
+      ? Number(map['total'])
+      : null;
+  const legacyTheme: OnBoardingThemeData = {
+    total: legacyTotal ?? null,
+    images: legacyImages.length > 0 ? legacyImages : null,
+  };
+  return { day: legacyTheme, night: null };
+}
+
+export const images = (d?: OnBoardingData | null): OnBoardingImage[] | null =>
+  d?.day?.images ?? d?.night?.images ?? null;
+export const total = (d?: OnBoardingData | null): number | null =>
+  d?.day?.total ?? d?.night?.total ?? null;
+export const hasTotal = (d?: OnBoardingData | null): boolean =>
+  total(d) !== null;
+export const hasImages = (d?: OnBoardingData | null): boolean =>
+  !!images(d) && (images(d)?.length ?? 0) > 0;
+export const imageCount = (d?: OnBoardingData | null): number =>
+  images(d)?.length ?? 0;
+export const isValid = (d?: OnBoardingData | null): boolean =>
+  !!(d?.day?.total && d?.day?.images) ||
+  !!(d?.night?.total && d?.night?.images);
+export const getImage = (
+  d: OnBoardingData | null | undefined,
+  index: number
+): OnBoardingImage | null => {
+  const list = images(d);
+  if (list && index >= 0 && index < list.length) return list[index] ?? null;
+  return null;
+};

package/src/data/network/apiClient.ts

@@ -0,0 +1,148 @@
+/* eslint-disable prettier/prettier */
+
+// Utilities / Helpers
+import { logger } from '../../utils/logger';
+
+// Services / API clients
+import { AuthInterceptor } from './interceptors/authInterceptor';
+import { RetryInterceptor } from './interceptors/retryInterceptor';
+import { ErrorInterceptor } from './interceptors/errorInterceptor';
+import { NetworkInterceptor } from './interceptors/networkInterceptor';
+import { LoggingInterceptor } from './interceptors/loggingInterceptor';
+
+export enum Environment {
+  production = 'production',
+  staging = 'staging',
+}
+
+export class ApiClient {
+  private static readonly baseUrls: Record<Environment, string> = {
+    [Environment.production]: 'https://....',
+    [Environment.staging]: 'https://....',
+  };
+
+  private baseUrl: string;
+  private interceptors: any[] = [];
+
+  constructor(environment: Environment = Environment.production) {
+    this.baseUrl = ApiClient.baseUrls[environment];
+
+    this.interceptors = [
+      new LoggingInterceptor(),
+      new NetworkInterceptor(),
+      new AuthInterceptor(),
+      new RetryInterceptor(2),
+      new ErrorInterceptor(),
+    ];
+  }
+
+  async get(endpoint: string, params?: Record<string, any>): Promise<any> {
+    return this.request('GET', endpoint, undefined, params);
+  }
+
+  async post(
+    endpoint: string,
+    data?: any,
+    params?: Record<string, any>
+  ): Promise<any> {
+    return this.request('POST', endpoint, data, params);
+  }
+
+  async put(
+    endpoint: string,
+    data?: any,
+    params?: Record<string, any>
+  ): Promise<any> {
+    return this.request('PUT', endpoint, data, params);
+  }
+
+  async delete(
+    endpoint: string,
+    data?: any,
+    params?: Record<string, any>
+  ): Promise<any> {
+    return this.request('DELETE', endpoint, data, params);
+  }
+
+  private async request(
+    method: string,
+    endpoint: string,
+    data?: any,
+    params?: Record<string, any>
+  ): Promise<any> {
+    const url = this.buildUrl(endpoint, params);
+    let options: any = {
+      method,
+      url,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: data,
+      params, // kept for interceptors
+    };
+
+    // Apply request interceptors
+    for (const interceptor of this.interceptors) {
+      if (interceptor.onRequest) {
+        options = await interceptor.onRequest(options);
+        if (!options) throw new Error('Interceptor blocked request');
+      }
+    }
+
+    try {
+      const response = await fetch(options.url, {
+        method: options.method,
+        headers: options.headers,
+        body: options.body ? JSON.stringify(options.body) : undefined,
+      });
+
+      let responseData: any = null;
+      try {
+        responseData = await response.json();
+      } catch {
+        // ignore JSON parse error
+      }
+
+      // Apply response interceptors
+      let responseObj = {
+        data: responseData,
+        status: response.status,
+        statusText: response.statusText,
+      };
+
+      for (const interceptor of this.interceptors) {
+        if (interceptor.onResponse) {
+          responseObj = await interceptor.onResponse(responseObj);
+        }
+      }
+
+      return responseObj;
+    } catch (error) {
+      // Apply error interceptors
+      logger.error('API Request failed', error);
+      const handledError = error;
+      for (const interceptor of this.interceptors) {
+        if (interceptor.onError) {
+          // This is complex to mock fully without a real handler
+          // interceptor.onError(handledError, handler);
+        }
+      }
+      throw handledError;
+    }
+  }
+
+  private buildUrl(endpoint: string, params?: Record<string, any>): string {
+    let url = `${this.baseUrl}${endpoint}`;
+    if (params) {
+      const queryString = Object.keys(params)
+        .map(
+          (key) => `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`
+        )
+        .join('&');
+      if (queryString) {
+        url += `?${queryString}`;
+      }
+    }
+    return url;
+  }
+}

package/src/data/network/apiEndpoints.ts

@@ -0,0 +1,3 @@
+export const ApiEndpoints = {
+  onboarding: '/on-boarding/listings',
+} as const;

package/src/data/network/apiExceptionHandler.ts

@@ -0,0 +1,16 @@
+export function getErrorMessage(status?: number, type?: string): string {
+  if (type === 'timeout') return 'Connection timeout. Please try again.';
+  if (type === 'sendtimeout') return 'Send timeout. Please try again.';
+  if (type === 'receivetimeout') return 'Receive timeout. Please try again.';
+  if (typeof status === 'number') {
+    if (status >= 400 && status < 500)
+      return `Request error [${status}]. Please check your input.`;
+    if (status >= 500)
+      return `Server error [${status}]. Please try again later.`;
+  }
+  return 'Something went wrong. Please try again.';
+}
+
+export function noInternetError(): string {
+  return 'No internet connection. Please check your network.';
+}

package/src/data/network/apiRepository.ts

@@ -0,0 +1,106 @@
+// 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;
+    }
+  ): AsyncGenerator<ApiResponse<T | null>, void, unknown> {
+    const cacheStrategy = opts?.cacheStrategy ?? CacheStrategy.normal;
+    const cacheKey =
+      (opts?.storageKeyPrefix ?? '') +
+      endpoint +
+      JSON.stringify(opts?.params ?? {});
+
+    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
+        );
+        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
+      );
+      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
+    );
+    yield res;
+  }
+
+  private async fetchFromNetwork<T>(
+    endpoint: string,
+    params?: Record<string, any>,
+    cacheKey?: string
+  ): Promise<ApiResponse<T | null>> {
+    try {
+      const 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,72 @@
+// Utilities
+import { logger } from '../../utils/logger';
+
+// Types / Models
+import type { ApiResponse } from '../models/apiResponse';
+import {
+  type OnBoardingData,
+  onBoardingDataFromJson,
+} from '../models/onboardingModel';
+
+// 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,
+        };
+      }
+    }
+  }
+
+  /**
+   * 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;
+}