@savers_app/react-native-sdk 1.1.0

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

@@ -0,0 +1,77 @@
+/* eslint-disable no-unreachable */
+
+// Utilities
+import { logger } from '../../../utils/logger';
+
+export class AuthInterceptor {
+  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;
+      }
+
+      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 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 {
+      // Placeholder for Keycloak integration
+      // const currentUser = KeycloakWebViewManager.instance.currentUser;
+      // return currentUser?.email;
+      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();
+}

package/src/data/storage/locationManager.ts

@@ -0,0 +1,39 @@
+class LocationManager {
+  private lat: number | null = null;
+  private lng: number | null = null;
+
+  setCoordinates(lat: number, lng: number): void {
+    this.lat = lat;
+    this.lng = lng;
+  }
+
+  getCoordinates(): { lat: number; lng: number } | null {
+    if (this.lat === null || this.lng === null) {
+      return null;
+    }
+    return { lat: this.lat, lng: this.lng };
+  }
+}
+
+export const locationManager = new LocationManager();
+
+export const setLocationCoordinates = async (
+  lat: number,
+  lng: number
+): Promise<void> => {
+  locationManager.setCoordinates(lat, lng);
+};
+
+export async function getLocationCoordinates(): Promise<{
+  lat: number;
+  lng: number;
+} | null> {
+  return locationManager.getCoordinates();
+}
+
+export function getLocationCoordinatesSync(): {
+  lat: number;
+  lng: number;
+} | null {
+  return locationManager.getCoordinates();
+}

package/src/data/storage/sessionManager.ts

@@ -0,0 +1,11 @@
+// Storage Utilities
+import { storageSet, storageGet } from './asyncStorageManager';
+import { SDK_SESSION_ID } from './storageKeys';
+
+export const setSessionId = async (sessionId: string) => {
+  await storageSet(SDK_SESSION_ID, sessionId);
+};
+
+export const getSessionId = async (): Promise<string | null> => {
+  return storageGet(SDK_SESSION_ID);
+};

package/src/data/storage/storageKeys.ts

@@ -0,0 +1,4 @@
+export const SAVERS_API_KEY = 'SAVERS_API_KEY';
+export const SAVERS_ENCRYPTION_KEY = 'SAVERS_ENCRYPTION_KEY';
+export const SDK_SESSION_ID = 'SDK_SESSION_ID';
+export const SDK_DEVICE_ID = 'SDK_DEVICE_ID';

package/src/data/storage/storageManager.ts

@@ -0,0 +1,83 @@
+// Storage Utilities
+import { storageGet, storageSet, storageRemove } from './asyncStorageManager';
+
+const cachePrefix = 'cache_';
+
+const userIdKey = 'userId';
+const isOnboardingSkipedKey = 'isOnboardingSkipedKey';
+const isAuthSkipedKey = 'isAuthSkipedKey';
+const authSkippedTimestampKey = 'authSkippedTimestamp';
+const userSelectedLocationKey = 'userSelectedLocation';
+const browsingModeKey = 'browsingMode';
+
+export const StorageKeys = {
+  userId: userIdKey,
+  isOnboardingSkiped: isOnboardingSkipedKey,
+  isAuthSkiped: isAuthSkipedKey,
+  authSkippedTimestamp: authSkippedTimestampKey,
+  userSelectedLocation: userSelectedLocationKey,
+  browsingMode: browsingModeKey,
+};
+
+export async function save(key: string, value: any): Promise<void> {
+  const fullKey = cachePrefix + key;
+  let dataToSave: string;
+  if (typeof value === 'string') {
+    dataToSave = value;
+  } else {
+    try {
+      dataToSave = JSON.stringify(value);
+    } catch {
+      dataToSave = String(value);
+    }
+  }
+  await storageSet(fullKey, dataToSave);
+}
+
+export async function get(key: string): Promise<any> {
+  const fullKey = cachePrefix + key;
+  const raw = await storageGet(fullKey);
+  if (raw === null) return null;
+  if (raw.startsWith('{') || raw.startsWith('[')) {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+  return raw;
+}
+
+export async function clear(key: string): Promise<void> {
+  const fullKey = cachePrefix + key;
+  await storageRemove(fullKey);
+}
+
+export async function clearAll(): Promise<void> {
+  // Not supported by asyncStorageManager wrapper yet, would need extension.
+  // For now, we'll leave it as a TODO or implement using low level if exposed,
+  // but better to remove direct dependency on @react-native-async-storage/async-storage
+  // to support the unified approach.
+  // However, asyncStorageManager hides the implementation.
+  // Let's rely on the fact that clearAll was mainly for cache.
+  console.warn('clearAll not fully supported in unified storage yet');
+}
+
+export async function saveAuthSkippedTime(): Promise<void> {
+  const timestamp = new Date().toISOString();
+  await save(authSkippedTimestampKey, timestamp);
+}
+
+export async function getAuthSkippedTime(): Promise<Date | null> {
+  const data = await get(authSkippedTimestampKey);
+  if (typeof data === 'string') {
+    try {
+      return new Date(data);
+    } catch {}
+  }
+  return null;
+}
+
+export async function clearAuthSkippedTime(): Promise<void> {
+  await clear(authSkippedTimestampKey);
+}

package/src/index.tsx

@@ -0,0 +1,17 @@
+export * from './services/navigation/openMap';
+export * from './services/navigation/goBackNavigation';
+export * from './services/permissions/permissionManager';
+export * from './utils/platformManager';
+export * from './utils/errors';
+export * from './utils/logger';
+export * from './utils/validator';
+export * from './services/webview/messageHandler';
+export * from './data/storage/deviceIdManager';
+export * from './services/navigation/dialPad';
+export * from './services/navigation/openBrowser';
+export * from './data/storage/sessionManager';
+export * from './services/url/urlGenerator';
+export * from './data/network/apiService';
+export * from './core/runtime';
+export * from './data/storage/keysManager';
+export * from './data/storage/locationManager';

package/src/services/device/location.ts

@@ -0,0 +1,51 @@
+// Platform Utilities
+import { isAndroid } from '../../utils/platformManager';
+import { resolveNativeDependencies } from '../../utils/dependencyManager';
+
+// Permissions
+import { ensureLocationPermission } from '../permissions/permissionManager';
+
+export type DeviceLocation = { lat: number; lng: number };
+
+let locationProvider: (() => Promise<DeviceLocation | undefined>) | undefined;
+
+export function setLocationProvider(
+  provider: () => Promise<DeviceLocation | undefined>
+): void {
+  locationProvider = provider;
+}
+
+export const fetchLocation = async (): Promise<DeviceLocation> => {
+  const { Geolocation } = resolveNativeDependencies();
+  if (!Geolocation) {
+    throw new Error(
+      'GEOLOCATION_NOT_LINKED: install and link @react-native-community/geolocation'
+    );
+  }
+  return new Promise((resolve, reject) => {
+    Geolocation.getCurrentPosition(
+      (pos: { coords: { latitude: number; longitude: number } }) =>
+        resolve({ lat: pos.coords.latitude, lng: pos.coords.longitude }),
+      (err: unknown) => reject(err),
+      { enableHighAccuracy: true, timeout: 10000 }
+    );
+  });
+};
+
+export async function getDeviceLocation(): Promise<DeviceLocation | undefined> {
+  if (locationProvider) {
+    return locationProvider();
+  }
+  if (isAndroid()) {
+    const granted = await ensureLocationPermission();
+    if (!granted) {
+      throw new Error('LOCATION_PERMISSION_DENIED');
+    }
+  }
+  try {
+    const loc = await fetchLocation();
+    return loc;
+  } catch {
+    throw new Error('LOCATION_UNAVAILABLE');
+  }
+}

package/src/services/navigation/dialPad.ts

@@ -0,0 +1,39 @@
+// React Native Core
+import { Linking, Platform } from 'react-native';
+
+// Utilities / Validators
+import { isValidPhoneNumber } from '../../utils/validator';
+
+export const callPhone = async (phone: string): Promise<void> => {
+  if (!isValidPhoneNumber(phone)) {
+    throw new Error('INVALID_PHONE_NUMBER');
+  }
+
+  const url =
+    Platform.OS === 'ios'
+      ? `telprompt:${phone}` // iOS preferred
+      : `tel:${phone}`;
+
+  try {
+    await Linking.openURL(url);
+  } catch {
+    throw new Error('CALL_NOT_SUPPORTED');
+  }
+};
+
+export async function openDialPad(phone?: string): Promise<void> {
+  const url =
+    Platform.OS === 'ios'
+      ? phone
+        ? `telprompt:${phone}`
+        : 'tel:' // open empty dial pad
+      : phone
+      ? `tel:${phone}`
+      : 'tel:';
+
+  try {
+    await Linking.openURL(url);
+  } catch {
+    throw new Error('DIAL_PAD_NOT_SUPPORTED');
+  }
+}

package/src/services/navigation/goBackNavigation.ts

@@ -0,0 +1,22 @@
+// React Native Core
+import { BackHandler, Platform } from 'react-native';
+
+// Navigation / Routing
+import { createNavigationContainerRef } from '@react-navigation/native';
+
+export const navigationRef = createNavigationContainerRef();
+
+export function closeCurrentScreen(): boolean {
+  if (navigationRef.isReady() && navigationRef.canGoBack()) {
+    navigationRef.goBack();
+    return true;
+  }
+  return false;
+}
+
+export function closeCurrentScreenSafe(): void {
+  const closed = closeCurrentScreen();
+  if (!closed && Platform.OS === 'android') {
+    BackHandler.exitApp();
+  }
+}

package/src/services/navigation/openBrowser.ts

@@ -0,0 +1,6 @@
+// React Native Core
+import { Linking } from 'react-native';
+
+export async function openBrowser(url: string): Promise<void> {
+  await Linking.openURL(url);
+}

package/src/services/navigation/openMap.ts

@@ -0,0 +1,39 @@
+// React Native Core
+import { Linking } from 'react-native';
+
+// Utilities / Helpers
+import { isMapAppAvailable, isValidCoordinates } from '../../utils/validator';
+
+// Platform / Environment helpers
+import { isIOS } from '../../utils/platformManager';
+
+export async function openMap(
+  lat: number,
+  lng: number,
+  label?: string
+): Promise<void> {
+  if (!isValidCoordinates(lat, lng)) {
+    throw new Error('INVALID_COORDINATES');
+  }
+
+  const iosUrl = `maps:0,0?q=${encodeURIComponent(label ?? '')}@${lat},${lng}`;
+  const androidUrl = `geo:0,0?q=${lat},${lng}${
+    label ? `(${encodeURIComponent(label)})` : ''
+  }`;
+  const deepLink = isIOS() ? iosUrl : androidUrl;
+
+  const available = await isMapAppAvailable();
+  if (available) {
+    await Linking.openURL(deepLink);
+    return;
+  }
+
+  const browserUrl = isIOS()
+    ? `https://maps.apple.com/?q=${encodeURIComponent(
+        label ?? ''
+      )}&ll=${lat},${lng}`
+    : `https://www.google.com/maps/search/?api=1&query=${lat},${lng}${
+        label ? `&query_place_id=${encodeURIComponent(label)}` : ''
+      }`;
+  await Linking.openURL(browserUrl);
+}