Implementing OAuth and Social Login

import * as AuthSession from 'expo-auth-session';
import { Redirect } from 'expo-router';

const discovery = {
  authorizationEndpoint: 'https://accounts.google.com/o/oauth2/v2/auth',
  tokenEndpoint: 'https://oauth2.googleapis.com/token',
  revocationEndpoint: 'https://oauth2.googleapis.com/revoke',
};

const config = {
  clientId: 'your-client-id',
  clientSecret: 'your-client-secret',
  redirectUrl: AuthSession.makeRedirectUri({ useProxy: true }),
  scopes: ['openid', 'profile', 'email'],
};

export default function OAuthScreen() {
  const [request, response, promptAsync] = AuthSession.useAuthRequest(
    config,
    discovery
  );

  if (response) {
    if (response.error) {
      console.log('OAuth error:', response.error);
    } else if (response.type === 'success') {
      const { access_token } = response.params;
      // Handle the token
    }
  }

  return (
    <Redirect href={request ? request.url : '#'} />
  );
}

import * as AuthSession from 'expo-auth-session';
import { Google } from 'expo-auth-session/providers/google';

const config = {
  clientId: 'your-google-client-id',
  redirectUri: AuthSession.makeRedirectUri({ useProxy: true }),
  scopes: ['profile', 'email'],
};

const { authUrl, ...rest } = await AuthSession.getAuthSessionInfoAsync({
  provider: Google,
  config,
});

// Redirect user to authUrl
console.log('Redirect to:', authUrl);

import * as WebBrowser from 'expo-web-browser';

const config = {
  authUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
  clientId: '1234567890-abcde.apps.googleusercontent.com',
  redirectUrl: 'expohost://auth/callback',
  scopes: ['email', 'profile']
};

WebBrowser.openAuthSessionAsync(config.authUrl, config.redirectUrl);

import { AuthSession } from 'expo-auth-session';

const config = {
  autoDiscovery: true,
  issuer: 'https://accounts.google.com',
  clientId: 'your-client-id',
  clientSecret: 'your-client-secret',
  redirectUrl: AuthSession.getRedirectUrl(),
  scopes: ['profile', 'email']
};

const discovery = await AuthSession.fetchDiscoveryAsync(config.issuer);
console.log('Discovered endpoints:', discovery);

import { AppleAuth } from '@invertase/react-native-apple-auth';

const appleAuth = new AppleAuth({
  clientId: 'com.example.app',
  clientSecret: 'secret-key-here',
  redirectUri: 'https://example.com/auth/apple',
  scope: ['name', 'email'],
  responseType: 'code',
});

export default appleAuth;

import { Google } from 'expo-auth-session/providers/google';
import * as WebBrowser from 'expo-web-browser';

const config = {
  clientId: 'YOUR_GOOGLE_CLIENT_ID',
  scopes: ['profile', 'email'],
  redirectUrl: WebBrowser.makeRedirectUri({
    scheme: 'your-app-scheme'
  }),
  discoveryUrl: 'https://accounts.google.com/.well-known/openid-configuration'
};

const handleGoogleLogin = async () => {
  const result = await Google.logInAsync(config);
  if (result.type === 'success') {
    console.log('Google login successful', result);
  } else {
    console.log('Google login failed', result);
  }
};

import * as Facebook from 'expo-facebook';

export default function FacebookLoginButton() {
  const handleLogin = async () => {
    await Facebook.initializeAsync({
      appId: 'YOUR_FACEBOOK_APP_ID',
    });
    const { type, token } = await Facebook.logInAsync({
      permissions: ['public_profile', 'email'],
    });

    if (type === 'success') {
      // Send token to your backend for validation
      console.log('Login successful with token:', token);
    } else {
      console.log('Login failed');
    }
  };

  return (
    <TouchableOpacity onPress={handleLogin}>
      <Text>Login with Facebook</Text>
    </TouchableOpacity>
  );
}

import * as WebBrowser from 'expo-web-browser';

const handleAuth = async () => {
  const result = await WebBrowser.openAuthSessionAsync(
    'https://example.com/oauth/authorize',
    'https://example.com/callback'
  );
  console.log(result);
};

import * as SecureStore from 'expo-secure-store';

// Store auth token
await SecureStore.setItemAsync('authToken', token);

// Retrieve auth token
const token = await SecureStore.getItemAsync('authToken');

// Delete auth token
await SecureStore.deleteItemAsync('authToken');

import { AuthSession } from 'expo-auth-session';

const refreshAccessToken = async (refreshToken) => {
  const response = await fetch('https://api.example.com/auth/refresh', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ refreshToken }),
  });

  const { accessToken, expiresAt } = await response.json();
  return { accessToken, expiresAt };
};

// Usage
const newTokenData = await refreshAccessToken(refreshToken);

import * as SecureStore from 'expo-secure-store';

const saveSession = async (session) => {
  await SecureStore.setItemAsync('accessToken', session.accessToken);
  await SecureStore.setItemAsync('refreshToken', session.refreshToken);
  await SecureStore.setItemAsync('expiresAt', session.expiresAt.toString());
};

const loadSession = async () => {
  const accessToken = await SecureStore.getItemAsync('accessToken');
  const refreshToken = await SecureStore.getItemAsync('refreshToken');
  const expiresAt = await SecureStore.getItemAsync('expiresAt');

  return {
    accessToken,
    refreshToken,
    expiresAt: parseInt(expiresAt),
  };
};

const refreshSession = async (refreshToken) => {
  const response = await fetch('https://api.example.com/auth/refresh', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ refreshToken }),
  });

  const newSession = await response.json();
  await saveSession(newSession);
  return newSession;
};

import { AuthSession } from 'expo-auth-session';
import * as WebBrowser from 'expo-web-browser';

const handleLogout = async () => {
  try {
    // Clear auth state
    await AuthSession.clearSessionAsync();
    
    // Optionally clear local storage or tokens
    // AsyncStorage.removeItem('authToken');
    
    // Redirect to login screen
    // navigation.navigate('Login');
  } catch (error) {
    console.error('Logout error:', error);
  }
};