@oxyhq/services 5.5.5 → 5.5.7

package/src/ui/hooks/useAuthFetch.ts

@@ -1,33 +1,23 @@
 /**
- * Zero Config Authenticated Fetch Hook
+ * Simplified Authenticated Fetch Hook
  * 
- * Simple hook that provides fetch-like API with automatic authentication
- * Leverages the existing useOxy hook and OxyProvider infrastructure
- * 
- * Usage:
- *   const authFetch = useAuthFetch();
- *   const response = await authFetch('/api/protected');
- *   const data = await authFetch.get('/api/users');
+ * Clean, professional hook that uses the centralized AuthManager
+ * No more duplicate authentication logic or race conditions
  */
 
 import { useCallback } from 'react';
 import { useOxy } from '../context/OxyContext';
 
 export interface AuthFetchOptions extends Omit<RequestInit, 'body'> {
-  body?: any; // Allow any type for body, we'll JSON.stringify if needed
+  body?: any;
 }
 
 export interface AuthFetchAPI {
-  // Main fetch function (drop-in replacement)
   (input: RequestInfo | URL, init?: AuthFetchOptions): Promise<Response>;
-  
-  // Convenience methods for JSON APIs
   get: (endpoint: string, options?: AuthFetchOptions) => Promise<any>;
   post: (endpoint: string, data?: any, options?: AuthFetchOptions) => Promise<any>;
   put: (endpoint: string, data?: any, options?: AuthFetchOptions) => Promise<any>;
   delete: (endpoint: string, options?: AuthFetchOptions) => Promise<any>;
-  
-  // Access to auth state and methods
   isAuthenticated: boolean;
   user: any;
   login: (username: string, password: string) => Promise<any>;
@@ -37,39 +27,41 @@ export interface AuthFetchAPI {
 
 /**
  * Hook that provides authenticated fetch functionality
- * Uses the existing OxyServices instance from useOxy context
+ * Uses the centralized AuthManager for all authentication operations
  */
 export function useAuthFetch(): AuthFetchAPI {
-  const { oxyServices, isAuthenticated, user, login, logout, signUp, activeSessionId } = useOxy();
+  const { authManager, isAuthenticated, user, login, logout, signUp } = useOxy();
+  
+  console.log('[useAuthFetch] Hook initialized');
+  console.log('[useAuthFetch] authManager:', !!authManager);
+  console.log('[useAuthFetch] isAuthenticated:', isAuthenticated);
+  console.log('[useAuthFetch] user:', !!user);
 
-  // Main fetch function with automatic auth headers
   const authFetch = useCallback(async (input: RequestInfo | URL, init?: AuthFetchOptions): Promise<Response> => {
-    const url = resolveURL(input, oxyServices.getBaseURL());
-    const options = await addAuthHeaders(init, oxyServices, activeSessionId || undefined, isAuthenticated);
+    const url = resolveURL(input, authManager.getBaseURL());
+    const options = await addAuthHeaders(init, authManager);
 
     try {
       let response = await fetch(url, options);
 
       // Handle token expiry and automatic refresh
       if (response.status === 401 && isAuthenticated) {
-        // Try to refresh token and retry
         try {
-          await oxyServices.refreshTokens();
-          const retryOptions = await addAuthHeaders(init, oxyServices, activeSessionId || undefined, isAuthenticated);
+          await authManager.refreshToken();
+          const retryOptions = await addAuthHeaders(init, authManager);
           response = await fetch(url, retryOptions);
         } catch (refreshError) {
-          // Refresh failed, user needs to login again
-          console.warn('Token refresh failed, user needs to re-authenticate');
+          console.warn('[AuthFetch] Token refresh failed:', refreshError);
           throw new Error('Authentication expired. Please login again.');
         }
       }
 
       return response;
     } catch (error) {
-      console.error('AuthFetch error:', error);
+      console.error('[AuthFetch] Request failed:', error);
       throw error;
     }
-  }, [oxyServices, activeSessionId, isAuthenticated]);
+  }, [authManager, isAuthenticated]);
 
   // JSON convenience methods
   const get = useCallback(async (endpoint: string, options?: AuthFetchOptions) => {
@@ -108,7 +100,7 @@ export function useAuthFetch(): AuthFetchAPI {
     return handleJsonResponse(response);
   }, [authFetch]);
 
-  // Attach convenience methods and auth state to the main function
+  // Attach convenience methods and auth state
   const fetchWithMethods = authFetch as AuthFetchAPI;
   fetchWithMethods.get = get;
   fetchWithMethods.post = post;
@@ -124,62 +116,53 @@ export function useAuthFetch(): AuthFetchAPI {
 }
 
 /**
- * Helper functions
+ * Helper functions - much simpler now
  */
 
 function resolveURL(input: RequestInfo | URL, baseURL: string): string {
   const url = input.toString();
   
-  // If it's already a full URL, return as is
   if (url.startsWith('http://') || url.startsWith('https://')) {
     return url;
   }
   
-  // If it starts with /, it's relative to base URL
   if (url.startsWith('/')) {
     return `${baseURL}${url}`;
   }
   
-  // Otherwise, append to base URL with /
   return `${baseURL}/${url}`;
 }
 
-async function addAuthHeaders(init?: AuthFetchOptions, oxyServices?: any, activeSessionId?: string, isAuthenticated?: boolean): Promise<RequestInit> {
+async function addAuthHeaders(init?: AuthFetchOptions, authManager?: any): Promise<RequestInit> {
   const headers = new Headers(init?.headers);
   
-  // Debug logging
-  console.log('[Auth API Debug] isAuthenticated:', isAuthenticated, 'activeSessionId:', activeSessionId, 'oxyServices:', !!oxyServices);
+  console.log('[AuthFetch] addAuthHeaders called');
+  console.log('[AuthFetch] Has authManager:', !!authManager);
+  console.log('[AuthFetch] AuthManager type:', typeof authManager);
+  console.log('[AuthFetch] Has Authorization header already:', headers.has('Authorization'));
   
-  // Add auth header if user is authenticated (use context state instead of getCurrentUserId)
-  if (isAuthenticated && oxyServices && !headers.has('Authorization')) {
+  if (authManager && !headers.has('Authorization')) {
     try {
-      // First try to get regular JWT access token
-      let accessToken = oxyServices.getAccessToken?.();
-      console.log('[Auth API Debug] JWT accessToken from getAccessToken():', !!accessToken);
+      console.log('[AuthFetch] AuthManager.isAuthenticated():', authManager.isAuthenticated());
       
-      // If no JWT token but we have a secure session, try to get token from session
-      if (!accessToken && activeSessionId) {
-        console.log('[Auth API] No JWT token, trying to get token from secure session:', activeSessionId);
-        try {
-          const tokenData = await oxyServices.getTokenBySession(activeSessionId);
-          accessToken = tokenData.accessToken;
-          console.log('[Auth API] Got token from session successfully');
-        } catch (error) {
-          console.warn('[Auth API] Failed to get token from session:', error);
-        }
-      }
+      const accessToken = await authManager.getAccessToken();
+      console.log('[AuthFetch] Got access token:', !!accessToken);
       
       if (accessToken) {
         headers.set('Authorization', `Bearer ${accessToken}`);
-        console.log('[Auth API] Added Authorization header successfully');
+        console.log('[AuthFetch] Added Authorization header successfully');
+      } else if (authManager.isAuthenticated()) {
+        console.error('[AuthFetch] User is authenticated but no token available');
+        throw new Error('Authentication state inconsistent. Please login again.');
       } else {
-        console.warn('[Auth API] No authentication token available - JWT token:', !!oxyServices.getAccessToken?.(), 'activeSessionId:', activeSessionId);
+        console.log('[AuthFetch] User not authenticated, skipping auth header');
       }
     } catch (error) {
-      console.error('[Auth API] Error getting access token:', error);
+      console.error('[AuthFetch] Failed to get access token:', error);
+      throw error;
     }
   } else {
-    console.warn('[Auth API] Cannot authenticate - isAuthenticated:', isAuthenticated, 'oxyServices:', !!oxyServices, 'hasAuthHeader:', headers.has('Authorization'));
+    console.log('[AuthFetch] Skipping auth header - authManager:', !!authManager, 'hasAuthHeader:', headers.has('Authorization'));
   }
 
   const body = init?.body;
@@ -214,7 +197,6 @@ async function handleJsonResponse(response: Response): Promise<any> {
   try {
     return await response.json();
   } catch {
-    // If response isn't JSON, return the response itself
     return response;
   }
 }

package/src/ui/screens/SessionManagementScreen.tsx

@@ -82,10 +82,10 @@ const SessionManagementScreen: React.FC<BaseScreenProps> = ({
                         try {
                             setActionLoading(sessionId);
                             await logout(sessionId);
-                            
+
                             // Refresh sessions to update the list
                             await refreshSessions();
-                            
+
                             toast.success('Session logged out successfully');
                         } catch (error) {
                             console.error('Logout session failed:', error);
@@ -100,8 +100,8 @@ const SessionManagementScreen: React.FC<BaseScreenProps> = ({
     };
 
     const handleLogoutOtherSessions = async () => {
-        const otherSessionsCount = userSessions.filter(s => s.sessionId !== activeSessionId).length;
-        
+        const otherSessionsCount = userSessions.filter((s: any) => s.sessionId !== activeSessionId).length;
+
         if (otherSessionsCount === 0) {
             toast.info('No other sessions to logout.');
             return;
@@ -124,10 +124,10 @@ const SessionManagementScreen: React.FC<BaseScreenProps> = ({
                                     await logout(session.sessionId);
                                 }
                             }
-                            
+
                             // Refresh sessions to update the list
                             await refreshSessions();
-                            
+
                             toast.success('Other sessions logged out successfully');
                         } catch (error) {
                             console.error('Logout other sessions failed:', error);
@@ -175,7 +175,7 @@ const SessionManagementScreen: React.FC<BaseScreenProps> = ({
         if (diffInMinutes < 60) return `${diffInMinutes}m ago`;
         if (diffInMinutes < 1440) return `${Math.floor(diffInMinutes / 60)}h ago`;
         if (diffInMinutes < 10080) return `${Math.floor(diffInMinutes / 1440)}d ago`;
-        
+
         return date.toLocaleDateString();
     };
 
@@ -230,7 +230,7 @@ const SessionManagementScreen: React.FC<BaseScreenProps> = ({
             >
                 {userSessions.length > 0 ? (
                     <>
-                        {userSessions.map((session) => (
+                        {userSessions.map((session: any) => (
                             <View
                                 key={session.sessionId}
                                 style={[
@@ -294,7 +294,7 @@ const SessionManagementScreen: React.FC<BaseScreenProps> = ({
                             <TouchableOpacity
                                 style={[styles.bulkActionButton, { backgroundColor: isDarkTheme ? '#1A1A1A' : '#F0F0F0', borderColor }]}
                                 onPress={handleLogoutOtherSessions}
-                                disabled={actionLoading === 'others' || userSessions.filter(s => s.sessionId !== activeSessionId).length === 0}
+                                disabled={actionLoading === 'others' || userSessions.filter((s: any) => s.sessionId !== activeSessionId).length === 0}
                             >
                                 {actionLoading === 'others' ? (
                                     <ActivityIndicator size="small" color={primaryColor} />