@onairos/react-native 3.4.1 → 3.5.4

package/src/utils/retryHelper.ts

@@ -1,275 +0,0 @@
-/**
- * 🔄 Retry Helper Utility
- * 
- * Provides robust retry logic with exponential backoff for network operations.
- * Used throughout the Onairos SDK for handling transient failures gracefully.
- */
-
-export interface RetryOptions {
-  /** Maximum number of retry attempts */
-  maxRetries: number;
-  /** Base delay between retries in milliseconds */
-  baseDelay: number;
-  /** Maximum delay between retries in milliseconds */
-  maxDelay: number;
-  /** Whether to use exponential backoff */
-  exponentialBackoff: boolean;
-  /** Function to determine if an error should trigger a retry */
-  shouldRetry?: (error: any, attempt: number) => boolean;
-  /** Function called before each retry attempt */
-  onRetry?: (error: any, attempt: number, nextDelay: number) => void;
-  /** Enable logging of retry attempts */
-  enableLogging: boolean;
-}
-
-export interface RetryResult<T> {
-  success: boolean;
-  data?: T;
-  error?: Error;
-  attempts: number;
-  totalDuration: number;
-}
-
-/**
- * Default retry options for the Onairos SDK
- */
-export const DEFAULT_RETRY_OPTIONS: RetryOptions = {
-  maxRetries: 3,
-  baseDelay: 1000,
-  maxDelay: 5000,
-  exponentialBackoff: true,
-  enableLogging: false,
-  shouldRetry: (error: any, attempt: number) => {
-    // Don't retry client errors (4xx) except for 408 (timeout) and 429 (rate limit)
-    if (error.status >= 400 && error.status < 500 && error.status !== 408 && error.status !== 429) {
-      return false;
-    }
-    
-    // Retry network errors, timeouts, and server errors (5xx)
-    if (error.name === 'AbortError' || 
-        error.message.includes('Network request failed') ||
-        error.message.includes('fetch') ||
-        error.message.includes('ENOTFOUND') ||
-        error.message.includes('timeout') ||
-        (error.status >= 500)) {
-      return true;
-    }
-    
-    // Retry JSON parse errors (likely server issues)
-    if (error.message.includes('JSON Parse error') || error.message.includes('Unexpected character')) {
-      return true;
-    }
-    
-    return false;
-  }
-};
-
-/**
- * Execute a function with retry logic and exponential backoff
- * @param fn Function to execute (should return a Promise)
- * @param options Retry configuration options
- * @returns Promise with retry result
- */
-export async function withRetry<T>(
-  fn: () => Promise<T>,
-  options: Partial<RetryOptions> = {}
-): Promise<RetryResult<T>> {
-  const config = { ...DEFAULT_RETRY_OPTIONS, ...options };
-  const startTime = Date.now();
-  let lastError: Error | null = null;
-
-  for (let attempt = 1; attempt <= config.maxRetries + 1; attempt++) {
-    try {
-      if (config.enableLogging && attempt > 1) {
-        console.log(`🔄 Retry attempt ${attempt}/${config.maxRetries + 1}`);
-      }
-
-      const result = await fn();
-      
-      return {
-        success: true,
-        data: result,
-        attempts: attempt,
-        totalDuration: Date.now() - startTime
-      };
-
-    } catch (error: any) {
-      lastError = error;
-      
-      // Check if we should retry this error
-      const shouldRetryError = config.shouldRetry ? config.shouldRetry(error, attempt) : true;
-      
-      // If this is the last attempt or we shouldn't retry, throw the error
-      if (attempt > config.maxRetries || !shouldRetryError) {
-        if (config.enableLogging) {
-          console.error(`❌ All retry attempts exhausted or error not retryable: ${error.message}`);
-        }
-        break;
-      }
-
-      // Calculate delay for next attempt
-      let delay = config.baseDelay;
-      if (config.exponentialBackoff) {
-        delay = Math.min(config.baseDelay * Math.pow(2, attempt - 1), config.maxDelay);
-      }
-
-      // Add some jitter to prevent thundering herd
-      const jitter = Math.random() * 0.1 * delay;
-      delay = Math.floor(delay + jitter);
-
-      if (config.onRetry) {
-        config.onRetry(error, attempt, delay);
-      }
-
-      if (config.enableLogging) {
-        console.log(`⏳ Waiting ${delay}ms before retry (attempt ${attempt}/${config.maxRetries + 1})`);
-      }
-
-      // Wait before next attempt
-      await new Promise<void>(resolve => setTimeout(() => resolve(), delay));
-    }
-  }
-
-  return {
-    success: false,
-    error: lastError || new Error('Unknown error'),
-    attempts: config.maxRetries + 1,
-    totalDuration: Date.now() - startTime
-  };
-}
-
-/**
- * Retry configuration for API calls
- */
-export const API_RETRY_OPTIONS: Partial<RetryOptions> = {
-  maxRetries: 3,
-  baseDelay: 1000,
-  maxDelay: 5000,
-  exponentialBackoff: true,
-  shouldRetry: (error: any, attempt: number) => {
-    // Enhanced retry logic for API calls
-    
-    // Never retry authentication errors (401) or permission errors (403)
-    if (error.status === 401 || error.status === 403) {
-      return false;
-    }
-    
-    // Never retry bad request errors (400) or not found (404) unless it's a specific case
-    if (error.status === 400 || (error.status === 404 && !error.message.includes('validation endpoint'))) {
-      return false;
-    }
-    
-    // Retry rate limiting (429) with longer delays
-    if (error.status === 429) {
-      return attempt <= 2; // Limit retries for rate limiting
-    }
-    
-    // Retry server errors (5xx)
-    if (error.status >= 500) {
-      return true;
-    }
-    
-    // Retry timeout and network errors
-    if (error.name === 'AbortError' || 
-        error.message.includes('timeout') ||
-        error.message.includes('Network request failed') ||
-        error.message.includes('fetch') ||
-        error.message.includes('ENOTFOUND')) {
-      return true;
-    }
-    
-    // Retry JSON parse errors (server returning HTML instead of JSON)
-    if (error.message.includes('JSON Parse error') || 
-        error.message.includes('Unexpected character') ||
-        error.message.includes('HTML page instead of JSON')) {
-      return true;
-    }
-    
-    return false;
-  },
-  onRetry: (error: any, attempt: number, delay: number) => {
-    console.warn(`⚠️ API call failed (attempt ${attempt}), retrying in ${delay}ms: ${error.message}`);
-  }
-};
-
-/**
- * Specialized retry for network/connectivity issues
- */
-export const NETWORK_RETRY_OPTIONS: Partial<RetryOptions> = {
-  maxRetries: 2,
-  baseDelay: 2000,
-  maxDelay: 8000,
-  exponentialBackoff: true,
-  shouldRetry: (error: any, attempt: number) => {
-    // Only retry actual network/connectivity issues
-    return error.message.includes('Network request failed') ||
-           error.message.includes('ENOTFOUND') ||
-           error.message.includes('DNS') ||
-           error.name === 'AbortError';
-  }
-};
-
-/**
- * Create a retry wrapper for fetch requests
- * @param url Request URL
- * @param options Fetch options
- * @param retryOptions Retry configuration
- * @returns Promise with fetch response
- */
-export async function fetchWithRetry(
-  url: string, 
-  options: RequestInit = {}, 
-  retryOptions: Partial<RetryOptions> = API_RETRY_OPTIONS
-): Promise<Response> {
-  const result = await withRetry(
-    () => fetch(url, options),
-    retryOptions
-  );
-
-  if (!result.success) {
-    throw result.error;
-  }
-
-  return result.data!;
-}
-
-/**
- * Health check function with retry for testing connectivity
- * @param url URL to check
- * @param timeout Timeout in milliseconds
- * @returns Promise indicating if the service is reachable
- */
-export async function healthCheck(
-  url: string, 
-  timeout: number = 5000
-): Promise<{ reachable: boolean; status?: number; error?: string; duration: number }> {
-  const startTime = Date.now();
-  
-  try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-    
-    const response = await fetch(url, {
-      method: 'GET',
-      signal: controller.signal,
-      headers: {
-        'User-Agent': 'OnairosReactNative/HealthCheck'
-      }
-    });
-    
-    clearTimeout(timeoutId);
-    
-    return {
-      reachable: true,
-      status: response.status,
-      duration: Date.now() - startTime
-    };
-    
-  } catch (error: any) {
-    return {
-      reachable: false,
-      error: error.message,
-      duration: Date.now() - startTime
-    };
-  }
-} 

package/src/utils/secureStorage.ts

@@ -1,361 +0,0 @@
-import { Platform } from 'react-native';
-import { sha256 } from './crypto';
-import { STORAGE_KEYS } from '../constants';
-import AsyncStorage from '@react-native-async-storage/async-storage';
-
-// JWT token storage key
-const JWT_TOKEN_KEY = 'onairos_jwt_token';
-
-// Define OnairosCredentials interface locally to avoid circular dependencies
-export interface OnairosCredentials {
-  username: string;
-  accessToken?: string;
-  refreshToken?: string;
-  userPin?: string;
-  platforms?: {
-    instagram?: { token: string; username: string; userId?: string };
-    youtube?: { token: string; username: string; userId?: string };
-    pinterest?: { token: string; username: string; userId?: string };
-    reddit?: { token: string; username: string; userId?: string };
-  };
-  createdAt: number;
-}
-
-export interface StorageOptions {
-  service?: string;
-  accessControl?: any;
-  accessible?: any;
-}
-
-// Create a mock storage for environments without Keychain access (like Expo Go)
-const mockStorage: Record<string, { username: string; password: string }> = {};
-
-// Try to import Keychain, but provide fallbacks if not available
-let Keychain: any = null;
-try {
-  // This import might fail in Expo Go or environments without native modules
-  Keychain = require('react-native-keychain');
-} catch (error) {
-  console.warn('react-native-keychain module not available, using mock storage');
-  // Create minimal mock implementation
-  Keychain = {
-    ACCESS_CONTROL: { BIOMETRY_ANY_OR_DEVICE_PASSCODE: 'mock' },
-    ACCESSIBLE: { WHEN_UNLOCKED: 'mock' },
-    getGenericPassword: async () => null,
-    setGenericPassword: async () => true,
-    resetGenericPassword: async () => true,
-  };
-}
-
-// Check if Keychain is properly initialized and available
-const isKeychainAvailable = () => {
-  try {
-    return Keychain && typeof Keychain.getGenericPassword === 'function';
-  } catch (e) {
-    return false;
-  }
-};
-
-// Wrapper for getGenericPassword that falls back to mock storage
-const safeGetGenericPassword = async (options: any) => {
-  try {
-    if (isKeychainAvailable()) {
-      return await Keychain.getGenericPassword(options);
-    } else {
-      // Fall back to mock storage in memory
-      const key = options?.service || 'default';
-      return mockStorage[key] || null;
-    }
-  } catch (error) {
-    console.warn('Keychain access failed, using mock storage', error);
-    // Fall back to mock storage on error
-    const key = options?.service || 'default';
-    return mockStorage[key] || null;
-  }
-};
-
-// Wrapper for setGenericPassword that falls back to mock storage
-const safeSetGenericPassword = async (
-  username: string,
-  password: string,
-  options?: any
-) => {
-  try {
-    if (isKeychainAvailable()) {
-      return await Keychain.setGenericPassword(username, password, options);
-    } else {
-      // Fall back to mock storage in memory
-      const key = options?.service || 'default';
-      mockStorage[key] = { username, password };
-      return true;
-    }
-  } catch (error) {
-    console.warn('Keychain access failed, using mock storage', error);
-    // Fall back to mock storage on error
-    const key = options?.service || 'default';
-    mockStorage[key] = { username, password };
-    return true;
-  }
-};
-
-// Wrapper for resetGenericPassword that falls back to mock storage
-const safeResetGenericPassword = async (options?: any) => {
-  try {
-    if (isKeychainAvailable()) {
-      return await Keychain.resetGenericPassword(options);
-    } else {
-      // Fall back to mock storage in memory
-      const key = options?.service || 'default';
-      delete mockStorage[key];
-      return true;
-    }
-  } catch (error) {
-    console.warn('Keychain access failed, using mock storage', error);
-    // Fall back to mock storage on error
-    const key = options?.service || 'default';
-    delete mockStorage[key];
-    return true;
-  }
-};
-
-/**
- * Store credentials in memory (temporary solution)
- */
-export const storeCredentials = async (
-  credentials: Partial<OnairosCredentials>
-): Promise<boolean> => {
-  try {
-    const existingCredentials = await getCredentials();
-    const updatedCredentials: OnairosCredentials = {
-      ...existingCredentials,
-      ...credentials,
-      createdAt: existingCredentials?.createdAt || Date.now(),
-    } as OnairosCredentials;
-
-    const username = updatedCredentials.username;
-    if (!username) {
-      throw new Error('Username is required for storing credentials');
-    }
-
-    const options: any = {
-      service: STORAGE_KEYS.credentials,
-    };
-
-    // Only use secure storage options on real devices
-    if (Platform.OS !== 'web' && isKeychainAvailable()) {
-      options.accessControl = Keychain.ACCESS_CONTROL.BIOMETRY_ANY_OR_DEVICE_PASSCODE;
-      options.accessible = Keychain.ACCESSIBLE.WHEN_UNLOCKED;
-    }
-
-    await safeSetGenericPassword(
-      username,
-      JSON.stringify(updatedCredentials),
-      options
-    );
-    return true;
-  } catch (error) {
-    console.error('Error storing credentials:', error);
-    return false;
-  }
-};
-
-/**
- * Retrieve credentials from memory (temporary solution)
- */
-export const getCredentials = async (): Promise<OnairosCredentials | null> => {
-  try {
-    const credentials = await safeGetGenericPassword({
-      service: STORAGE_KEYS.credentials,
-    });
-    if (credentials) {
-      return JSON.parse(credentials.password);
-    }
-    return null;
-  } catch (error) {
-    console.error('Error getting credentials:', error);
-    return null;
-  }
-};
-
-/**
- * Check if the user has stored credentials
- */
-export const hasCredentials = async (): Promise<boolean> => {
-  try {
-    const credentials = await safeGetGenericPassword({
-      service: STORAGE_KEYS.credentials,
-    });
-    return !!credentials;
-  } catch (error) {
-    console.error('Error checking credentials:', error);
-    return false;
-  }
-};
-
-/**
- * Delete stored credentials
- */
-export const deleteCredentials = async (): Promise<boolean> => {
-  try {
-    await safeResetGenericPassword({
-      service: STORAGE_KEYS.credentials,
-    });
-    return true;
-  } catch (error) {
-    console.error('Error deleting credentials:', error);
-    return false;
-  }
-};
-
-/**
- * Update specific fields in the stored credentials
- */
-export const updateCredentials = async (
-  credentials: Partial<OnairosCredentials>
-): Promise<boolean> => {
-  return storeCredentials(credentials);
-};
-
-/**
- * Generate a device-specific unique username
- */
-export const generateDeviceUsername = (): string => {
-  const randomId = Math.random().toString(36).substring(2, 10);
-  return `dev_${randomId}`;
-};
-
-/**
- * Verify credentials (temporary mock implementation)
- */
-export const verifyCredentials = async (username: string): Promise<boolean> => {
-  try {
-    // For Expo Go or development, always return true
-    if (!isKeychainAvailable()) {
-      return true;
-    }
-    
-    // TODO: Implement actual verification with API
-    return true;
-  } catch (error) {
-    console.error('Error verifying credentials:', error);
-    return false;
-  }
-};
-
-/**
- * JWT Token Storage Functions
- * These functions handle JWT tokens from email verification
- * 
- * Note: Main JWT token management is handled in apiKeyService.ts
- * These are utility functions for backwards compatibility
- */
-
-/**
- * Retrieve JWT token
- * @returns JWT token or null if not found
- */
-export const getJWT = async (): Promise<string | null> => {
-  try {
-    const token = await AsyncStorage.getItem(JWT_TOKEN_KEY);
-    return token;
-  } catch (error) {
-    console.error('❌ Failed to retrieve JWT token:', error);
-    return null;
-  }
-};
-
-/**
- * Check if JWT token exists
- * @returns True if JWT token exists
- */
-export const hasJWT = async (): Promise<boolean> => {
-  try {
-    const token = await AsyncStorage.getItem(JWT_TOKEN_KEY);
-    return !!token;
-  } catch (error) {
-    console.error('❌ Failed to check JWT token:', error);
-    return false;
-  }
-};
-
-/**
- * Clear JWT token
- */
-export const clearJWT = async (): Promise<boolean> => {
-  try {
-    await AsyncStorage.removeItem(JWT_TOKEN_KEY);
-    console.log('🗑️ JWT token cleared');
-    return true;
-  } catch (error) {
-    console.error('❌ Failed to clear JWT token:', error);
-    return false;
-  }
-};
-
-/**
- * Simple base64 decoder for React Native
- */
-const base64Decode = (str: string): string => {
-  // Add padding if needed
-  while (str.length % 4) {
-    str += '=';
-  }
-  
-  // Simple base64 decoding
-  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-  let result = '';
-  
-  for (let i = 0; i < str.length; i += 4) {
-    const a = chars.indexOf(str.charAt(i));
-    const b = chars.indexOf(str.charAt(i + 1));
-    const c = chars.indexOf(str.charAt(i + 2));
-    const d = chars.indexOf(str.charAt(i + 3));
-    
-    const bitmap = (a << 18) | (b << 12) | (c << 6) | d;
-    
-    result += String.fromCharCode((bitmap >> 16) & 255);
-    if (c !== 64) result += String.fromCharCode((bitmap >> 8) & 255);
-    if (d !== 64) result += String.fromCharCode(bitmap & 255);
-  }
-  
-  return result;
-};
-
-/**
- * Get JWT token payload (decoded)
- * @returns Decoded JWT payload or null if invalid
- */
-export const getJWTPayload = async (): Promise<any | null> => {
-  try {
-    const token = await getJWT();
-    if (!token) return null;
-    
-    // Decode JWT payload (middle part of token)
-    const parts = token.split('.');
-    if (parts.length !== 3) return null;
-    
-    const decodedPayload = base64Decode(parts[1]);
-    const payload = JSON.parse(decodedPayload);
-    return payload;
-  } catch (error) {
-    console.error('❌ Failed to decode JWT payload:', error);
-    return null;
-  }
-};
-
-/**
- * Check if JWT token is expired
- * @returns True if token is expired or invalid
- */
-export const isJWTExpired = async (): Promise<boolean> => {
-  try {
-    const payload = await getJWTPayload();
-    if (!payload || !payload.exp) return true;
-    
-    const currentTime = Math.floor(Date.now() / 1000);
-    return payload.exp < currentTime;
-  } catch (error) {
-    console.error('❌ Failed to check JWT expiration:', error);
-    return true;
-  }
-};