@onairos/react-native 3.4.0 → 3.5.4

package/src/services/oauthService.ts

@@ -1,412 +0,0 @@
-import { Linking, Platform } from 'react-native';
-import { updateCredentials, OnairosCredentials } from '../utils/secureStorage';
-import { sha256 } from '../utils/crypto';
-import { onairosApi } from '../api';
-
-// Define OAuth configuration types
-export interface OAuthConfig {
-  clientId: string;
-  redirectUri: string;
-  scope: string;
-  authorizationEndpoint: string;
-  tokenEndpoint: string;
-  responseType: string;
-}
-
-// Platform-specific OAuth configurations
-const OAUTH_CONFIGS: Record<string, OAuthConfig> = {
-  instagram: {
-    clientId: 'YOUR_INSTAGRAM_CLIENT_ID', // Replace with actual client ID
-    redirectUri: 'onairosanime://auth/instagram',
-    scope: 'user_profile,user_media',
-    authorizationEndpoint: 'https://api.instagram.com/oauth/authorize',
-    tokenEndpoint: 'https://api.instagram.com/oauth/access_token',
-    responseType: 'code',
-  },
-  youtube: {
-    clientId: 'YOUR_YOUTUBE_CLIENT_ID', // Replace with actual client ID
-    redirectUri: 'onairosanime://auth/youtube',
-    scope: 'https://www.googleapis.com/auth/youtube.readonly',
-    authorizationEndpoint: 'https://accounts.google.com/o/oauth2/auth',
-    tokenEndpoint: 'https://oauth2.googleapis.com/token',
-    responseType: 'code',
-  },
-  pinterest: {
-    clientId: 'YOUR_PINTEREST_CLIENT_ID', // Replace with actual client ID
-    redirectUri: 'onairosanime://auth/pinterest',
-    scope: 'boards:read,pins:read',
-    authorizationEndpoint: 'https://www.pinterest.com/oauth/',
-    tokenEndpoint: 'https://api.pinterest.com/v5/oauth/token',
-    responseType: 'code',
-  },
-  reddit: {
-    clientId: 'YOUR_REDDIT_CLIENT_ID', // Replace with actual client ID
-    redirectUri: 'onairosanime://auth/reddit',
-    scope: 'identity,read',
-    authorizationEndpoint: 'https://www.reddit.com/api/v1/authorize',
-    tokenEndpoint: 'https://www.reddit.com/api/v1/access_token',
-    responseType: 'code',
-  },
-};
-
-/**
- * Generate a state value for OAuth to prevent CSRF attacks
- */
-const generateState = (): string => {
-  const randomValue = Math.random().toString(36).substring(2, 15);
-  return sha256(randomValue).substring(0, 10);
-};
-
-/**
- * Initialize OAuth service handlers and listeners
- */
-export const initializeOAuthService = (): void => {
-  // Set up deep linking handlers for OAuth redirects
-  Linking.addEventListener('url', handleDeepLink);
-};
-
-/**
- * Clean up OAuth service handlers and listeners
- */
-export const cleanupOAuthService = (): void => {
-  // Use the modern React Native Linking API
-  if (typeof Linking.removeAllListeners === 'function') {
-    Linking.removeAllListeners('url');
-  }
-};
-
-// Keep track of current OAuth state and callbacks
-let currentOAuthState: string | null = null;
-let currentOAuthPlatform: string | null = null;
-let currentOAuthResolve: ((value: any) => void) | null = null;
-let currentOAuthReject: ((error: Error) => void) | null = null;
-
-/**
- * Handle deep link callbacks from OAuth providers
- */
-const handleDeepLink = async (event: { url: string }): Promise<void> => {
-  try {
-    const { url } = event;
-    
-    // Check if this is an OAuth callback URL
-    if (!url.startsWith('onairosanime://auth/')) {
-      return;
-    }
-    
-    // Extract platform from URL path
-    const platform = url.split('onairosanime://auth/')[1].split('?')[0];
-    
-    // Only handle if it matches current OAuth flow
-    if (platform !== currentOAuthPlatform) {
-      return;
-    }
-    
-    // Parse URL parameters
-    const params = new URL(url).searchParams;
-    const code = params.get('code');
-    const state = params.get('state');
-    const error = params.get('error');
-    
-    // Validate state to prevent CSRF attacks
-    if (state !== currentOAuthState) {
-      if (currentOAuthReject) {
-        currentOAuthReject(new Error('OAuth state mismatch - possible CSRF attack'));
-      }
-      return;
-    }
-    
-    // Handle errors
-    if (error) {
-      if (currentOAuthReject) {
-        currentOAuthReject(new Error(`OAuth error: ${error}`));
-      }
-      return;
-    }
-    
-    // Proceed with token exchange if code is present
-    if (code) {
-      const tokenResult = await exchangeCodeForToken(platform, code);
-      
-      if (currentOAuthResolve) {
-        currentOAuthResolve(tokenResult);
-      }
-    } else {
-      if (currentOAuthReject) {
-        currentOAuthReject(new Error('No authorization code received'));
-      }
-    }
-  } catch (error) {
-    console.error('Error handling OAuth deep link:', error);
-    if (currentOAuthReject) {
-      currentOAuthReject(error as Error);
-    }
-  } finally {
-    // Reset state
-    currentOAuthState = null;
-    currentOAuthPlatform = null;
-    currentOAuthResolve = null;
-    currentOAuthReject = null;
-  }
-};
-
-/**
- * Exchange OAuth authorization code for access token
- */
-const exchangeCodeForToken = async (platform: string, code: string): Promise<any> => {
-  try {
-    const config = OAUTH_CONFIGS[platform];
-    
-    if (!config) {
-      throw new Error(`Unsupported platform: ${platform}`);
-    }
-    
-    // Prepare token request parameters
-    const params = new URLSearchParams({
-      grant_type: 'authorization_code',
-      code,
-      redirect_uri: config.redirectUri,
-      client_id: config.clientId,
-    });
-    
-    // Exchange code for token
-    const response = await fetch(config.tokenEndpoint, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/x-www-form-urlencoded',
-      },
-      body: params.toString(),
-    });
-    
-    const data = await response.json();
-    
-    if (!response.ok) {
-      throw new Error(data.error || 'Failed to exchange code for token');
-    }
-    
-    // Fetch user information based on the platform
-    const userInfo = await fetchUserInfo(platform, data.access_token);
-    
-    return {
-      token: data.access_token,
-      refreshToken: data.refresh_token,
-      expiresIn: data.expires_in,
-      username: userInfo.username,
-      userId: userInfo.id,
-    };
-  } catch (error) {
-    console.error(`Error exchanging code for token (${platform}):`, error);
-    throw error;
-  }
-};
-
-/**
- * Fetch user information from the connected platform
- */
-const fetchUserInfo = async (platform: string, accessToken: string): Promise<any> => {
-  try {
-    let endpoint;
-    let headers: Record<string, string> = {
-      Authorization: `Bearer ${accessToken}`,
-    };
-    
-    // Platform-specific API endpoints for user info
-    switch (platform) {
-      case 'instagram':
-        endpoint = 'https://graph.instagram.com/me?fields=id,username';
-        break;
-      case 'youtube':
-        endpoint = 'https://www.googleapis.com/youtube/v3/channels?part=snippet&mine=true';
-        break;
-      case 'pinterest':
-        endpoint = 'https://api.pinterest.com/v5/user_account';
-        break;
-      case 'reddit':
-        endpoint = 'https://oauth.reddit.com/api/v1/me';
-        break;
-      default:
-        throw new Error(`Unsupported platform: ${platform}`);
-    }
-    
-    const response = await fetch(endpoint, { headers });
-    const data = await response.json();
-    
-    if (!response.ok) {
-      throw new Error(data.error || 'Failed to fetch user info');
-    }
-    
-    // Extract user information based on platform-specific response format
-    switch (platform) {
-      case 'instagram':
-        return { id: data.id, username: data.username };
-      case 'youtube':
-        return { 
-          id: data.items[0].id, 
-          username: data.items[0].snippet.title 
-        };
-      case 'pinterest':
-        return { 
-          id: data.id, 
-          username: data.username || data.full_name 
-        };
-      case 'reddit':
-        return { id: data.id, username: data.name };
-      default:
-        throw new Error(`Unsupported platform: ${platform}`);
-    }
-  } catch (error) {
-    console.error(`Error fetching user info (${platform}):`, error);
-    throw error;
-  }
-};
-
-/**
- * Connect to a platform using OAuth
- */
-export const connectPlatform = (platform: string): Promise<any> => {
-  return new Promise((resolve, reject) => {
-    try {
-      const config = OAUTH_CONFIGS[platform];
-      
-      if (!config) {
-        throw new Error(`Unsupported platform: ${platform}`);
-      }
-      
-      // Generate state for CSRF protection
-      const state = generateState();
-      
-      // Build authorization URL
-      const authUrl = new URL(config.authorizationEndpoint);
-      authUrl.searchParams.append('client_id', config.clientId);
-      authUrl.searchParams.append('redirect_uri', config.redirectUri);
-      authUrl.searchParams.append('response_type', config.responseType);
-      authUrl.searchParams.append('scope', config.scope);
-      authUrl.searchParams.append('state', state);
-      
-      // Set up current OAuth state for callback handling
-      currentOAuthState = state;
-      currentOAuthPlatform = platform;
-      currentOAuthResolve = resolve;
-      currentOAuthReject = reject;
-      
-      // Open browser or WebView to the authorization URL
-      Linking.openURL(authUrl.toString());
-    } catch (error) {
-      reject(error);
-    }
-  });
-};
-
-/**
- * Disconnect from a platform
- */
-export const disconnectPlatform = async (
-  platform: string, 
-  credentials: OnairosCredentials
-): Promise<boolean> => {
-  try {
-    // Call Onairos API to disconnect platform
-    await onairosApi.post('/users/disconnect-platform', {
-      platform,
-      username: credentials.username,
-    });
-    
-    // Update local credentials to remove platform
-    const updatedPlatforms = { ...credentials.platforms };
-    
-    // Type-safe platform removal using keyof operator
-    if (updatedPlatforms && platform in updatedPlatforms) {
-    delete updatedPlatforms[platform as keyof typeof updatedPlatforms];
-    }
-    
-    await updateCredentials({
-      ...credentials,
-      platforms: updatedPlatforms,
-    });
-    
-    return true;
-  } catch (error) {
-    console.error(`Error disconnecting platform (${platform}):`, error);
-    return false;
-  }
-};
-
-/**
- * Store platform connection data in user credentials
- */
-export const storePlatformConnection = async (
-  platform: string,
-  connectionData: any,
-  credentials: OnairosCredentials
-): Promise<boolean> => {
-  try {
-    // Only accept valid platform types
-    const validPlatform = (
-      platform === 'instagram' || 
-      platform === 'youtube' || 
-      platform === 'pinterest' || 
-      platform === 'reddit'
-    );
-    
-    if (!validPlatform) {
-      throw new Error(`Unsupported platform: ${platform}`);
-    }
-    
-    // Update platforms in credentials with type safety
-    const updatedPlatforms = {
-      ...credentials.platforms,
-    };
-    
-    // Type-safe assignment 
-    const platformData = {
-        username: connectionData.username,
-        userId: connectionData.userId,
-      token: connectionData.token,
-      refreshToken: connectionData.refreshToken,
-      expiresAt: connectionData.expiresIn ? 
-        Date.now() + (connectionData.expiresIn * 1000) : 
-        null,
-      connectedAt: Date.now(),
-    };
-    
-    // Assign platform data based on platform type
-    if (platform === 'instagram') updatedPlatforms.instagram = platformData;
-    else if (platform === 'youtube') updatedPlatforms.youtube = platformData;
-    else if (platform === 'pinterest') updatedPlatforms.pinterest = platformData;
-    else if (platform === 'reddit') updatedPlatforms.reddit = platformData;
-    
-    // Update stored credentials
-    await updateCredentials({
-      ...credentials,
-      platforms: updatedPlatforms,
-    });
-    
-    return true;
-  } catch (error) {
-    console.error(`Error storing platform connection (${platform}):`, error);
-    return false;
-  }
-};
-
-export interface AuthorizationData {
-  accountName: string;
-  authUrl: string;
-}
-
-export interface PlatformConnectionResult {
-  success: boolean;
-  userName?: string;
-  error?: string;
-}
-
-/**
- * Service for handling OAuth connections to various platforms
- */
-export const OAuthService = {
-  initializeOAuthService,
-  cleanupOAuthService,
-  connectPlatform,
-  disconnectPlatform,
-  storePlatformConnection,
-  // Base API URL
-  _apiBaseUrl: 'https://api2.onairos.uk',
-};