@oxyhq/services 5.5.9 → 5.6.0

package/src/__tests__/backend-middleware.test.ts

@@ -1,209 +0,0 @@
-/**
- * Integration test for refactored authentication system
- * Tests the backend middleware functionality
- */
-
-import { OxyServices } from '../../core';
-
-describe('Authentication System Integration', () => {
-  let oxyServices: OxyServices;
-  let mockReq: any;
-  let mockRes: any;
-  let mockNext: any;
-
-  beforeEach(() => {
-    oxyServices = new OxyServices({
-      baseURL: 'https://api.test.com'
-    });
-
-    // Mock Express request/response objects
-    mockReq = {
-      headers: {},
-      user: undefined,
-      userId: undefined,
-      accessToken: undefined
-    };
-
-    mockRes = {
-      status: jest.fn().mockReturnThis(),
-      json: jest.fn().mockReturnThis()
-    };
-
-    mockNext = jest.fn();
-  });
-
-  describe('Middleware Creation', () => {
-    test('should create authentication middleware', () => {
-      const middleware = oxyServices.createAuthenticateTokenMiddleware();
-      expect(typeof middleware).toBe('function');
-      expect(middleware.length).toBe(3); // req, res, next
-    });
-
-    test('should create middleware with custom options', () => {
-      const customErrorHandler = jest.fn();
-      const middleware = oxyServices.createAuthenticateTokenMiddleware({
-        loadFullUser: false,
-        onError: customErrorHandler
-      });
-      
-      expect(typeof middleware).toBe('function');
-    });
-  });
-
-  describe('Token Validation', () => {
-    test('should handle missing token', async () => {
-      const middleware = oxyServices.createAuthenticateTokenMiddleware();
-      
-      await middleware(mockReq, mockRes, mockNext);
-      
-      expect(mockRes.status).toHaveBeenCalledWith(401);
-      expect(mockRes.json).toHaveBeenCalledWith({
-        message: 'Access token required',
-        code: 'MISSING_TOKEN'
-      });
-      expect(mockNext).not.toHaveBeenCalled();
-    });
-
-    test('should handle invalid token format', async () => {
-      mockReq.headers.authorization = 'InvalidFormat token123';
-      
-      const middleware = oxyServices.createAuthenticateTokenMiddleware();
-      await middleware(mockReq, mockRes, mockNext);
-      
-      expect(mockRes.status).toHaveBeenCalledWith(401);
-      expect(mockNext).not.toHaveBeenCalled();
-    });
-
-    test('should extract token from Bearer header', async () => {
-      mockReq.headers.authorization = 'Bearer valid.jwt.token';
-      
-      const middleware = oxyServices.createAuthenticateTokenMiddleware();
-      await middleware(mockReq, mockRes, mockNext);
-      
-      // Note: This will fail validation since it's not a real token,
-      // but we can verify the token was extracted
-      expect(mockRes.status).toHaveBeenCalled();
-    });
-  });
-
-  describe('Standalone Token Validation', () => {
-    test('should validate empty token', async () => {
-      const result = await oxyServices.authenticateToken('');
-      
-      expect(result.valid).toBe(false);
-      expect(result.error).toBe('Token is required');
-      expect(result.userId).toBeUndefined();
-      expect(result.user).toBeUndefined();
-    });
-
-    test('should validate invalid token', async () => {
-      const result = await oxyServices.authenticateToken('invalid.jwt.token');
-      
-      expect(result.valid).toBe(false);
-      expect(result.error).toBeTruthy();
-      expect(result.userId).toBeUndefined();
-      expect(result.user).toBeUndefined();
-    });
-
-    test('should handle validation errors gracefully', async () => {
-      const result = await oxyServices.authenticateToken('malformed-token');
-      
-      expect(result.valid).toBe(false);
-      expect(result.error).toMatch(/validation failed|Invalid/i);
-    });
-  });
-
-  describe('Custom Error Handling', () => {
-    test('should use custom error handler when provided', async () => {
-      const customErrorHandler = jest.fn();
-      const middleware = oxyServices.createAuthenticateTokenMiddleware({
-        onError: customErrorHandler
-      });
-      
-      await middleware(mockReq, mockRes, mockNext);
-      
-      expect(customErrorHandler).toHaveBeenCalledWith({
-        message: 'Access token required',
-        code: 'MISSING_TOKEN',
-        status: 401
-      });
-      expect(mockRes.status).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('Backend Integration Example', () => {
-    test('should work with Express.js route patterns', () => {
-      // Simulate Express.js app setup
-      const mockApp = {
-        get: jest.fn(),
-        post: jest.fn(),
-        use: jest.fn()
-      };
-
-      // Create middleware
-      const authenticateToken = oxyServices.createAuthenticateTokenMiddleware({
-        loadFullUser: true
-      });
-
-      // Simulate route registration
-      mockApp.get('/api/protected', authenticateToken, (req: any, res: any) => {
-        res.json({ 
-          message: 'Access granted',
-          user: req.user,
-          userId: req.userId 
-        });
-      });
-
-      expect(mockApp.get).toHaveBeenCalledWith(
-        '/api/protected',
-        authenticateToken,
-        expect.any(Function)
-      );
-    });
-
-    test('should provide consistent interface for different auth patterns', () => {
-      // Pattern 1: Middleware
-      const middleware = oxyServices.createAuthenticateTokenMiddleware();
-      expect(typeof middleware).toBe('function');
-
-      // Pattern 2: Standalone validation
-      const validateToken = oxyServices.authenticateToken.bind(oxyServices);
-      expect(typeof validateToken).toBe('function');
-
-      // Pattern 3: Direct service methods
-      expect(typeof oxyServices.getAccessToken).toBe('function');
-      expect(typeof oxyServices.setTokens).toBe('function');
-      expect(typeof oxyServices.clearTokens).toBe('function');
-    });
-  });
-
-  describe('Zero-Config Setup Verification', () => {
-    test('should work with minimal configuration', () => {
-      // This simulates the zero-config setup promise
-      const minimalSetup = () => {
-        // Backend: Just create OxyServices and use middleware
-        const services = new OxyServices({ baseURL: 'https://api.example.com' });
-        const authMiddleware = services.createAuthenticateTokenMiddleware();
-        
-        return { services, authMiddleware };
-      };
-
-      const { services, authMiddleware } = minimalSetup();
-      
-      expect(services).toBeInstanceOf(OxyServices);
-      expect(typeof authMiddleware).toBe('function');
-      expect(services.getBaseURL()).toBe('https://api.example.com');
-    });
-
-    test('should support runtime configuration changes', () => {
-      const services = new OxyServices({ baseURL: 'https://dev-api.com' });
-      
-      expect(services.getBaseURL()).toBe('https://dev-api.com');
-      
-      // Simulate runtime change to production
-      services.setBaseURL('https://prod-api.com');
-      
-      expect(services.getBaseURL()).toBe('https://prod-api.com');
-    });
-  });
-});

package/src/__tests__/polyfills.test.ts

@@ -1,30 +0,0 @@
-/**
- * Test file to verify FormData polyfill functionality
- */
-
-import { getFormDataConstructor } from '../utils/polyfills';
-
-describe('FormData Polyfill Tests', () => {
-  it('should provide FormData constructor', () => {
-    const FormDataConstructor = getFormDataConstructor();
-    expect(FormDataConstructor).toBeDefined();
-    expect(typeof FormDataConstructor).toBe('function');
-  });
-
-  it('should create FormData instance successfully', () => {
-    const FormDataConstructor = getFormDataConstructor();
-    const formData = new FormDataConstructor();
-    expect(formData).toBeDefined();
-    expect(typeof formData.append).toBe('function');
-  });
-
-  it('should handle form data append operations', () => {
-    const FormDataConstructor = getFormDataConstructor();
-    const formData = new FormDataConstructor();
-    
-    // Should not throw
-    expect(() => {
-      formData.append('test', 'value');
-    }).not.toThrow();
-  });
-});

package/src/__tests__/setup.ts

@@ -1,43 +0,0 @@
-import '@testing-library/jest-dom';
-
-// Mock React Native APIs
-global.jest = require('jest');
-
-// Mock Dimensions
-jest.mock('react-native', () => {
-  const RN = jest.requireActual('react-native');
-  return {
-    ...RN,
-    Dimensions: {
-      get: jest.fn().mockReturnValue({ width: 375, height: 800 }),
-    },
-    Platform: {
-      OS: 'web',
-      select: (options: any) => options.web || options.default,
-    },
-  };
-});
-
-// Mock AsyncStorage
-jest.mock('@react-native-async-storage/async-storage', () =>
-  require('@react-native-async-storage/async-storage/jest/async-storage-mock')
-);
-
-// Mock react-native-gesture-handler
-jest.mock('react-native-gesture-handler', () => {
-  const View = require('react-native').View;
-  return {
-    ScrollView: View,
-    PanGestureHandler: View,
-    TapGestureHandler: View,
-    FlingGestureHandler: View,
-    PinchGestureHandler: View,
-    RotationGestureHandler: View,
-    State: {},
-    PanResponder: {
-      create: jest.fn(() => ({
-        panHandlers: {},
-      })),
-    },
-  };
-});

package/src/__tests__/ui/hooks/authfetch-integration.test.ts

@@ -1,197 +0,0 @@
-/**
- * Integration test demonstrating the separation of internal and public authFetch usage
- * This test simulates real-world usage patterns described in the issue
- */
-
-describe('AuthFetch Separation - Integration Test', () => {
-  describe('Real-world usage simulation', () => {
-    // Mock OxyServices to simulate the actual implementation
-    class MockOxyServices {
-      private internalBaseURL: string;
-
-      constructor(config: { baseURL: string }) {
-        this.internalBaseURL = config.baseURL;
-      }
-
-      // Internal URL management (used by the module itself)
-      getBaseURL(): string {
-        return this.internalBaseURL;
-      }
-
-      setBaseURL(url: string): void {
-        if (!url) throw new Error('Base URL cannot be empty');
-        this.internalBaseURL = url;
-      }
-
-      // Simulate internal module methods that make API calls
-      authenticateToken(token: string): Promise<{ valid: boolean; error?: string }> {
-        const url = `${this.internalBaseURL}/auth/validate`;
-        console.log(`Internal module call to: ${url}`);
-        return Promise.resolve({ valid: false, error: 'Invalid token' });
-      }
-
-      refreshTokens(): Promise<void> {
-        const url = `${this.internalBaseURL}/auth/refresh`;
-        console.log(`Internal module call to: ${url}`);
-        return Promise.resolve();
-      }
-
-      getUserBySession(sessionId: string): Promise<any> {
-        const url = `${this.internalBaseURL}/users/session/${sessionId}`;
-        console.log(`Internal module call to: ${url}`);
-        return Promise.resolve({ id: 'user123', username: 'testuser' });
-      }
-    }
-
-    // Mock context state (simulating the new OxyContext implementation)
-    class MockOxyContext {
-      private oxyServices: MockOxyServices;
-      private appBaseURL: string;
-
-      constructor(oxyServices: MockOxyServices) {
-        this.oxyServices = oxyServices;
-        this.appBaseURL = oxyServices.getBaseURL(); // Initially same as internal URL
-      }
-
-      // Public methods for apps
-      setApiUrl(url: string): void {
-        if (!url) throw new Error('Base URL cannot be empty');
-        this.appBaseURL = url; // Only affects public authFetch
-      }
-
-      getAppBaseURL(): string {
-        return this.appBaseURL;
-      }
-
-      getOxyServices(): MockOxyServices {
-        return this.oxyServices;
-      }
-    }
-
-    // Mock authFetch (simulating the new useAuthFetch implementation)
-    function createMockAuthFetch(context: MockOxyContext) {
-      return {
-        get: async (endpoint: string) => {
-          const url = `${context.getAppBaseURL()}${endpoint}`;
-          console.log(`Public authFetch call to: ${url}`);
-          return { data: `Response from ${url}` };
-        },
-        post: async (endpoint: string, data: any) => {
-          const url = `${context.getAppBaseURL()}${endpoint}`;
-          console.log(`Public authFetch call to: ${url}`);
-          return { data: `Posted to ${url}`, posted: data };
-        }
-      };
-    }
-
-    test('should demonstrate clean separation in Mention app scenario', async () => {
-      console.log('\n=== Mention App Integration Test ===\n');
-
-      // 1. Initialize OxyServices for internal module usage
-      const oxyServices = new MockOxyServices({
-        baseURL: 'https://api.oxy.so'
-      });
-
-      // 2. Create context (simulating OxyProvider)
-      const context = new MockOxyContext(oxyServices);
-      
-      // 3. Create authFetch (simulating useAuthFetch hook)
-      const authFetch = createMockAuthFetch(context);
-
-      console.log('1. Initial state:');
-      
-      // Internal module calls should use Oxy API
-      await oxyServices.authenticateToken('test-token');
-      await oxyServices.getUserBySession('session123');
-      
-      // Public authFetch calls initially use Oxy API too
-      await authFetch.get('/api/users/me');
-      await authFetch.post('/api/mentions', { text: 'Hello world' });
-
-      console.log('\n2. Mention app sets its own API URL:');
-      
-      // App configures its own API URL
-      context.setApiUrl('https://mention.earth/api');
-
-      console.log('\n3. After configuration:');
-      
-      // Internal module calls STILL use Oxy API (unchanged)
-      await oxyServices.authenticateToken('test-token');
-      await oxyServices.refreshTokens();
-      
-      // Public authFetch calls now use Mention's API
-      await authFetch.get('/api/mentions');
-      await authFetch.post('/api/mentions', { text: 'New mention' });
-      
-      // Verify URLs are correctly separated
-      expect(oxyServices.getBaseURL()).toBe('https://api.oxy.so');
-      expect(context.getAppBaseURL()).toBe('https://mention.earth/api');
-      
-      console.log('\n✅ Clean separation achieved!');
-    });
-
-    test('should support dynamic URL changes without affecting internal calls', async () => {
-      console.log('\n=== Dynamic URL Changes Test ===\n');
-
-      const oxyServices = new MockOxyServices({
-        baseURL: 'https://api.oxy.so'
-      });
-      const context = new MockOxyContext(oxyServices);
-      const authFetch = createMockAuthFetch(context);
-
-      // Scenario: App switches between staging and production
-      const environments = [
-        'https://staging.myapp.com/api',
-        'https://production.myapp.com/api',
-        'https://dev.myapp.com/api'
-      ];
-
-      for (const [index, env] of environments.entries()) {
-        console.log(`${index + 1}. Switching to ${env}:`);
-        
-        context.setApiUrl(env);
-        
-        // Internal calls remain unchanged
-        await oxyServices.authenticateToken('token');
-        
-        // Public calls use new environment
-        await authFetch.get('/api/data');
-        
-        // Verify separation
-        expect(oxyServices.getBaseURL()).toBe('https://api.oxy.so');
-        expect(context.getAppBaseURL()).toBe(env);
-      }
-      
-      console.log('\n✅ Dynamic URL changes work correctly!');
-    });
-
-    test('should handle zero-config setup as described in issue', () => {
-      console.log('\n=== Zero-Config Setup Test ===\n');
-
-      // Simulate the zero-config setup described in the issue
-      console.log('1. Create OxyServices instance:');
-      const oxyServices = new MockOxyServices({
-        baseURL: 'https://your-api.com'
-      });
-
-      console.log('2. Wrap app with provider (simulated):');
-      const context = new MockOxyContext(oxyServices);
-
-      console.log('3. Use authFetch in components (simulated):');
-      const authFetch = createMockAuthFetch(context);
-
-      // Verify the setup works
-      expect(oxyServices.getBaseURL()).toBe('https://your-api.com');
-      expect(context.getAppBaseURL()).toBe('https://your-api.com');
-
-      console.log('4. Change API URL at runtime:');
-      context.setApiUrl('https://production-api.com');
-
-      // Verify separation
-      expect(oxyServices.getBaseURL()).toBe('https://your-api.com'); // Internal unchanged
-      expect(context.getAppBaseURL()).toBe('https://production-api.com'); // Public changed
-
-      console.log('\n✅ Zero-config setup with separation works!');
-    });
-  });
-});

package/src/__tests__/ui/hooks/backward-compatibility.test.ts

@@ -1,159 +0,0 @@
-/**
- * Backward compatibility test - ensures existing API surface is unchanged
- */
-
-describe('Backward Compatibility', () => {
-  describe('Existing API surface', () => {
-    // Mock the components to test the API surface
-    function mockUseOxy() {
-      return {
-        oxyServices: {
-          getBaseURL: () => 'https://api.oxy.so',
-          setBaseURL: (url: string) => {},
-        },
-        isAuthenticated: true,
-        user: { id: 'user123', username: 'testuser' },
-        login: async (username: string, password: string) => ({ id: 'user123' }),
-        logout: async () => {},
-        signUp: async (username: string, email: string, password: string) => ({ id: 'user123' }),
-        activeSessionId: 'session123',
-        setApiUrl: (url: string) => {}, // This should still exist
-        getAppBaseURL: () => 'https://app.example.com', // New addition
-      };
-    }
-
-    function mockUseAuthFetch() {
-      const oxyContext = mockUseOxy();
-      
-      // Mock the AuthFetchAPI interface
-      const authFetch = async (input: RequestInfo | URL, init?: any) => {
-        return new Response('{"success": true}');
-      };
-
-      // Add convenience methods as per the interface
-      Object.assign(authFetch, {
-        get: async (endpoint: string, options?: any) => ({ data: 'get response' }),
-        post: async (endpoint: string, data?: any, options?: any) => ({ data: 'post response' }),
-        put: async (endpoint: string, data?: any, options?: any) => ({ data: 'put response' }),
-        delete: async (endpoint: string, options?: any) => ({ data: 'delete response' }),
-        isAuthenticated: oxyContext.isAuthenticated,
-        user: oxyContext.user,
-        login: oxyContext.login,
-        logout: oxyContext.logout,
-        signUp: oxyContext.signUp,
-        setApiUrl: oxyContext.setApiUrl, // Existing API
-      });
-
-      return authFetch;
-    }
-
-    test('should maintain existing useAuthFetch API', async () => {
-      const authFetch = mockUseAuthFetch();
-
-      // Test that all existing methods are still available
-      expect(typeof authFetch).toBe('function'); // Main function
-      expect(typeof authFetch.get).toBe('function');
-      expect(typeof authFetch.post).toBe('function');
-      expect(typeof authFetch.put).toBe('function');
-      expect(typeof authFetch.delete).toBe('function');
-      expect(typeof authFetch.setApiUrl).toBe('function'); // Key API method
-
-      // Test that auth properties are available
-      expect(typeof authFetch.isAuthenticated).toBe('boolean');
-      expect(authFetch.user).toBeTruthy();
-      expect(typeof authFetch.login).toBe('function');
-      expect(typeof authFetch.logout).toBe('function');
-      expect(typeof authFetch.signUp).toBe('function');
-    });
-
-    test('should support existing usage patterns from documentation', async () => {
-      // Test usage pattern from refactored-authentication.md
-      const authFetch = mockUseAuthFetch();
-
-      // Simple authenticated GET request
-      const profile = await authFetch.get('/api/users/me');
-      expect(profile).toEqual({ data: 'get response' });
-
-      // Simple authenticated POST request
-      const result = await authFetch.post('/api/users/me', { name: 'Updated Name' });
-      expect(result).toEqual({ data: 'post response' });
-
-      // Runtime API URL updates (this should still work)
-      authFetch.setApiUrl('https://new-api.com');
-      
-      // Verify no breaking changes in the API surface
-      expect(authFetch.isAuthenticated).toBe(true);
-      expect(authFetch.user?.username).toBe('testuser');
-    });
-
-    test('should support existing OxyServices API', () => {
-      const oxyContext = mockUseOxy();
-      const oxyServices = oxyContext.oxyServices;
-
-      // Existing OxyServices methods should still work
-      expect(typeof oxyServices.getBaseURL).toBe('function');
-      expect(typeof oxyServices.setBaseURL).toBe('function');
-      expect(oxyServices.getBaseURL()).toBe('https://api.oxy.so');
-
-      // This should not throw
-      oxyServices.setBaseURL('https://new-oxy-url.com');
-    });
-
-    test('should demonstrate zero-config setup still works', () => {
-      // From the documentation example
-      console.log('Testing zero-config setup pattern...');
-
-      // 1. Create OxyServices instance (existing pattern)
-      const mockOxyServices = {
-        baseURL: 'https://your-api.com',
-        getBaseURL: () => 'https://your-api.com',
-      };
-
-      // 2. Wrap app with provider (existing pattern)
-      const mockProvider = {
-        oxyServices: mockOxyServices,
-      };
-
-      // 3. Use authFetch in components (existing pattern)
-      const authFetch = mockUseAuthFetch();
-
-      // All existing functionality should work
-      expect(authFetch).toBeTruthy();
-      expect(typeof authFetch.get).toBe('function');
-      expect(typeof authFetch.setApiUrl).toBe('function');
-
-      console.log('✅ Zero-config setup compatibility verified');
-    });
-  });
-
-  describe('New functionality (additive)', () => {
-    test('should add new getAppBaseURL without breaking existing API', () => {
-      const oxyContext = mockUseOxy();
-
-      // New method should be available
-      expect(typeof oxyContext.getAppBaseURL).toBe('function');
-      expect(oxyContext.getAppBaseURL()).toBe('https://app.example.com');
-
-      // Existing methods should still work
-      expect(typeof oxyContext.setApiUrl).toBe('function');
-    });
-
-    test('should demonstrate separation without breaking existing usage', () => {
-      console.log('\nTesting that new separation doesn\'t break existing patterns...');
-
-      const oxyContext = mockUseOxy();
-      
-      // Existing pattern: app sets API URL
-      oxyContext.setApiUrl('https://myapp.example.com');
-      
-      // New behavior: this now only affects public authFetch, not internal calls
-      // But from the app's perspective, the API call is identical
-      expect(typeof oxyContext.setApiUrl).toBe('function');
-      
-      // Internal calls would still work independently (behind the scenes)
-      expect(oxyContext.oxyServices.getBaseURL()).toBe('https://api.oxy.so');
-      
-      console.log('✅ Separation is transparent to existing users');
-    });
-  });
-});