Mobile Integration

# Install required dependencies
npm install @react-native-async-storage/async-storage
# or
yarn add @react-native-async-storage/async-storage

// services/auth.ts
import AsyncStorage from '@react-native-async-storage/async-storage';

const API_BASE_URL = __DEV__ 
  ? 'http://localhost:3002' 
  : 'https://api.turbocamp.dev';

interface User {
  id: string;
  email: string;
  name: string;
  emailVerified: boolean;
  image?: string;
  createdAt: string;
  updatedAt: string;
}

interface Session {
  id: string;
  userId: string;
  expiresAt: string;
  token: string;
}

interface AuthResponse {
  user: User;
  session: Session;
}

class AuthService {
  private sessionToken: string | null = null;
  private user: User | null = null;

  async initialize() {
    try {
      this.sessionToken = await AsyncStorage.getItem('session_token');
      const userString = await AsyncStorage.getItem('user');
      this.user = userString ? JSON.parse(userString) : null;
    } catch (error) {
      console.error('Failed to initialize auth:', error);
    }
  }

  async signUp(email: string, password: string, name: string): Promise<AuthResponse> {
    try {
      const response = await fetch(`${API_BASE_URL}/api/auth/sign-up/email`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ email, password, name }),
      });

      if (!response.ok) {
        const error = await response.json();
        throw new Error(error.error.message);
      }

      const data = await response.json();
      await this.setAuthData(data);
      return data;
    } catch (error) {
      throw error;
    }
  }

  async signIn(email: string, password: string): Promise<AuthResponse> {
    try {
      const response = await fetch(`${API_BASE_URL}/api/auth/sign-in/email`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ email, password }),
      });

      if (!response.ok) {
        const error = await response.json();
        throw new Error(error.error.message);
      }

      const data = await response.json();
      await this.setAuthData(data);
      return data;
    } catch (error) {
      throw error;
    }
  }

  async getSession(): Promise<AuthResponse | null> {
    if (!this.sessionToken) return null;

    try {
      const response = await fetch(`${API_BASE_URL}/api/auth/get-session`, {
        headers: {
          'Cookie': `better-auth.session_token=${this.sessionToken}`,
        },
      });

      if (!response.ok) {
        await this.signOut();
        return null;
      }

      const data = await response.json();
      this.user = data.user;
      return data;
    } catch (error) {
      await this.signOut();
      return null;
    }
  }

  async signOut(): Promise<void> {
    if (this.sessionToken) {
      try {
        await fetch(`${API_BASE_URL}/api/auth/sign-out`, {
          method: 'POST',
          headers: {
            'Cookie': `better-auth.session_token=${this.sessionToken}`,
          },
        });
      } catch (error) {
        // Ignore errors during sign out
      }
    }
    
    await this.clearAuthData();
  }

  async forgotPassword(email: string): Promise<void> {
    try {
      const response = await fetch(`${API_BASE_URL}/api/auth/forget-password`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ email }),
      });

      if (!response.ok) {
        const error = await response.json();
        throw new Error(error.error.message);
      }
    } catch (error) {
      throw error;
    }
  }

  private async setAuthData(data: AuthResponse): Promise<void> {
    this.sessionToken = data.session.token;
    this.user = data.user;
    
    await AsyncStorage.setItem('session_token', this.sessionToken);
    await AsyncStorage.setItem('user', JSON.stringify(this.user));
  }

  private async clearAuthData(): Promise<void> {
    this.sessionToken = null;
    this.user = null;
    
    await AsyncStorage.removeItem('session_token');
    await AsyncStorage.removeItem('user');
  }

  getCurrentUser(): User | null {
    return this.user;
  }

  getSessionToken(): string | null {
    return this.sessionToken;
  }

  isAuthenticated(): boolean {
    return this.sessionToken !== null && this.user !== null;
  }
}

export const authService = new AuthService();

// contexts/AuthContext.tsx
import React, { createContext, useContext, useEffect, useState } from 'react';
import { authService } from '../services/auth';

interface User {
  id: string;
  email: string;
  name: string;
  emailVerified: boolean;
  image?: string;
  createdAt: string;
  updatedAt: string;
}

interface AuthContextType {
  user: User | null;
  loading: boolean;
  signIn: (email: string, password: string) => Promise<void>;
  signUp: (email: string, password: string, name: string) => Promise<void>;
  signOut: () => Promise<void>;
  forgotPassword: (email: string) => Promise<void>;
  refreshSession: () => Promise<void>;
}

const AuthContext = createContext<AuthContextType | undefined>(undefined);

export const useAuth = () => {
  const context = useContext(AuthContext);
  if (context === undefined) {
    throw new Error('useAuth must be used within an AuthProvider');
  }
  return context;
};

export const AuthProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
  const [user, setUser] = useState<User | null>(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    initializeAuth();
  }, []);

  const initializeAuth = async () => {
    try {
      await authService.initialize();
      const session = await authService.getSession();
      setUser(session?.user || null);
    } catch (error) {
      console.error('Failed to initialize auth:', error);
    } finally {
      setLoading(false);
    }
  };

  const signIn = async (email: string, password: string) => {
    try {
      setLoading(true);
      const response = await authService.signIn(email, password);
      setUser(response.user);
    } catch (error) {
      throw error;
    } finally {
      setLoading(false);
    }
  };

  const signUp = async (email: string, password: string, name: string) => {
    try {
      setLoading(true);
      const response = await authService.signUp(email, password, name);
      setUser(response.user);
    } catch (error) {
      throw error;
    } finally {
      setLoading(false);
    }
  };

  const signOut = async () => {
    try {
      setLoading(true);
      await authService.signOut();
      setUser(null);
    } catch (error) {
      console.error('Failed to sign out:', error);
    } finally {
      setLoading(false);
    }
  };

  const forgotPassword = async (email: string) => {
    try {
      await authService.forgotPassword(email);
    } catch (error) {
      throw error;
    }
  };

  const refreshSession = async () => {
    try {
      const session = await authService.getSession();
      setUser(session?.user || null);
    } catch (error) {
      console.error('Failed to refresh session:', error);
      setUser(null);
    }
  };

  const value = {
    user,
    loading,
    signIn,
    signUp,
    signOut,
    forgotPassword,
    refreshSession,
  };

  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
};