@oxyhq/services 5.5.8 → 5.5.9

package/src/__tests__/ui/hooks/url-resolution.test.ts

@@ -0,0 +1,129 @@
+/**
+ * Tests for URL resolution in separated authFetch implementation
+ */
+
+describe('URL Resolution Separation', () => {
+  describe('resolveURL function behavior', () => {
+    // Mock implementation of resolveURL logic used in useAuthFetch
+    function resolveURL(input: RequestInfo | URL, baseURL: string): string {
+      if (!baseURL) {
+        throw new Error('Base URL not configured. Please provide a baseURL in OxyServices configuration.');
+      }
+
+      const url = input.toString();
+      
+      // If it's already a full URL (http/https), return as is
+      if (url.startsWith('http://') || url.startsWith('https://')) {
+        return url;
+      }
+      
+      // Normalize base URL (remove trailing slash)
+      const normalizedBaseURL = baseURL.replace(/\/$/, '');
+      
+      // If URL starts with /, it's relative to base URL
+      if (url.startsWith('/')) {
+        return `${normalizedBaseURL}${url}`;
+      }
+      
+      // Otherwise, append to base URL with /
+      return `${normalizedBaseURL}/${url}`;
+    }
+
+    test('should resolve relative URLs with app base URL', () => {
+      const appBaseURL = 'https://myapp.example.com';
+      
+      expect(resolveURL('/api/users', appBaseURL)).toBe('https://myapp.example.com/api/users');
+      expect(resolveURL('api/users', appBaseURL)).toBe('https://myapp.example.com/api/users');
+      expect(resolveURL('/api/posts', appBaseURL)).toBe('https://myapp.example.com/api/posts');
+    });
+
+    test('should preserve absolute URLs unchanged', () => {
+      const appBaseURL = 'https://myapp.example.com';
+      const absoluteURL = 'https://external-api.example.com/data';
+      
+      expect(resolveURL(absoluteURL, appBaseURL)).toBe(absoluteURL);
+    });
+
+    test('should handle different app base URLs independently', () => {
+      const appBaseURL1 = 'https://app1.example.com';
+      const appBaseURL2 = 'https://app2.example.com';
+      const oxyBaseURL = 'https://api.oxy.so';
+      
+      // Same endpoint, different base URLs
+      expect(resolveURL('/api/users', appBaseURL1)).toBe('https://app1.example.com/api/users');
+      expect(resolveURL('/api/users', appBaseURL2)).toBe('https://app2.example.com/api/users');
+      expect(resolveURL('/api/users', oxyBaseURL)).toBe('https://api.oxy.so/api/users');
+    });
+
+    test('should normalize base URLs correctly', () => {
+      const baseURLWithSlash = 'https://myapp.example.com/';
+      const baseURLWithoutSlash = 'https://myapp.example.com';
+      
+      expect(resolveURL('/api/users', baseURLWithSlash)).toBe('https://myapp.example.com/api/users');
+      expect(resolveURL('/api/users', baseURLWithoutSlash)).toBe('https://myapp.example.com/api/users');
+    });
+
+    test('should throw error for missing base URL', () => {
+      expect(() => resolveURL('/api/users', '')).toThrow('Base URL not configured');
+    });
+  });
+
+  describe('Separation scenarios', () => {
+    test('should demonstrate independent URL management', () => {
+      // Simulate the separation: internal vs public URLs
+      const internalOxyURL = 'https://api.oxy.so';
+      const publicAppURL = 'https://mention.earth/api';
+      
+      // Internal module calls (would use OxyServices base URL)
+      const internalCall = resolveURL('/auth/validate', internalOxyURL);
+      expect(internalCall).toBe('https://api.oxy.so/auth/validate');
+      
+      // Public authFetch calls (would use app base URL)
+      const publicCall = resolveURL('/api/mentions', publicAppURL);
+      expect(publicCall).toBe('https://mention.earth/api/api/mentions');
+    });
+
+    test('should support dynamic app URL changes', () => {
+      // Simulate changing app URL without affecting internal URL
+      let appBaseURL = 'https://staging.myapp.com';
+      const oxyBaseURL = 'https://api.oxy.so';
+      
+      // Initial state
+      expect(resolveURL('/api/data', appBaseURL)).toBe('https://staging.myapp.com/api/data');
+      expect(resolveURL('/auth/me', oxyBaseURL)).toBe('https://api.oxy.so/auth/me');
+      
+      // App changes its URL
+      appBaseURL = 'https://production.myapp.com';
+      
+      // App URLs updated
+      expect(resolveURL('/api/data', appBaseURL)).toBe('https://production.myapp.com/api/data');
+      // Internal URLs unchanged
+      expect(resolveURL('/auth/me', oxyBaseURL)).toBe('https://api.oxy.so/auth/me');
+    });
+  });
+
+  // Helper function to mimic resolveURL from the actual implementation
+  function resolveURL(input: RequestInfo | URL, baseURL: string): string {
+    if (!baseURL) {
+      throw new Error('Base URL not configured. Please provide a baseURL in OxyServices configuration.');
+    }
+
+    const url = input.toString();
+    
+    // If it's already a full URL (http/https), return as is
+    if (url.startsWith('http://') || url.startsWith('https://')) {
+      return url;
+    }
+    
+    // Normalize base URL (remove trailing slash)
+    const normalizedBaseURL = baseURL.replace(/\/$/, '');
+    
+    // If URL starts with /, it's relative to base URL
+    if (url.startsWith('/')) {
+      return `${normalizedBaseURL}${url}`;
+    }
+    
+    // Otherwise, append to base URL with /
+    return `${normalizedBaseURL}/${url}`;
+  }
+});

package/src/__tests__/ui/hooks/useAuthFetch-separation.test.ts

@@ -0,0 +1,69 @@
+/**
+ * Tests for authFetch separation between public and internal usage
+ */
+
+import { OxyServices } from '../../../core';
+
+describe('AuthFetch Separation', () => {
+  let oxyServices: OxyServices;
+
+  beforeEach(() => {
+    oxyServices = new OxyServices({
+      baseURL: 'https://api.oxy.so'
+    });
+  });
+
+  describe('OxyServices internal base URL isolation', () => {
+    test('should preserve original base URL for internal calls', () => {
+      const originalBaseURL = 'https://api.oxy.so';
+      
+      // Verify initial state
+      expect(oxyServices.getBaseURL()).toBe(originalBaseURL);
+      
+      // Simulate app changing its own base URL (this should not affect OxyServices)
+      // Note: In the new implementation, setApiUrl only affects app authFetch, not OxyServices
+      const appBaseURL = 'https://app-api.example.com';
+      
+      // OxyServices base URL should remain unchanged
+      expect(oxyServices.getBaseURL()).toBe(originalBaseURL);
+    });
+
+    test('should handle OxyServices base URL changes separately', () => {
+      const originalBaseURL = 'https://api.oxy.so';
+      const newOxyBaseURL = 'https://new-oxy-api.example.com';
+      
+      expect(oxyServices.getBaseURL()).toBe(originalBaseURL);
+      
+      // This should still work for internal module updates
+      oxyServices.setBaseURL(newOxyBaseURL);
+      expect(oxyServices.getBaseURL()).toBe(newOxyBaseURL);
+    });
+
+    test('should maintain separation - internal vs public URLs', () => {
+      const oxyBaseURL = 'https://api.oxy.so';
+      const appBaseURL = 'https://myapp.example.com';
+      
+      // OxyServices keeps its own URL for internal calls
+      expect(oxyServices.getBaseURL()).toBe(oxyBaseURL);
+      
+      // App can have its own URL (this would be managed in context)
+      // The separation ensures these don't interfere with each other
+      expect(oxyBaseURL).not.toBe(appBaseURL);
+    });
+  });
+
+  describe('URL validation and error handling', () => {
+    test('should validate URLs properly', () => {
+      expect(() => oxyServices.setBaseURL('')).toThrow('Base URL cannot be empty');
+      expect(() => oxyServices.setBaseURL('not-a-url')).not.toThrow(); // axios will handle invalid URLs
+    });
+
+    test('should handle URL normalization', () => {
+      oxyServices.setBaseURL('https://api.example.com/');
+      expect(oxyServices.getBaseURL()).toBe('https://api.example.com/');
+      
+      oxyServices.setBaseURL('https://api.example.com');
+      expect(oxyServices.getBaseURL()).toBe('https://api.example.com');
+    });
+  });
+});

package/src/ui/context/OxyContext.tsx

@@ -37,6 +37,7 @@ export interface OxyContextState {
 
   // API configuration
   setApiUrl: (url: string) => void;
+  getAppBaseURL: () => string;
 
   // Methods to directly control the bottom sheet
   showBottomSheet?: (screenOrConfig?: string | { screen: string; props?: Record<string, any> }) => void;
@@ -129,6 +130,7 @@ export const OxyContextProvider: React.FC<OxyContextProviderProps> = ({
   const [isLoading, setIsLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
   const [storage, setStorage] = useState<StorageInterface | null>(null);
+  const [appBaseURL, setAppBaseURL] = useState<string>(oxyServices.getBaseURL());
 
   // Storage keys (memoized to prevent infinite loops)
   const keys = useMemo(() => getSecureStorageKeys(storageKeyPrefix), [storageKeyPrefix]);
@@ -646,12 +648,23 @@ export const OxyContextProvider: React.FC<OxyContextProviderProps> = ({
   // API URL configuration
   const setApiUrl = useCallback((url: string) => {
     try {
-      oxyServices.setBaseURL(url);
+      // Validate URL
+      if (!url) {
+        throw new Error('Base URL cannot be empty');
+      }
+      // Only update the app-specific base URL, not the OxyServices base URL
+      // This ensures internal module calls to Oxy API remain unaffected
+      setAppBaseURL(url);
     } catch (error) {
       console.error('Failed to update API URL:', error);
       setError(`Failed to update API URL: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
-  }, [oxyServices]);
+  }, []);
+
+  // Get current app base URL
+  const getAppBaseURL = useCallback(() => {
+    return appBaseURL;
+  }, [appBaseURL]);
 
   // Compute comprehensive authentication status
   // This is the single source of truth for authentication across the entire app
@@ -684,6 +697,7 @@ export const OxyContextProvider: React.FC<OxyContextProviderProps> = ({
     updateDeviceName,
     oxyServices,
     setApiUrl,
+    getAppBaseURL,
     bottomSheetRef,
     showBottomSheet,
     hideBottomSheet,

package/src/ui/hooks/useAuthFetch.ts

@@ -43,7 +43,7 @@ export interface AuthFetchAPI {
  * Uses the existing OxyServices instance from useOxy context
  */
 export function useAuthFetch(): AuthFetchAPI {
-  const { oxyServices, isAuthenticated, user, login, logout, signUp, activeSessionId, setApiUrl } = useOxy();
+  const { oxyServices, isAuthenticated, user, login, logout, signUp, activeSessionId, setApiUrl, getAppBaseURL } = useOxy();
 
   // Validate that we have the required dependencies
   if (!oxyServices) {
@@ -56,7 +56,7 @@ export function useAuthFetch(): AuthFetchAPI {
       throw new Error('OxyServices not initialized. Make sure to wrap your app in OxyProvider.');
     }
 
-    const url = resolveURL(input, oxyServices.getBaseURL());
+    const url = resolveURL(input, getAppBaseURL());
     const options = await addAuthHeaders(init, oxyServices, activeSessionId || undefined, isAuthenticated);
 
     try {
@@ -88,7 +88,7 @@ export function useAuthFetch(): AuthFetchAPI {
       }
       throw new Error('Request failed');
     }
-  }, [oxyServices, activeSessionId, isAuthenticated]);
+  }, [oxyServices, activeSessionId, isAuthenticated, getAppBaseURL]);
 
   // JSON convenience methods
   const get = useCallback(async (endpoint: string, options?: AuthFetchOptions) => {