@onairos/react-native 3.4.0 → 3.5.4

package/src/utils/encryption.ts

@@ -1,69 +0,0 @@
-import { onairosApi } from '../api';
-import RSA from 'react-native-rsa-native';
-import { ApiResponse } from '../types';
-
-/**
- * Encrypt a model key using RSA with a public key
- * @param publicKey The public key to encrypt with
- * @param modelKey The model key to encrypt
- * @returns The encrypted model key
- */
-export const encryptModelKey = (publicKey: string, modelKey: string): string => {
-  try {
-    console.log('Encrypting model key');
-    
-    if (!publicKey || !modelKey) {
-      throw new Error('Public key or model key is missing');
-    }
-    
-    // In a production environment, this would use RSA encryption
-    // For now, we'll use a mock implementation
-    // return RSA.encrypt(modelKey, publicKey);
-    
-    // Return a fake encrypted value
-    return `encrypted_${modelKey}_${Date.now()}`;
-  } catch (error) {
-    console.error('Error encrypting model key:', error);
-    throw error;
-  }
-};
-
-/**
- * Get the server's public key
- * @returns The server's public key
- */
-export const getServerPublicKey = async (): Promise<string> => {
-  try {
-    // Use the API without generics to prevent TypeScript errors
-    const response = await onairosApi.get('public/getPublicKey');
-    
-    // Check for the public key in the response data
-    if (response?.data?.data?.publicKey) {
-      return response.data.data.publicKey;
-    } else if (response?.data?.publicKey) {
-      return response.data.publicKey;
-    } else {
-      throw new Error('No public key found in response');
-    }
-  } catch (error) {
-    console.error('Error getting server public key:', error);
-    // For testing, return a mock public key
-    return 'mock_public_key_for_testing';
-  }
-};
-
-/**
- * Hash a string using SHA-256
- * @param input The string to hash
- * @returns The hashed string
- */
-export const hashString = async (input: string): Promise<string> => {
-  try {
-    // In a production environment, this would use a proper hashing function
-    // For now, we'll return a mock hash
-    return `hash_${input.replace(/\s+/g, '_')}_${Date.now()}`;
-  } catch (error) {
-    console.error('Error hashing string:', error);
-    return `fallback_hash_${Date.now()}`;
-  }
-}; 

package/src/utils/onairosApi.ts

@@ -1,391 +0,0 @@
-import { Platform } from 'react-native';
-import NetInfo from '@react-native-community/netinfo';
-import { OnairosCredentials } from './secureStorage';
-import { logDebug } from './debugHelper';
-import { getJWT, makeUserRequest, makeDeveloperRequest, isUserAuthenticated, extractUsernameFromJWT } from '../services/apiKeyService';
-
-// API response types
-export interface ApiResponse<T = any> {
-  success: boolean;
-  data?: T;
-  error?: {
-    code: string;
-    message: string;
-    details?: any;
-  };
-}
-
-// Error types
-export type ApiErrorType = 
-  | 'network_error'
-  | 'timeout_error'
-  | 'auth_error' 
-  | 'server_error' 
-  | 'validation_error' 
-  | 'unknown_error';
-
-// API error structure
-export class ApiError extends Error {
-  type: ApiErrorType;
-  code?: string;
-  details?: any;
-  
-  constructor(message: string, type: ApiErrorType, code?: string, details?: any) {
-    super(message);
-    this.type = type;
-    this.code = code;
-    this.details = details;
-    this.name = 'ApiError';
-  }
-}
-
-/**
- * Check if the device has an active network connection
- */
-const checkNetworkConnection = async (): Promise<boolean> => {
-  const networkState = await NetInfo.fetch();
-  return networkState.isConnected === true;
-};
-
-/**
- * Make user-authenticated API request using JWT token
- */
-const makeUserApiRequest = async <T>(
-  endpoint: string,
-  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH',
-  options: {
-    data?: any;
-    headers?: Record<string, string>;
-    debug?: boolean;
-  } = {}
-): Promise<ApiResponse<T>> => {
-  const { data, headers = {}, debug = false } = options;
-  
-  try {
-    // Check for network connectivity
-    const isConnected = await checkNetworkConnection();
-    if (!isConnected) {
-      throw new ApiError(
-        'No network connection available',
-        'network_error'
-      );
-    }
-    
-    // Check if user is authenticated
-    if (!isUserAuthenticated()) {
-      throw new ApiError(
-        'User not authenticated. Please verify email first.',
-        'auth_error'
-      );
-    }
-    
-    // Log request information if debug mode is enabled
-    if (debug) {
-      logDebug('User API Request', {
-        endpoint,
-        method,
-        headers: { ...headers, Authorization: '[REDACTED]' },
-        data: data || null,
-      });
-    }
-    
-    // Make authenticated request using JWT token
-    const response = await makeUserRequest(endpoint, {
-      method,
-      headers,
-      ...(data ? { body: JSON.stringify(data) } : {}),
-    });
-    
-    // Parse response as JSON
-    const responseData = await response.json();
-    
-    // Log response if debug mode is enabled
-    if (debug) {
-      logDebug('User API Response', {
-        status: response.status,
-        data: responseData,
-      });
-    }
-    
-    // Handle API error responses
-    if (!response.ok) {
-      const errorType: ApiErrorType = 
-        response.status === 401 || response.status === 403 ? 'auth_error' :
-        response.status === 400 ? 'validation_error' :
-        response.status >= 500 ? 'server_error' : 'unknown_error';
-      
-      throw new ApiError(
-        responseData.error?.message || 'API request failed',
-        errorType,
-        responseData.error?.code,
-        responseData.error?.details
-      );
-    }
-    
-    return responseData as ApiResponse<T>;
-  } catch (error) {
-    // Handle specific error types
-    if (error instanceof ApiError) {
-      throw error;
-    }
-    
-    if (error.name === 'AbortError') {
-      throw new ApiError('Request timed out', 'timeout_error');
-    }
-    
-    // Log error if debug mode is enabled
-    if (debug) {
-      logDebug('User API Error', {
-        endpoint,
-        method,
-        error: error.message || 'Unknown error',
-      });
-    }
-    
-    // Return a generic error for all other cases
-    throw new ApiError(
-      error.message || 'An unexpected error occurred',
-      'unknown_error'
-    );
-  }
-};
-
-/**
- * Make developer-authenticated API request using API key
- */
-const makeDeveloperApiRequest = async <T>(
-  endpoint: string,
-  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH',
-  options: {
-    data?: any;
-    headers?: Record<string, string>;
-    debug?: boolean;
-  } = {}
-): Promise<ApiResponse<T>> => {
-  const { data, headers = {}, debug = false } = options;
-  
-  try {
-    // Check for network connectivity
-    const isConnected = await checkNetworkConnection();
-    if (!isConnected) {
-      throw new ApiError(
-        'No network connection available',
-        'network_error'
-      );
-    }
-    
-    // Log request information if debug mode is enabled
-    if (debug) {
-      logDebug('Developer API Request', {
-        endpoint,
-        method,
-        headers: { ...headers, Authorization: '[REDACTED]' },
-        data: data || null,
-      });
-    }
-    
-    // Make authenticated request using developer API key
-    const response = await makeDeveloperRequest(endpoint, {
-      method,
-      headers,
-      ...(data ? { body: JSON.stringify(data) } : {}),
-    });
-    
-    // Parse response as JSON
-    const responseData = await response.json();
-    
-    // Log response if debug mode is enabled
-    if (debug) {
-      logDebug('Developer API Response', {
-        status: response.status,
-        data: responseData,
-      });
-    }
-    
-    // Handle API error responses
-    if (!response.ok) {
-      const errorType: ApiErrorType = 
-        response.status === 401 || response.status === 403 ? 'auth_error' :
-        response.status === 400 ? 'validation_error' :
-        response.status >= 500 ? 'server_error' : 'unknown_error';
-      
-      throw new ApiError(
-        responseData.error?.message || 'API request failed',
-        errorType,
-        responseData.error?.code,
-        responseData.error?.details
-      );
-    }
-    
-    return responseData as ApiResponse<T>;
-  } catch (error) {
-    // Handle specific error types
-    if (error instanceof ApiError) {
-      throw error;
-    }
-    
-    if (error.name === 'AbortError') {
-      throw new ApiError('Request timed out', 'timeout_error');
-    }
-    
-    // Log error if debug mode is enabled
-    if (debug) {
-      logDebug('Developer API Error', {
-        endpoint,
-        method,
-        error: error.message || 'Unknown error',
-      });
-    }
-    
-    // Return a generic error for all other cases
-    throw new ApiError(
-      error.message || 'An unexpected error occurred',
-      'unknown_error'
-    );
-  }
-};
-
-/**
- * Validate user credentials with the API (uses JWT)
- */
-export const validateCredentials = async (
-  username: string,
-  options = { debug: false }
-): Promise<{ isValid: boolean; message?: string }> => {
-  try {
-    const response = await makeUserApiRequest<{ isValid: boolean }>('auth/validate', 'POST', {
-      data: { username },
-      debug: options.debug,
-    });
-    
-    return {
-      isValid: response.success && response.data?.isValid === true,
-      message: response.error?.message,
-    };
-  } catch (error) {
-    return {
-      isValid: false,
-      message: error.message,
-    };
-  }
-};
-
-/**
- * Create a new user account (uses developer API key)
- */
-export const createAccount = async (
-  credentials: Partial<OnairosCredentials>,
-  options = { debug: false }
-): Promise<ApiResponse<{ accessToken: string; userId: string }>> => {
-  return makeDeveloperApiRequest('auth/register', 'POST', {
-    data: {
-      username: credentials.username,
-      platforms: credentials.platforms,
-    },
-    debug: options.debug,
-  });
-};
-
-/**
- * Authenticate with the API using credentials (uses JWT)
- */
-export const authenticate = async (
-  credentials: Partial<OnairosCredentials>,
-  options = { debug: false }
-): Promise<ApiResponse<{ accessToken: string; refreshToken: string }>> => {
-  return makeUserApiRequest('auth/login', 'POST', {
-    data: {
-      username: credentials.username,
-      pin: credentials.userPin,
-    },
-    debug: options.debug,
-  });
-};
-
-/**
- * Refresh authentication token (uses JWT)
- */
-export const refreshToken = async (
-  refreshToken: string,
-  options = { debug: false }
-): Promise<ApiResponse<{ accessToken: string; refreshToken: string }>> => {
-  return makeUserApiRequest('auth/refresh', 'POST', {
-    data: { refreshToken },
-    debug: options.debug,
-  });
-};
-
-/**
- * Get user's connected platform data (uses JWT)
- */
-export const getPlatformData = async (
-  platform: string,
-  options = { debug: false }
-): Promise<ApiResponse<any>> => {
-  return makeUserApiRequest(`platforms/${platform}/data`, 'GET', {
-    debug: options.debug,
-  });
-};
-
-/**
- * Get user profile information (uses JWT)
- */
-export const getUserProfile = async (
-  options = { debug: false }
-): Promise<ApiResponse<any>> => {
-  return makeUserApiRequest('user/profile', 'GET', {
-    debug: options.debug,
-  });
-};
-
-/**
- * Update user platform connections (uses JWT)
- */
-export const updatePlatformConnections = async (
-  platforms: Record<string, any>,
-  options = { debug: false }
-): Promise<ApiResponse<any>> => {
-  return makeUserApiRequest('user/platforms', 'PUT', {
-    data: { platforms },
-    debug: options.debug,
-  });
-};
-
-/**
- * Store user PIN (uses JWT and extracts username from JWT)
- */
-export const storePIN = async (
-  pin: string,
-  options: { debug?: boolean; username?: string } = {}
-): Promise<ApiResponse<any>> => {
-  const { debug = false, username } = options;
-  
-  // Extract username from JWT if not provided
-  const userToStore = username || extractUsernameFromJWT();
-  
-  if (!userToStore) {
-    throw new ApiError(
-      'No username available - either provide username or ensure JWT token is valid',
-      'auth_error'
-    );
-  }
-  
-  return makeUserApiRequest('store-pin/mobile', 'POST', {
-    data: { username: userToStore, pin },
-    debug,
-  });
-};
-
-/**
- * Get current JWT token
- */
-export const getCurrentUserToken = async (): Promise<string | null> => {
-  return await getJWT();
-};
-
-/**
- * Check if user is authenticated with JWT
- */
-export const isCurrentUserAuthenticated = (): boolean => {
-  return isUserAuthenticated();
-};

package/src/utils/programmaticFlow.ts

@@ -1,113 +0,0 @@
-/**
- * Programmatic Onairos Flow
- * 
- * This function executes the complete Onairos authentication and onboarding flow
- * that can be attached to custom buttons or called programmatically.
- */
-
-import { OnairosButtonProps } from '../types';
-import { initializePlatformAuthService } from '../services/platformAuthService';
-
-/**
- * Execute the complete Onairos flow programmatically
- * This is the same logic that the OnairosButton uses internally
- * 
- * @param options Configuration options for the flow
- * @returns Promise that resolves when flow is complete
- */
-export const executeOnairosFlow = async (options: OnairosButtonProps): Promise<void> => {
-  try {
-    console.log('🚀 Starting Onairos flow programmatically...');
-    
-    // Initialize API key service if not already initialized
-    await initializePlatformAuthService();
-    
-    // Import components dynamically to avoid circular dependencies
-    const { UniversalOnboarding } = await import('../components/UniversalOnboarding');
-    const React = await import('react');
-    
-    // Create a promise that resolves when the flow is complete
-    return new Promise((resolve, reject) => {
-      let modalRef: any = null;
-      
-      const handleComplete = (apiUrl: string, token: string, userData: any) => {
-        console.log('✅ Onairos flow completed successfully');
-        
-        // Clean up modal
-        if (modalRef && modalRef.close) {
-          modalRef.close();
-        }
-        
-        // Call user's onResolved callback
-        if (options.onResolved) {
-          options.onResolved(apiUrl, token, userData);
-        }
-        
-        resolve();
-      };
-      
-      const handleRejection = (error?: string) => {
-        console.log('❌ Onairos flow rejected:', error);
-        
-        // Clean up modal
-        if (modalRef && modalRef.close) {
-          modalRef.close();
-        }
-        
-        // Call user's onRejection callback
-        if (options.onRejection) {
-          options.onRejection(error);
-        }
-        
-        reject(new Error(error || 'Onairos flow was rejected'));
-      };
-      
-      // Create and show the Universal Onboarding modal
-      const modalElement = React.createElement(UniversalOnboarding, {
-        visible: true,
-        onClose: () => handleRejection('User closed the modal'),
-        AppName: options.AppName,
-        requestData: options.requestData,
-        returnLink: options.returnLink,
-        onComplete: handleComplete,
-        preferredPlatform: options.preferredPlatform,
-        debug: options.debug,
-        testMode: options.testMode,
-      });
-      
-      // Store modal reference for cleanup
-      modalRef = modalElement;
-      
-      // Note: In a real implementation, you'd need to render this modal
-      // This is a simplified version - the actual implementation would
-      // need to handle React rendering in the current app context
-      console.log('📱 Onairos modal should be displayed');
-    });
-  } catch (error) {
-    console.error('❌ Failed to execute Onairos flow:', error);
-    throw error;
-  }
-};
-
-/**
- * Simple wrapper function that matches the OnairosButton click behavior
- * 
- * @param options Configuration options for the flow
- * @returns Promise that resolves when flow is complete
- */
-export const startOnairosFlow = async (options: OnairosButtonProps): Promise<void> => {
-  // Pre-check if provided
-  if (options.preCheck) {
-    const canProceed = await options.preCheck();
-    if (!canProceed) {
-      console.log('❌ Pre-check failed, not starting Onairos flow');
-      if (options.onRejection) {
-        options.onRejection('Pre-check failed');
-      }
-      return;
-    }
-  }
-  
-  // Execute the flow
-  return executeOnairosFlow(options);
-};