@djangocfg/api 2.1.10 → 2.1.15

package/src/auth/context/AuthContext.tsx

@@ -0,0 +1,604 @@
+// @ts-nocheck
+'use client';
+
+import { usePathname } from 'next/navigation';
+import React, {
+    createContext, ReactNode, useCallback, useContext, useEffect, useMemo, useRef, useState
+} from 'react';
+
+import { api as apiAccounts, Enums } from '../../';
+import { useAccountsContext, AccountsProvider } from './AccountsContext';
+import { useLocalStorage, useQueryParams, useCfgRouter } from '@djangocfg/ui-nextjs/hooks';
+import { getCachedProfile, clearProfileCache } from '../hooks/useProfileCache';
+
+import { authLogger } from '../utils/logger';
+import { Analytics, AnalyticsEvent, AnalyticsCategory } from '../utils/analytics';
+import type { AuthConfig, AuthContextType, AuthProviderProps, UserProfile } from './types';
+
+// Default routes
+const defaultRoutes = {
+  auth: '/auth',
+  defaultCallback: '/dashboard',
+  defaultAuthCallback: '/auth',
+};
+
+const AuthContext = createContext<AuthContextType | undefined>(undefined);
+
+// Constants
+const EMAIL_STORAGE_KEY = 'auth_email';
+const PHONE_STORAGE_KEY = 'auth_phone';
+const AUTH_REDIRECT_KEY = 'auth_redirect_url';
+
+const hasValidTokens = (): boolean => {
+  if (typeof window === 'undefined') return false;
+  return apiAccounts.isAuthenticated();
+};
+
+// Internal provider that uses AccountsContext
+const AuthProviderInternal: React.FC<AuthProviderProps> = ({ children, config }) => {
+  const accounts = useAccountsContext();
+
+  // Smart initial loading state: only true if we don't have tokens yet
+  const [isLoading, setIsLoading] = useState(() => {
+    // If we already have tokens and profile, don't show loading
+    if (typeof window !== 'undefined') {
+      const hasTokens = hasValidTokens();
+      // Only show loading on initial mount if no tokens
+      return !hasTokens;
+    }
+    return true;
+  });
+
+  const [initialized, setInitialized] = useState(false);
+  const router = useCfgRouter();
+  const pathname = usePathname();
+  const queryParams = useQueryParams();
+
+  // Use localStorage hooks for email, phone, and redirect
+  const [storedEmail, setStoredEmail, clearStoredEmail] = useLocalStorage<string | null>(EMAIL_STORAGE_KEY, null);
+  const [storedPhone, setStoredPhone, clearStoredPhone] = useLocalStorage<string | null>(PHONE_STORAGE_KEY, null);
+  const [redirectUrl, setRedirectUrl, clearRedirectUrl] = useLocalStorage<string | null>(AUTH_REDIRECT_KEY, null);
+
+  // Map AccountsContext profile to UserProfile
+  const user = accounts.profile as UserProfile | null;
+
+  // Use refs to avoid dependency issues
+  const userRef = useRef(user);
+  const configRef = useRef(config);
+  const isLoadingProfileRef = useRef(false);
+
+  // Update refs when values change
+  useEffect(() => {
+    userRef.current = user;
+  }, [user]);
+
+  useEffect(() => {
+    configRef.current = config;
+  }, [config]);
+
+  // Note: API URL is configured in BaseClient, not at runtime
+
+  // Common function to clear auth state
+  const clearAuthState = useCallback((caller: string) => {
+    authLogger.info('clearAuthState >> caller', caller);
+    apiAccounts.clearTokens();
+    clearProfileCache(); // Clear profile cache from localStorage
+    // Note: user is now managed by AccountsContext, will auto-update
+    setInitialized(true);
+    setIsLoading(false);
+  }, []);
+
+  // Global error handler for auth-related errors
+  const handleGlobalAuthError = useCallback((error: any, context: string = 'API Request') => {
+    // Simple error check - if response has error flag, it's an error
+    if (error?.success === false) {
+      authLogger.warn(`Error detected in ${context}, clearing tokens`);
+      clearAuthState(`globalAuthError:${context}`);
+      return true;
+    }
+
+    return false;
+  }, [clearAuthState]);
+
+  // Simple profile loading without retry - now uses AccountsContext with memoization
+  const loadCurrentProfile = useCallback(async (callerId?: string): Promise<void> => {
+    const finalCallerId = callerId || 'AuthContext.loadCurrentProfile';
+
+    // Check if profile loading is already in progress
+    if (isLoadingProfileRef.current) {
+      authLogger.debug(`Profile loading already in progress, skipping duplicate call from: ${finalCallerId}`);
+      return;
+    }
+
+    authLogger.debug(`loadCurrentProfile called by: ${finalCallerId}`);
+
+    try {
+      isLoadingProfileRef.current = true;
+
+      // Ensure API clients are properly initialized with current token
+      const isAuth = apiAccounts.isAuthenticated();
+      const token = apiAccounts.getToken();
+      // authLogger.debug('isAuthenticated:', isAuth, 'token:', token ? token.substring(0, 20) + '...' : 'null');
+
+      if (!isAuth) {
+        authLogger.warn('No valid authentication token, throwing error');
+        throw new Error('No valid authentication token');
+      }
+
+      // Check if profile is already loaded in AccountsContext to prevent duplicate API calls
+      if (accounts.profile && !accounts.isLoadingProfile) {
+        authLogger.debug('Profile already loaded in AccountsContext, skipping API call');
+        setInitialized(true);
+        return;
+      }
+
+      // Refresh profile from AccountsContext (now with memoization)
+      const refreshedProfile = await accounts.refreshProfile(finalCallerId);
+
+      if (refreshedProfile) {
+        authLogger.info('Profile loaded successfully:', refreshedProfile.id);
+      } else {
+        authLogger.warn('Profile refresh returned undefined - but keeping tokens');
+      }
+
+      // Always mark as initialized if we have valid tokens
+      // Don't clear tokens just because profile fetch failed
+      setInitialized(true);
+    } catch (error) {
+      authLogger.error('Failed to load profile:', error);
+      // Use global error handler first, fallback to clearing state
+      if (!handleGlobalAuthError(error, 'loadCurrentProfile')) {
+        clearAuthState('loadCurrentProfile:error');
+      }
+    } finally {
+      isLoadingProfileRef.current = false;
+    }
+  }, [clearAuthState, handleGlobalAuthError, accounts]);
+
+  // Initialize auth state once
+  useEffect(() => {
+    if (initialized) return;
+
+    const initializeAuth = async () => {
+      authLogger.info('Initializing auth...');
+
+      // Check if running in iframe (AdminLayout will handle auth via postMessage)
+      const isInIframe = typeof window !== 'undefined' && window.self !== window.top;
+      authLogger.info('Is in iframe:', isInIframe);
+
+      // Debug token state
+      const token = apiAccounts.getToken();
+      const refreshToken = apiAccounts.getRefreshToken();
+      authLogger.info('Token from API:', token ? `${token.substring(0, 20)}...` : 'null');
+      authLogger.info('Refresh token from API:', refreshToken ? `${refreshToken.substring(0, 20)}...` : 'null');
+      authLogger.info('localStorage keys:', Object.keys(localStorage).filter(k => k.includes('token') || k.includes('auth')));
+
+      const hasTokens = hasValidTokens();
+      authLogger.info('Has tokens:', hasTokens);
+
+      // Check if profile is already loaded from cache (AccountsContext initialization)
+      if (userRef.current) {
+        authLogger.info('Profile already loaded from AccountsContext cache, skipping API request');
+        setInitialized(true);
+        setIsLoading(false);
+        return;
+      }
+
+      // Check if cache exists in localStorage (before userRef updates)
+      const cachedProfile = getCachedProfile();
+      if (cachedProfile) {
+        authLogger.info('Profile found in localStorage cache, skipping API request');
+        setInitialized(true);
+        setIsLoading(false);
+        return;
+      }
+
+      // In iframe mode WITHOUT tokens yet - wait for AdminLayout to receive them via postMessage
+      // Don't initialize yet - AdminLayout.handleAuthToken will call loadCurrentProfile
+      if (isInIframe && !hasTokens) {
+        authLogger.info('Running in iframe without tokens - waiting for parent to send via postMessage');
+        authLogger.info('AdminLayout will handle auth initialization, skipping AuthContext init');
+        setInitialized(true); // Mark as initialized to prevent re-initialization
+        setIsLoading(false);
+        return;
+      }
+
+      if (hasTokens) {
+        setIsLoading(true);
+        try {
+          authLogger.info('No cached profile found, loading from API...');
+          await loadCurrentProfile('AuthContext.initializeAuth');
+        } catch (error) {
+          authLogger.error('Failed to load profile during initialization:', error);
+          // If profile loading fails, clear auth state
+          clearAuthState('initializeAuth:loadProfileFailed');
+        }
+        setIsLoading(false);
+      } else {
+        setInitialized(true);
+        setIsLoading(false);
+      }
+    };
+
+    initializeAuth();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [initialized]);
+
+  // Redirect logic - only for unauthenticated users on protected pages
+  useEffect(() => {
+    if (!initialized) return;
+
+    // Consider authenticated if we have valid tokens, even without profile
+    const isAuthenticated = apiAccounts.isAuthenticated();
+    const authRoute = config?.routes?.auth || defaultRoutes.auth;
+    const isAuthPage = pathname === authRoute;
+    const flowParam = queryParams.get('flow');
+
+    // Only redirect authenticated users away from auth page if they're not in a flow
+    // This prevents interference with OTP verification flow
+    if (isAuthenticated && isAuthPage && !flowParam) {
+      const callbackUrl = config?.routes?.defaultCallback || defaultRoutes.defaultCallback;
+      router.push(callbackUrl);
+    }
+  }, [initialized, pathname, queryParams, config?.routes]);
+
+  const pushToDefaultCallbackUrl = useCallback(() => {
+    const callbackUrl = config?.routes?.defaultCallback || defaultRoutes.defaultCallback;
+    router.push(callbackUrl);
+  }, [config?.routes, router]);
+
+  const pushToDefaultAuthCallbackUrl = useCallback(() => {
+    const authCallbackUrl = config?.routes?.defaultAuthCallback || defaultRoutes.defaultAuthCallback;
+    router.push(authCallbackUrl);
+  }, [config?.routes, router]);
+
+  // Memoized checkAuthAndRedirect function
+  const checkAuthAndRedirect = useCallback(async () => {
+    try {
+      setIsLoading(true);
+      const isAuthenticated = apiAccounts.isAuthenticated();
+
+      if (isAuthenticated) {
+        await loadCurrentProfile();
+        if (userRef.current) {
+          pushToDefaultCallbackUrl();
+        }
+      } else {
+        pushToDefaultAuthCallbackUrl();
+      }
+    } catch (error) {
+      authLogger.error('Failed to check authentication:', error);
+      // Use global error handler first
+      if (!handleGlobalAuthError(error, 'checkAuthAndRedirect')) {
+        clearAuthState('checkAuthAndRedirect');
+      }
+      pushToDefaultAuthCallbackUrl();
+    } finally {
+      setIsLoading(false);
+    }
+  }, [loadCurrentProfile, clearAuthState, pushToDefaultCallbackUrl, pushToDefaultAuthCallbackUrl, handleGlobalAuthError]);
+
+  // OTP methods - supports both email and phone - now uses AccountsContext
+  const requestOTP = useCallback(
+    async (identifier: string, channel?: 'email' | 'phone', sourceUrl?: string): Promise<{ success: boolean; message: string }> => {
+      // Clear tokens before requesting OTP
+      apiAccounts.clearTokens();
+
+      try {
+        const channelValue = channel === 'phone' 
+          ? Enums.OTPRequestRequestChannel.PHONE 
+          : Enums.OTPRequestRequestChannel.EMAIL;
+        const result = await accounts.requestOTP({
+          identifier,
+          channel: channelValue,
+        });
+
+        const channelName = channel === 'phone' ? 'phone number' : 'email address';
+
+        // Track OTP request
+        Analytics.event(AnalyticsEvent.AUTH_OTP_REQUEST, {
+          category: AnalyticsCategory.AUTH,
+          label: channel || 'email',
+        });
+
+        return {
+          success: true,
+          message: result.message || `OTP code sent to your ${channelName}`,
+        };
+      } catch (error) {
+        authLogger.error('Request OTP error:', error);
+        return {
+          success: false,
+          message: 'Failed to send OTP',
+        };
+      }
+    },
+    [accounts],
+  );
+
+  const verifyOTP = useCallback(
+    async (identifier: string, otpCode: string, channel?: 'email' | 'phone', sourceUrl?: string): Promise<{ success: boolean; message: string; user?: UserProfile }> => {
+      try {
+        const channelValue = channel === 'phone' 
+          ? Enums.OTPVerifyRequestChannel.PHONE 
+          : Enums.OTPVerifyRequestChannel.EMAIL;
+        // AccountsContext automatically saves tokens and refreshes profile
+        const result = await accounts.verifyOTP({
+          identifier,
+          otp: otpCode,
+          channel: channelValue,
+        });
+
+        // Verify that we got valid tokens
+        if (!result.access || !result.refresh) {
+          authLogger.error('Verify OTP returned invalid response:', result);
+          return {
+            success: false,
+            message: 'Invalid OTP verification response',
+          };
+        }
+
+        // Save identifier based on channel and clear opposite channel
+        if (channel === 'phone') {
+          setStoredPhone(identifier);
+          clearStoredEmail();
+        } else if (identifier.includes('@')) {
+          setStoredEmail(identifier);
+          clearStoredPhone();
+        }
+
+        // Small delay to ensure profile state is updated
+        await new Promise(resolve => setTimeout(resolve, 200));
+
+        // Track successful login
+        Analytics.event(AnalyticsEvent.AUTH_LOGIN_SUCCESS, {
+          category: AnalyticsCategory.AUTH,
+          label: channel || 'email',
+        });
+
+        // Set user ID for future tracking
+        if (result.user?.id) {
+          Analytics.setUser(String(result.user.id));
+        }
+
+        // Handle redirect logic here
+        // Use hardPush for full page reload - ensures all React contexts reinitialize
+        const defaultCallback = config?.routes?.defaultCallback || defaultRoutes.defaultCallback;
+
+        if (redirectUrl && redirectUrl !== defaultCallback) {
+          clearRedirectUrl();
+          router.hardPush(redirectUrl);
+        } else {
+          router.hardPush(defaultCallback);
+        }
+
+        return {
+          success: true,
+          message: 'Login successful',
+          user: result.user as UserProfile,
+        };
+      } catch (error) {
+        authLogger.error('Verify OTP error:', error);
+
+        // Track failed verification
+        Analytics.event(AnalyticsEvent.AUTH_OTP_VERIFY_FAIL, {
+          category: AnalyticsCategory.AUTH,
+          label: channel || 'email',
+        });
+
+        return {
+          success: false,
+          message: 'Failed to verify OTP',
+        };
+      }
+    },
+    [setStoredEmail, setStoredPhone, clearStoredEmail, clearStoredPhone, redirectUrl, clearRedirectUrl, config?.routes?.defaultCallback, accounts],
+  );
+
+  const refreshToken = useCallback(async (): Promise<{ success: boolean; message: string }> => {
+    try {
+      const refreshTokenValue = apiAccounts.getRefreshToken();
+      if (!refreshTokenValue) {
+        clearAuthState('refreshToken:noToken');
+
+        // Track session expired
+        Analytics.event(AnalyticsEvent.AUTH_SESSION_EXPIRED, {
+          category: AnalyticsCategory.AUTH,
+        });
+
+        return {
+          success: false,
+          message: 'No refresh token available',
+        };
+      }
+
+      await accounts.refreshToken(refreshTokenValue);
+
+      // Track successful refresh
+      Analytics.event(AnalyticsEvent.AUTH_TOKEN_REFRESH, {
+        category: AnalyticsCategory.AUTH,
+      });
+
+      return {
+        success: true,
+        message: 'Token refreshed',
+      };
+    } catch (error) {
+      authLogger.error('Refresh token error:', error);
+      clearAuthState('refreshToken:error');
+
+      // Track refresh failure
+      Analytics.event(AnalyticsEvent.AUTH_TOKEN_REFRESH_FAIL, {
+        category: AnalyticsCategory.AUTH,
+      });
+
+      return {
+        success: false,
+        message: 'Error refreshing token',
+      };
+    }
+  }, [clearAuthState, accounts]);
+
+  const clearRedirect = useCallback((): void => {
+    clearRedirectUrl();
+  }, [clearRedirectUrl]);
+
+  // Save current URL for redirect after authentication
+  const saveCurrentUrlForRedirect = useCallback((): void => {
+    if (typeof window !== 'undefined') {
+      const currentUrl = window.location.pathname + window.location.search;
+      setRedirectUrl(currentUrl);
+    }
+  }, [setRedirectUrl]);
+
+  const logout = useCallback(async (): Promise<void> => {
+    const performLogout = () => {
+      // Track logout
+      Analytics.event(AnalyticsEvent.AUTH_LOGOUT, {
+        category: AnalyticsCategory.AUTH,
+      });
+
+      accounts.logout(); // Clear tokens and profile
+      setInitialized(true);
+      setIsLoading(false);
+
+      // Use hardReplace for full page reload + replace history
+      // This ensures contexts reinitialize AND back button won't return to protected page
+      const authCallbackUrl = config?.routes?.defaultAuthCallback || defaultRoutes.defaultAuthCallback;
+      router.hardReplace(authCallbackUrl);
+    };
+
+    // Use config.onConfirm if provided, otherwise use a simple confirm
+    if (configRef.current?.onConfirm) {
+      const { confirmed } = await configRef.current.onConfirm({
+        title: 'Logout',
+        description: 'Are you sure you want to logout?',
+        confirmationButtonText: 'Logout',
+        cancellationButtonText: 'Cancel',
+        color: 'error',
+      });
+      if (confirmed) {
+        performLogout();
+      }
+    } else {
+      // Fallback to browser confirm
+      const confirmed = window.confirm('Are you sure you want to logout?');
+      if (confirmed) {
+        performLogout();
+      }
+    }
+  }, [accounts, config?.routes?.defaultAuthCallback, router]);
+
+  // Redirect URL methods
+  const getSavedRedirectUrl = useCallback((): string | null => {
+    if (typeof window !== 'undefined') {
+      return sessionStorage.getItem(AUTH_REDIRECT_KEY);
+    }
+    return null;
+  }, []);
+
+  const saveRedirectUrl = useCallback((url: string): void => {
+    if (typeof window !== 'undefined') {
+      sessionStorage.setItem(AUTH_REDIRECT_KEY, url);
+    }
+  }, []);
+
+  const clearSavedRedirectUrl = useCallback((): void => {
+    if (typeof window !== 'undefined') {
+      sessionStorage.removeItem(AUTH_REDIRECT_KEY);
+    }
+  }, []);
+
+  const getFinalRedirectUrl = useCallback((): string => {
+    const savedUrl = getSavedRedirectUrl();
+    return savedUrl || (config?.routes?.defaultCallback || defaultRoutes.defaultCallback);
+  }, [getSavedRedirectUrl, config?.routes?.defaultCallback]);
+
+  const useAndClearRedirectUrl = useCallback((): string => {
+    const finalUrl = getFinalRedirectUrl();
+    clearSavedRedirectUrl();
+    return finalUrl;
+  }, [getFinalRedirectUrl, clearSavedRedirectUrl]);
+
+  // Computed: Is admin user (staff or superuser)
+  const isAdminUser = useMemo(() => {
+    return Boolean(user?.is_staff || user?.is_superuser);
+  }, [user]);
+
+  // Memoized context value
+  const value = useMemo<AuthContextType>(
+    () => ({
+      user,
+      isLoading,
+      // Consider authenticated if we have valid tokens, even without user profile
+      isAuthenticated: apiAccounts.isAuthenticated(),
+      isAdminUser,
+      loadCurrentProfile,
+      checkAuthAndRedirect,
+      getToken: () => apiAccounts.getToken(),
+      getRefreshToken: () => apiAccounts.getRefreshToken(),
+      getSavedEmail: () => storedEmail,
+      saveEmail: setStoredEmail,
+      clearSavedEmail: clearStoredEmail,
+      getSavedPhone: () => storedPhone,
+      savePhone: setStoredPhone,
+      clearSavedPhone: clearStoredPhone,
+      requestOTP,
+      verifyOTP,
+      refreshToken,
+      logout,
+      getSavedRedirectUrl,
+      saveRedirectUrl,
+      clearSavedRedirectUrl,
+      getFinalRedirectUrl,
+      useAndClearRedirectUrl,
+      saveCurrentUrlForRedirect,
+    }),
+    [
+      user,
+      isLoading,
+      isAdminUser,
+      loadCurrentProfile,
+      checkAuthAndRedirect,
+      storedEmail,
+      setStoredEmail,
+      clearStoredEmail,
+      storedPhone,
+      setStoredPhone,
+      clearStoredPhone,
+      requestOTP,
+      verifyOTP,
+      refreshToken,
+      logout,
+      getSavedRedirectUrl,
+      saveRedirectUrl,
+      clearSavedRedirectUrl,
+      getFinalRedirectUrl,
+      useAndClearRedirectUrl,
+      saveCurrentUrlForRedirect,
+    ],
+  );
+
+  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
+};
+
+// Wrapper that provides AccountsContext
+export const AuthProvider: React.FC<AuthProviderProps> = ({ children, config }) => {
+  return (
+    <AccountsProvider>
+      <AuthProviderInternal config={config}>
+        {children}
+      </AuthProviderInternal>
+    </AccountsProvider>
+  );
+};
+
+export const useAuth = (): AuthContextType => {
+  const context = useContext(AuthContext);
+  if (context === undefined) {
+    throw new Error('useAuth must be used within an AuthProvider');
+  }
+  return context;
+};
+
+export default AuthContext; 

package/src/auth/context/index.ts

@@ -0,0 +1,4 @@
+export { AuthProvider, useAuth } from './AuthContext';
+export type { AuthConfig, AuthContextType, AuthProviderProps, UserProfile } from './types';
+export { AccountsProvider, useAccountsContext, PatchedUserProfileUpdateRequestSchema } from './AccountsContext';
+export type { AccountsContextValue, PatchedUserProfileUpdateRequest } from './AccountsContext'; 

package/src/auth/context/types.ts

@@ -0,0 +1,68 @@
+import React from 'react';
+
+import type { User } from '../../';
+
+// User profile type
+export type UserProfile = User;
+
+// Auth configuration
+export interface AuthConfig {
+  apiUrl?: string;
+  routes?: {
+    auth?: string;
+    defaultCallback?: string;
+    defaultAuthCallback?: string;
+  };
+  onLogout?: () => void;
+  onConfirm?: (options: {
+    title: string;
+    description: string;
+    confirmationButtonText: string;
+    cancellationButtonText: string;
+    color: string;
+  }) => Promise<{ confirmed: boolean }>;
+}
+
+// Auth context interface
+export interface AuthContextType {
+  user: UserProfile | null;
+  isLoading: boolean;
+  isAuthenticated: boolean;
+  isAdminUser: boolean;
+  loadCurrentProfile: (callerId?: string) => Promise<void>;
+  checkAuthAndRedirect: () => Promise<void>;
+
+  // Token Methods
+  getToken: () => string | null;
+  getRefreshToken: () => string | null;
+
+  // Email Methods
+  getSavedEmail: () => string | null;
+  saveEmail: (email: string) => void;
+  clearSavedEmail: () => void;
+
+  // Phone Methods
+  getSavedPhone: () => string | null;
+  savePhone: (phone: string) => void;
+  clearSavedPhone: () => void;
+
+  // OTP Methods - Multi-channel support
+  requestOTP: (identifier: string, channel?: 'email' | 'phone', sourceUrl?: string) => Promise<{ success: boolean; message: string }>;
+  verifyOTP: (identifier: string, otpCode: string, channel?: 'email' | 'phone', sourceUrl?: string) => Promise<{ success: boolean; message: string; user?: UserProfile }>;
+  refreshToken: () => Promise<{ success: boolean; message: string }>;
+  logout: () => Promise<void>;
+
+  // Redirect Methods
+  getSavedRedirectUrl: () => string | null;
+  saveRedirectUrl: (url: string) => void;
+  clearSavedRedirectUrl: () => void;
+  getFinalRedirectUrl: () => string;
+  useAndClearRedirectUrl: () => string;
+  saveCurrentUrlForRedirect: () => void;
+}
+
+// Provider props
+export interface AuthProviderProps {
+  children: React.ReactNode;
+  config?: AuthConfig;
+} 

package/src/auth/hooks/index.ts

@@ -0,0 +1,17 @@
+'use client';
+
+export { useAuthRedirectManager } from './useAuthRedirect';
+export { useAuthGuard } from './useAuthGuard';
+export { useSessionStorage } from './useSessionStorage';
+export { useLocalStorage } from './useLocalStorage';
+export { useAuthForm } from './useAuthForm';
+export { useAutoAuth } from './useAutoAuth';
+export { useGithubAuth, type UseGithubAuthOptions, type UseGithubAuthReturn } from './useGithubAuth';
+export {
+  getCachedProfile,
+  setCachedProfile,
+  clearProfileCache,
+  hasValidCache,
+  getCacheMetadata,
+  type ProfileCacheOptions
+} from './useProfileCache';