@onairos/react-native 3.1.15 → 3.1.17

package/src/services/jwtStorageService.ts

@@ -1,257 +1,257 @@
-import AsyncStorage from '@react-native-async-storage/async-storage';
-import { Buffer } from 'buffer';
-
-/**
- * JWT Token Storage Service - CORRECTED APPROACH
- * Manages 3 DISTINCT JWT token types for different route families
- * 
- * TOKEN TYPES:
- * 1. Enoch JWT (enoch_token) - For /enoch/*, /api/auth/*, /mobile-training/enoch
- * 2. Onairos JWT (onairos_jwt_token) - For /youtube/*, /gmail/*, social connections  
- * 3. Auth Token (auth_token) - For context-specific auth flows
- */
-
-export enum TokenType {
-  ENOCH = 'enoch_token',
-  ONAIROS = 'onairos_jwt_token', 
-  AUTH = 'auth_token'
-}
-
-/**
- * Route-based token mapping
- * Determines which token type to use for which routes
- */
-export const getTokenTypeForRoute = (route: string): TokenType => {
-  const cleanRoute = route.toLowerCase();
-  
-  // Enoch routes - use Enoch JWT
-  if (cleanRoute.includes('/enoch/') || 
-      cleanRoute.includes('/api/auth/') || 
-      cleanRoute.includes('/mobile-training/enoch')) {
-    return TokenType.ENOCH;
-  }
-  
-  // Onairos routes - use Onairos JWT  
-  if (cleanRoute.includes('/youtube/') || 
-      cleanRoute.includes('/gmail/') ||
-      cleanRoute.includes('/connectedaccounts') ||
-      cleanRoute.includes('/social/')) {
-    return TokenType.ONAIROS;
-  }
-  
-  // Default to auth token for other routes
-  return TokenType.AUTH;
-};
-
-/**
- * Store JWT token of specific type
- * @param tokenType - Type of token to store
- * @param token - JWT token to store
- * @returns Promise<boolean> - Success status
- */
-export const storeJWT = async (tokenType: TokenType, token: string): Promise<boolean> => {
-  try {
-    if (!token || token.trim() === '') {
-      console.warn(`⚠️ [JWT Storage] Attempted to store empty/null ${tokenType} token`);
-      return false;
-    }
-    
-    // Validate JWT format (should have 3 parts separated by dots)
-    const parts = token.split('.');
-    if (parts.length !== 3) {
-      console.warn(`⚠️ [JWT Storage] Invalid JWT format for ${tokenType} - token should have 3 parts`);
-      return false;
-    }
-    
-    await AsyncStorage.setItem(tokenType, token);
-    console.log(`✅ [JWT Storage] ${tokenType} token stored successfully`);
-    return true;
-  } catch (error) {
-    console.error(`❌ [JWT Storage] Failed to store ${tokenType} token:`, error);
-    return false;
-  }
-};
-
-/**
- * Retrieve JWT token of specific type
- * @param tokenType - Type of token to retrieve
- * @returns Promise<string | null> - JWT token or null if not found
- */
-export const getJWT = async (tokenType: TokenType): Promise<string | null> => {
-  try {
-    const token = await AsyncStorage.getItem(tokenType);
-    
-    if (!token) {
-      console.log(`📭 [JWT Storage] No ${tokenType} token found in storage`);
-      return null;
-    }
-    
-    // Validate JWT format
-    if (!isValidJWTFormat(token)) {
-      console.warn(`⚠️ [JWT Storage] Invalid JWT format found for ${tokenType}, removing`);
-      await clearJWT(tokenType);
-      return null;
-    }
-    
-    console.log(`🔐 [JWT Storage] ${tokenType} token retrieved successfully`);
-    return token;
-  } catch (error) {
-    console.error(`❌ [JWT Storage] Failed to retrieve ${tokenType} token:`, error);
-    return null;
-  }
-};
-
-/**
- * Get JWT token for specific route
- * @param route - API route to get token for
- * @returns Promise<string | null> - Appropriate JWT token or null
- */
-export const getJWTForRoute = async (route: string): Promise<string | null> => {
-  const tokenType = getTokenTypeForRoute(route);
-  const token = await getJWT(tokenType);
-  
-  if (token) {
-    console.log(`🎯 [JWT Storage] Using ${tokenType} token for route: ${route}`);
-  } else {
-    console.warn(`⚠️ [JWT Storage] No ${tokenType} token available for route: ${route}`);
-  }
-  
-  return token;
-};
-
-/**
- * Clear JWT token of specific type
- * @param tokenType - Type of token to clear
- * @returns Promise<boolean> - Success status
- */
-export const clearJWT = async (tokenType: TokenType): Promise<boolean> => {
-  try {
-    await AsyncStorage.removeItem(tokenType);
-    console.log(`✅ [JWT Storage] ${tokenType} token cleared successfully`);
-    return true;
-  } catch (error) {
-    console.error(`❌ [JWT Storage] Failed to clear ${tokenType} token:`, error);
-    return false;
-  }
-};
-
-/**
- * Clear all JWT tokens
- * @returns Promise<boolean> - Success status
- */
-export const clearAllJWT = async (): Promise<boolean> => {
-  try {
-    await Promise.all([
-      clearJWT(TokenType.ENOCH),
-      clearJWT(TokenType.ONAIROS), 
-      clearJWT(TokenType.AUTH)
-    ]);
-    console.log('✅ [JWT Storage] All JWT tokens cleared successfully');
-    return true;
-  } catch (error) {
-    console.error('❌ [JWT Storage] Failed to clear all JWT tokens:', error);
-    return false;
-  }
-};
-
-/**
- * Replace JWT token after verification - route-aware
- * @param tokenType - Type of token being replaced
- * @param newToken - New JWT token from verification response
- * @returns Promise<boolean> - Success status
- */
-export const replaceJWTAfterVerification = async (tokenType: TokenType, newToken: string): Promise<boolean> => {
-  try {
-    console.log(`🔄 [JWT Storage] Replacing ${tokenType} token after verification`);
-    
-    if (!newToken || !isValidJWTFormat(newToken)) {
-      console.error(`❌ [JWT Storage] Invalid ${tokenType} token provided for replacement`);
-      return false;
-    }
-    
-    // Clear old token first, then store new one
-    await clearJWT(tokenType);
-    const stored = await storeJWT(tokenType, newToken);
-    
-    if (stored) {
-      console.log(`✅ [JWT Storage] ${tokenType} token successfully replaced after verification`);
-    }
-    
-    return stored;
-  } catch (error) {
-    console.error(`❌ [JWT Storage] Failed to replace ${tokenType} token after verification:`, error);
-    return false;
-  }
-};
-
-/**
- * Store Enoch JWT token (from email verification)
- * @param token - Enoch JWT token
- * @returns Promise<boolean> - Success status
- */
-export const storeEnochJWT = async (token: string): Promise<boolean> => {
-  return await storeJWT(TokenType.ENOCH, token);
-};
-
-/**
- * Store Onairos JWT token (from sign-in/registration)
- * @param token - Onairos JWT token  
- * @returns Promise<boolean> - Success status
- */
-export const storeOnairosJWT = async (token: string): Promise<boolean> => {
-  return await storeJWT(TokenType.ONAIROS, token);
-};
-
-/**
- * Store Auth token (for context-specific flows)
- * @param token - Auth token
- * @returns Promise<boolean> - Success status
- */
-export const storeAuthToken = async (token: string): Promise<boolean> => {
-  return await storeJWT(TokenType.AUTH, token);
-};
-
-/**
- * Validate JWT format
- * @param token - Token to validate
- * @returns boolean - True if valid JWT format
- */
-const isValidJWTFormat = (token: string): boolean => {
-  if (!token || token.length < 20) return false;
-  
-  // Check if it's an email address (invalid JWT)
-  if (token.includes('@') && token.includes('.') && !token.includes('Bearer') && token.length < 100) {
-    return false;
-  }
-  
-  // Check if it has JWT structure (3 parts separated by dots)
-  const tokenParts = token.split('.');
-  if (tokenParts.length !== 3) return false;
-  
-  // Additional validation - JWT should be longer than 50 characters typically
-  if (token.length < 50) return false;
-  
-  return true;
-};
-
-/**
- * Check if JWT token of specific type exists and is valid
- * @param tokenType - Type of token to check
- * @returns Promise<boolean> - True if valid token exists
- */
-export const hasValidJWT = async (tokenType: TokenType): Promise<boolean> => {
-  const token = await getJWT(tokenType);
-  return token !== null;
-};
-
-/**
- * Get all available tokens (for debugging)
- * @returns Promise<Record<TokenType, string | null>> - All tokens
- */
-export const getAllTokens = async (): Promise<Record<TokenType, string | null>> => {
-  return {
-    [TokenType.ENOCH]: await getJWT(TokenType.ENOCH),
-    [TokenType.ONAIROS]: await getJWT(TokenType.ONAIROS),
-    [TokenType.AUTH]: await getJWT(TokenType.AUTH)
-  };
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { Buffer } from 'buffer';
+
+/**
+ * JWT Token Storage Service - CORRECTED APPROACH
+ * Manages 3 DISTINCT JWT token types for different route families
+ * 
+ * TOKEN TYPES:
+ * 1. Enoch JWT (enoch_token) - For /enoch/*, /api/auth/*, /mobile-training/enoch
+ * 2. Onairos JWT (onairos_jwt_token) - For /youtube/*, /gmail/*, social connections  
+ * 3. Auth Token (auth_token) - For context-specific auth flows
+ */
+
+export enum TokenType {
+  ENOCH = 'enoch_token',
+  ONAIROS = 'onairos_jwt_token', 
+  AUTH = 'auth_token'
+}
+
+/**
+ * Route-based token mapping
+ * Determines which token type to use for which routes
+ */
+export const getTokenTypeForRoute = (route: string): TokenType => {
+  const cleanRoute = route.toLowerCase();
+  
+  // Enoch routes - use Enoch JWT
+  if (cleanRoute.includes('/enoch/') || 
+      cleanRoute.includes('/api/auth/') || 
+      cleanRoute.includes('/mobile-training/enoch')) {
+    return TokenType.ENOCH;
+  }
+  
+  // Onairos routes - use Onairos JWT  
+  if (cleanRoute.includes('/youtube/') || 
+      cleanRoute.includes('/gmail/') ||
+      cleanRoute.includes('/connectedaccounts') ||
+      cleanRoute.includes('/social/')) {
+    return TokenType.ONAIROS;
+  }
+  
+  // Default to auth token for other routes
+  return TokenType.AUTH;
+};
+
+/**
+ * Store JWT token of specific type
+ * @param tokenType - Type of token to store
+ * @param token - JWT token to store
+ * @returns Promise<boolean> - Success status
+ */
+export const storeJWT = async (tokenType: TokenType, token: string): Promise<boolean> => {
+  try {
+    if (!token || token.trim() === '') {
+      console.warn(`⚠️ [JWT Storage] Attempted to store empty/null ${tokenType} token`);
+      return false;
+    }
+    
+    // Validate JWT format (should have 3 parts separated by dots)
+    const parts = token.split('.');
+    if (parts.length !== 3) {
+      console.warn(`⚠️ [JWT Storage] Invalid JWT format for ${tokenType} - token should have 3 parts`);
+      return false;
+    }
+    
+    await AsyncStorage.setItem(tokenType, token);
+    console.log(`✅ [JWT Storage] ${tokenType} token stored successfully`);
+    return true;
+  } catch (error) {
+    console.error(`❌ [JWT Storage] Failed to store ${tokenType} token:`, error);
+    return false;
+  }
+};
+
+/**
+ * Retrieve JWT token of specific type
+ * @param tokenType - Type of token to retrieve
+ * @returns Promise<string | null> - JWT token or null if not found
+ */
+export const getJWT = async (tokenType: TokenType): Promise<string | null> => {
+  try {
+    const token = await AsyncStorage.getItem(tokenType);
+    
+    if (!token) {
+      console.log(`📭 [JWT Storage] No ${tokenType} token found in storage`);
+      return null;
+    }
+    
+    // Validate JWT format
+    if (!isValidJWTFormat(token)) {
+      console.warn(`⚠️ [JWT Storage] Invalid JWT format found for ${tokenType}, removing`);
+      await clearJWT(tokenType);
+      return null;
+    }
+    
+    console.log(`🔐 [JWT Storage] ${tokenType} token retrieved successfully`);
+    return token;
+  } catch (error) {
+    console.error(`❌ [JWT Storage] Failed to retrieve ${tokenType} token:`, error);
+    return null;
+  }
+};
+
+/**
+ * Get JWT token for specific route
+ * @param route - API route to get token for
+ * @returns Promise<string | null> - Appropriate JWT token or null
+ */
+export const getJWTForRoute = async (route: string): Promise<string | null> => {
+  const tokenType = getTokenTypeForRoute(route);
+  const token = await getJWT(tokenType);
+  
+  if (token) {
+    console.log(`🎯 [JWT Storage] Using ${tokenType} token for route: ${route}`);
+  } else {
+    console.warn(`⚠️ [JWT Storage] No ${tokenType} token available for route: ${route}`);
+  }
+  
+  return token;
+};
+
+/**
+ * Clear JWT token of specific type
+ * @param tokenType - Type of token to clear
+ * @returns Promise<boolean> - Success status
+ */
+export const clearJWT = async (tokenType: TokenType): Promise<boolean> => {
+  try {
+    await AsyncStorage.removeItem(tokenType);
+    console.log(`✅ [JWT Storage] ${tokenType} token cleared successfully`);
+    return true;
+  } catch (error) {
+    console.error(`❌ [JWT Storage] Failed to clear ${tokenType} token:`, error);
+    return false;
+  }
+};
+
+/**
+ * Clear all JWT tokens
+ * @returns Promise<boolean> - Success status
+ */
+export const clearAllJWT = async (): Promise<boolean> => {
+  try {
+    await Promise.all([
+      clearJWT(TokenType.ENOCH),
+      clearJWT(TokenType.ONAIROS), 
+      clearJWT(TokenType.AUTH)
+    ]);
+    console.log('✅ [JWT Storage] All JWT tokens cleared successfully');
+    return true;
+  } catch (error) {
+    console.error('❌ [JWT Storage] Failed to clear all JWT tokens:', error);
+    return false;
+  }
+};
+
+/**
+ * Replace JWT token after verification - route-aware
+ * @param tokenType - Type of token being replaced
+ * @param newToken - New JWT token from verification response
+ * @returns Promise<boolean> - Success status
+ */
+export const replaceJWTAfterVerification = async (tokenType: TokenType, newToken: string): Promise<boolean> => {
+  try {
+    console.log(`🔄 [JWT Storage] Replacing ${tokenType} token after verification`);
+    
+    if (!newToken || !isValidJWTFormat(newToken)) {
+      console.error(`❌ [JWT Storage] Invalid ${tokenType} token provided for replacement`);
+      return false;
+    }
+    
+    // Clear old token first, then store new one
+    await clearJWT(tokenType);
+    const stored = await storeJWT(tokenType, newToken);
+    
+    if (stored) {
+      console.log(`✅ [JWT Storage] ${tokenType} token successfully replaced after verification`);
+    }
+    
+    return stored;
+  } catch (error) {
+    console.error(`❌ [JWT Storage] Failed to replace ${tokenType} token after verification:`, error);
+    return false;
+  }
+};
+
+/**
+ * Store Enoch JWT token (from email verification)
+ * @param token - Enoch JWT token
+ * @returns Promise<boolean> - Success status
+ */
+export const storeEnochJWT = async (token: string): Promise<boolean> => {
+  return await storeJWT(TokenType.ENOCH, token);
+};
+
+/**
+ * Store Onairos JWT token (from sign-in/registration)
+ * @param token - Onairos JWT token  
+ * @returns Promise<boolean> - Success status
+ */
+export const storeOnairosJWT = async (token: string): Promise<boolean> => {
+  return await storeJWT(TokenType.ONAIROS, token);
+};
+
+/**
+ * Store Auth token (for context-specific flows)
+ * @param token - Auth token
+ * @returns Promise<boolean> - Success status
+ */
+export const storeAuthToken = async (token: string): Promise<boolean> => {
+  return await storeJWT(TokenType.AUTH, token);
+};
+
+/**
+ * Validate JWT format
+ * @param token - Token to validate
+ * @returns boolean - True if valid JWT format
+ */
+const isValidJWTFormat = (token: string): boolean => {
+  if (!token || token.length < 20) return false;
+  
+  // Check if it's an email address (invalid JWT)
+  if (token.includes('@') && token.includes('.') && !token.includes('Bearer') && token.length < 100) {
+    return false;
+  }
+  
+  // Check if it has JWT structure (3 parts separated by dots)
+  const tokenParts = token.split('.');
+  if (tokenParts.length !== 3) return false;
+  
+  // Additional validation - JWT should be longer than 50 characters typically
+  if (token.length < 50) return false;
+  
+  return true;
+};
+
+/**
+ * Check if JWT token of specific type exists and is valid
+ * @param tokenType - Type of token to check
+ * @returns Promise<boolean> - True if valid token exists
+ */
+export const hasValidJWT = async (tokenType: TokenType): Promise<boolean> => {
+  const token = await getJWT(tokenType);
+  return token !== null;
+};
+
+/**
+ * Get all available tokens (for debugging)
+ * @returns Promise<Record<TokenType, string | null>> - All tokens
+ */
+export const getAllTokens = async (): Promise<Record<TokenType, string | null>> => {
+  return {
+    [TokenType.ENOCH]: await getJWT(TokenType.ENOCH),
+    [TokenType.ONAIROS]: await getJWT(TokenType.ONAIROS),
+    [TokenType.AUTH]: await getJWT(TokenType.AUTH)
+  };
 };