@pixygon/auth 1.0.0

package/src/providers/AuthProvider.tsx

@@ -0,0 +1,480 @@
+/**
+ * @pixygon/auth - Auth Provider
+ * React context provider for authentication state management
+ */
+
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useState,
+  useCallback,
+  useMemo,
+  type ReactNode,
+} from 'react';
+import type {
+  AuthConfig,
+  AuthContextValue,
+  AuthState,
+  AuthStatus,
+  AuthError,
+  UserRole,
+  LoginRequest,
+  LoginResponse,
+  RegisterRequest,
+  RegisterResponse,
+  VerifyRequest,
+  VerifyResponse,
+  ForgotPasswordRequest,
+  ForgotPasswordResponse,
+  RecoverPasswordRequest,
+  RecoverPasswordResponse,
+  ResendVerificationRequest,
+  ResendVerificationResponse,
+} from '../types';
+import { createTokenStorage } from '../utils/storage';
+import { createAuthApiClient } from '../api/client';
+
+// ============================================================================
+// Context
+// ============================================================================
+
+const AuthContext = createContext<AuthContextValue | null>(null);
+
+// ============================================================================
+// Default Config
+// ============================================================================
+
+const defaultConfig: Partial<AuthConfig> = {
+  autoRefresh: true,
+  refreshThreshold: 300, // 5 minutes before expiry
+  debug: false,
+};
+
+// ============================================================================
+// Provider Props
+// ============================================================================
+
+export interface AuthProviderProps {
+  config: AuthConfig;
+  children: ReactNode;
+}
+
+// ============================================================================
+// Provider Component
+// ============================================================================
+
+export function AuthProvider({ config: userConfig, children }: AuthProviderProps) {
+  const config = useMemo(() => ({ ...defaultConfig, ...userConfig }), [userConfig]);
+
+  // Initialize storage and API client
+  const tokenStorage = useMemo(
+    () => createTokenStorage(config.appId, config.storage),
+    [config.appId, config.storage]
+  );
+
+  const apiClient = useMemo(
+    () => createAuthApiClient(config as AuthConfig, tokenStorage),
+    [config, tokenStorage]
+  );
+
+  // Auth state
+  const [state, setState] = useState<AuthState>({
+    user: null,
+    accessToken: null,
+    refreshToken: null,
+    status: 'idle',
+    isLoading: true,
+    error: null,
+  });
+
+  const log = useCallback(
+    (...args: unknown[]) => {
+      if (config.debug) {
+        console.log('[PixygonAuth]', ...args);
+      }
+    },
+    [config.debug]
+  );
+
+  // ========================================================================
+  // Initialization - Restore auth state from storage
+  // ========================================================================
+
+  useEffect(() => {
+    let mounted = true;
+
+    async function initializeAuth() {
+      log('Initializing auth...');
+
+      try {
+        const stored = await tokenStorage.getAll();
+
+        if (!stored.accessToken || !stored.user) {
+          log('No stored auth found');
+          if (mounted) {
+            setState((prev) => ({
+              ...prev,
+              status: 'unauthenticated',
+              isLoading: false,
+            }));
+          }
+          return;
+        }
+
+        // Check if token is expired
+        const isExpired = await tokenStorage.isTokenExpired();
+
+        if (isExpired && stored.refreshToken) {
+          log('Token expired, attempting refresh...');
+          try {
+            const response = await apiClient.refreshToken({
+              refreshToken: stored.refreshToken,
+            });
+
+            if (mounted) {
+              setState({
+                user: stored.user,
+                accessToken: response.token,
+                refreshToken: response.refreshToken,
+                status: 'authenticated',
+                isLoading: false,
+                error: null,
+              });
+              apiClient.setAccessToken(response.token);
+            }
+          } catch (error) {
+            log('Token refresh failed:', error);
+            await tokenStorage.clear();
+            if (mounted) {
+              setState({
+                user: null,
+                accessToken: null,
+                refreshToken: null,
+                status: 'unauthenticated',
+                isLoading: false,
+                error: null,
+              });
+            }
+          }
+        } else if (!isExpired) {
+          log('Restoring auth from storage');
+          apiClient.setAccessToken(stored.accessToken);
+
+          if (mounted) {
+            setState({
+              user: stored.user,
+              accessToken: stored.accessToken,
+              refreshToken: stored.refreshToken,
+              status: stored.user.isVerified ? 'authenticated' : 'verifying',
+              isLoading: false,
+              error: null,
+            });
+          }
+        } else {
+          log('Token expired and no refresh token available');
+          await tokenStorage.clear();
+          if (mounted) {
+            setState({
+              user: null,
+              accessToken: null,
+              refreshToken: null,
+              status: 'unauthenticated',
+              isLoading: false,
+              error: null,
+            });
+          }
+        }
+      } catch (error) {
+        log('Auth initialization error:', error);
+        if (mounted) {
+          setState((prev) => ({
+            ...prev,
+            status: 'unauthenticated',
+            isLoading: false,
+            error: {
+              code: 'UNKNOWN_ERROR',
+              message: 'Failed to initialize authentication',
+            },
+          }));
+        }
+      }
+    }
+
+    initializeAuth();
+
+    return () => {
+      mounted = false;
+    };
+  }, [apiClient, tokenStorage, log]);
+
+  // ========================================================================
+  // Auto Token Refresh
+  // ========================================================================
+
+  useEffect(() => {
+    if (!config.autoRefresh || state.status !== 'authenticated') {
+      return;
+    }
+
+    const checkAndRefresh = async () => {
+      const willExpire = await tokenStorage.willExpireSoon(config.refreshThreshold || 300);
+      if (willExpire && state.refreshToken) {
+        log('Token expiring soon, refreshing...');
+        try {
+          const response = await apiClient.refreshToken({
+            refreshToken: state.refreshToken,
+          });
+
+          setState((prev) => ({
+            ...prev,
+            accessToken: response.token,
+            refreshToken: response.refreshToken,
+          }));
+          apiClient.setAccessToken(response.token);
+        } catch (error) {
+          log('Auto-refresh failed:', error);
+        }
+      }
+    };
+
+    // Check every minute
+    const interval = setInterval(checkAndRefresh, 60000);
+
+    return () => clearInterval(interval);
+  }, [
+    config.autoRefresh,
+    config.refreshThreshold,
+    state.status,
+    state.refreshToken,
+    apiClient,
+    tokenStorage,
+    log,
+  ]);
+
+  // ========================================================================
+  // Auth Actions
+  // ========================================================================
+
+  const login = useCallback(
+    async (credentials: LoginRequest): Promise<LoginResponse> => {
+      setState((prev) => ({ ...prev, isLoading: true, error: null }));
+
+      try {
+        const response = await apiClient.login(credentials);
+
+        const newStatus: AuthStatus = response.user.isVerified ? 'authenticated' : 'verifying';
+
+        setState({
+          user: response.user,
+          accessToken: response.token,
+          refreshToken: response.refreshToken || null,
+          status: newStatus,
+          isLoading: false,
+          error: null,
+        });
+
+        return response;
+      } catch (error) {
+        const authError = error as AuthError;
+        setState((prev) => ({
+          ...prev,
+          isLoading: false,
+          error: authError,
+        }));
+        config.onError?.(authError);
+        throw error;
+      }
+    },
+    [apiClient, config]
+  );
+
+  const register = useCallback(
+    async (data: RegisterRequest): Promise<RegisterResponse> => {
+      setState((prev) => ({ ...prev, isLoading: true, error: null }));
+
+      try {
+        const response = await apiClient.register(data);
+
+        setState((prev) => ({
+          ...prev,
+          isLoading: false,
+        }));
+
+        return response;
+      } catch (error) {
+        const authError = error as AuthError;
+        setState((prev) => ({
+          ...prev,
+          isLoading: false,
+          error: authError,
+        }));
+        config.onError?.(authError);
+        throw error;
+      }
+    },
+    [apiClient, config]
+  );
+
+  const verify = useCallback(
+    async (data: VerifyRequest): Promise<VerifyResponse> => {
+      setState((prev) => ({ ...prev, isLoading: true, error: null }));
+
+      try {
+        const response = await apiClient.verify(data);
+
+        setState({
+          user: response.user,
+          accessToken: response.token,
+          refreshToken: response.refreshToken || null,
+          status: 'authenticated',
+          isLoading: false,
+          error: null,
+        });
+
+        return response;
+      } catch (error) {
+        const authError = error as AuthError;
+        setState((prev) => ({
+          ...prev,
+          isLoading: false,
+          error: authError,
+        }));
+        config.onError?.(authError);
+        throw error;
+      }
+    },
+    [apiClient, config]
+  );
+
+  const resendVerification = useCallback(
+    async (data: ResendVerificationRequest): Promise<ResendVerificationResponse> => {
+      return apiClient.resendVerification(data);
+    },
+    [apiClient]
+  );
+
+  const forgotPassword = useCallback(
+    async (data: ForgotPasswordRequest): Promise<ForgotPasswordResponse> => {
+      return apiClient.forgotPassword(data);
+    },
+    [apiClient]
+  );
+
+  const recoverPassword = useCallback(
+    async (data: RecoverPasswordRequest): Promise<RecoverPasswordResponse> => {
+      return apiClient.recoverPassword(data);
+    },
+    [apiClient]
+  );
+
+  const logout = useCallback(async (): Promise<void> => {
+    log('Logging out...');
+
+    await tokenStorage.clear();
+    apiClient.setAccessToken(null);
+
+    setState({
+      user: null,
+      accessToken: null,
+      refreshToken: null,
+      status: 'unauthenticated',
+      isLoading: false,
+      error: null,
+    });
+
+    config.onLogout?.();
+  }, [tokenStorage, apiClient, config, log]);
+
+  const refreshTokens = useCallback(async (): Promise<void> => {
+    if (!state.refreshToken) {
+      throw new Error('No refresh token available');
+    }
+
+    const response = await apiClient.refreshToken({
+      refreshToken: state.refreshToken,
+    });
+
+    setState((prev) => ({
+      ...prev,
+      accessToken: response.token,
+      refreshToken: response.refreshToken,
+    }));
+  }, [apiClient, state.refreshToken]);
+
+  // ========================================================================
+  // Utility Functions
+  // ========================================================================
+
+  const getAccessToken = useCallback(() => state.accessToken, [state.accessToken]);
+
+  const hasRole = useCallback(
+    (role: UserRole | UserRole[]): boolean => {
+      if (!state.user) return false;
+
+      const roles = Array.isArray(role) ? role : [role];
+      return roles.includes(state.user.role);
+    },
+    [state.user]
+  );
+
+  // ========================================================================
+  // Context Value
+  // ========================================================================
+
+  const contextValue = useMemo<AuthContextValue>(
+    () => ({
+      // State
+      ...state,
+      isAuthenticated: state.status === 'authenticated',
+      isVerified: state.user?.isVerified ?? false,
+
+      // Actions
+      login,
+      register,
+      logout,
+      verify,
+      resendVerification,
+      forgotPassword,
+      recoverPassword,
+      refreshTokens,
+
+      // Utilities
+      getAccessToken,
+      hasRole,
+
+      // Config
+      config: config as AuthConfig,
+    }),
+    [
+      state,
+      login,
+      register,
+      logout,
+      verify,
+      resendVerification,
+      forgotPassword,
+      recoverPassword,
+      refreshTokens,
+      getAccessToken,
+      hasRole,
+      config,
+    ]
+  );
+
+  return <AuthContext.Provider value={contextValue}>{children}</AuthContext.Provider>;
+}
+
+// ============================================================================
+// Hook
+// ============================================================================
+
+export function useAuthContext(): AuthContextValue {
+  const context = useContext(AuthContext);
+  if (!context) {
+    throw new Error('useAuthContext must be used within an AuthProvider');
+  }
+  return context;
+}
+
+export { AuthContext };