@oxyhq/services 5.13.25 → 5.13.26

package/src/core/OxyServices.base.ts

@@ -6,8 +6,7 @@
 import { jwtDecode } from 'jwt-decode';
 import type { OxyConfig as OxyConfigBase, ApiError, User } from '../models/interfaces';
 import { handleHttpError } from '../utils/errorUtils';
-import { HttpClient } from './HttpClient';
-import { RequestManager, type RequestOptions } from './RequestManager';
+import { HttpService, type RequestOptions } from './HttpService';
 import { OxyAuthenticationError, OxyAuthenticationTimeoutError } from './OxyServices.errors';
 
 export interface OxyConfig extends OxyConfigBase {
@@ -26,8 +25,7 @@ interface JwtPayload {
  * Base class for OxyServices with core infrastructure
  */
 export class OxyServicesBase {
-  public httpClient: HttpClient;
-  public requestManager: RequestManager;
+  public httpService: HttpService;
   public cloudURL: string;
   public config: OxyConfig;
 
@@ -39,16 +37,13 @@ export class OxyServicesBase {
     this.config = config;
     this.cloudURL = config.cloudURL || 'https://cloud.oxy.so';
 
-    // Initialize HTTP client (handles authentication and interceptors)
-    this.httpClient = new HttpClient(config);
-
-    // Initialize request manager (handles caching, deduplication, queuing, retry)
-    this.requestManager = new RequestManager(this.httpClient, config);
+    // Initialize unified HTTP service (handles auth, caching, deduplication, queuing, retry)
+    this.httpService = new HttpService(config);
   }
 
   // Test-only utility to reset global tokens between jest tests
   static __resetTokensForTests(): void {
-    HttpClient.__resetTokensForTests();
+    HttpService.__resetTokensForTests();
   }
 
   /**
@@ -61,7 +56,13 @@ export class OxyServicesBase {
     data?: any,
     options: RequestOptions = {}
   ): Promise<T> {
-    return this.requestManager.request<T>(method, url, data, options);
+    return this.httpService.request<T>({
+      method,
+      url,
+      data: method !== 'GET' ? data : undefined,
+      params: method === 'GET' ? data : undefined,
+      ...options,
+    });
   }
 
   // ============================================================================
@@ -72,43 +73,43 @@ export class OxyServicesBase {
    * Get the configured Oxy API base URL
    */
   public getBaseURL(): string {
-    return this.httpClient.getBaseURL();
+    return this.httpService.getBaseURL();
   }
 
   /**
-   * Get the HTTP client instance
-   * Useful for advanced use cases where direct access to the HTTP client is needed
+   * Get the HTTP service instance
+   * Useful for advanced use cases where direct access to the HTTP service is needed
    */
-  public getClient(): HttpClient {
-    return this.httpClient;
+  public getClient(): HttpService {
+    return this.httpService;
   }
 
   /**
    * Get performance metrics
    */
   public getMetrics() {
-    return this.requestManager.getMetrics();
+    return this.httpService.getMetrics();
   }
 
   /**
    * Clear request cache
    */
   public clearCache(): void {
-    this.requestManager.clearCache();
+    this.httpService.clearCache();
   }
 
   /**
    * Clear specific cache entry
    */
   public clearCacheEntry(key: string): void {
-    this.requestManager.clearCacheEntry(key);
+    this.httpService.clearCacheEntry(key);
   }
 
   /**
    * Get cache statistics
    */
   public getCacheStats() {
-    return this.requestManager.getCacheStats();
+    return this.httpService.getCacheStats();
   }
 
   /**
@@ -122,21 +123,21 @@ export class OxyServicesBase {
    * Set authentication tokens
    */
   public setTokens(accessToken: string, refreshToken = ''): void {
-    this.httpClient.setTokens(accessToken, refreshToken);
+    this.httpService.setTokens(accessToken, refreshToken);
   }
 
   /**
    * Clear stored authentication tokens
    */
   public clearTokens(): void {
-    this.httpClient.clearTokens();
+    this.httpService.clearTokens();
   }
 
   /**
    * Get the current user ID from the access token
    */
   public getCurrentUserId(): string | null {
-    const accessToken = this.httpClient.getAccessToken();
+    const accessToken = this.httpService.getAccessToken();
     if (!accessToken) {
       return null;
     }
@@ -153,14 +154,14 @@ export class OxyServicesBase {
    * Check if the client has a valid access token (public method)
    */
   public hasValidToken(): boolean {
-    return this.httpClient.hasAccessToken();
+    return this.httpService.hasAccessToken();
   }
 
   /**
    * Get the raw access token (for constructing anchor URLs when needed)
    */
   public getAccessToken(): string | null {
-    return this.httpClient.getAccessToken();
+    return this.httpService.getAccessToken();
   }
 
   /**
@@ -183,7 +184,7 @@ export class OxyServicesBase {
    */
   public async waitForAuth(timeoutMs = 5000): Promise<boolean> {
     // Immediate synchronous check - no delay if token is ready
-    if (this.httpClient.hasAccessToken()) {
+    if (this.httpService.hasAccessToken()) {
       return true;
     }
 
@@ -196,7 +197,7 @@ export class OxyServicesBase {
     while (performance.now() < maxTime) {
       await new Promise(resolve => setTimeout(resolve, pollInterval));
       
-      if (this.httpClient.hasAccessToken()) {
+      if (this.httpService.hasAccessToken()) {
         return true;
       }
       
@@ -232,7 +233,7 @@ export class OxyServicesBase {
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
       try {
         // First attempt: check if we have a token
-        if (!this.httpClient.hasAccessToken()) {
+        if (!this.httpService.hasAccessToken()) {
           if (attempt === 0) {
             // On first attempt, wait briefly for authentication to complete
             const authReady = await this.waitForAuth(authTimeoutMs);
@@ -252,11 +253,12 @@ export class OxyServicesBase {
         // Execute the operation
         return await operation();
 
-      } catch (error: any) {
+      } catch (error: unknown) {
         const isLastAttempt = attempt === maxRetries;
-        const isAuthError = error?.response?.status === 401 || 
-                           error?.code === 'MISSING_TOKEN' ||
-                           error?.message?.includes('Authentication') ||
+        const errorObj = error && typeof error === 'object' ? error as { response?: { status?: number }; code?: string; message?: string } : null;
+        const isAuthError = errorObj?.response?.status === 401 || 
+                           errorObj?.code === 'MISSING_TOKEN' ||
+                           errorObj?.message?.includes('Authentication') ||
                            error instanceof OxyAuthenticationError;
 
         if (isAuthError && !isLastAttempt && !(error instanceof OxyAuthenticationTimeoutError)) {
@@ -298,12 +300,12 @@ export class OxyServicesBase {
   /**
    * Centralized error handling
    */
-  public handleError(error: any): Error {
+  public handleError(error: unknown): Error {
     const api = handleHttpError(error);
     const err = new Error(api.message) as Error & { code?: string; status?: number; details?: Record<string, unknown> };
     err.code = api.code;
     err.status = api.status;
-    err.details = api.details as any;
+    err.details = api.details;
     return err;
   }
 

package/src/core/OxyServices.ts

@@ -68,8 +68,7 @@ import { composeOxyServices } from './mixins';
  * This class provides all API functionality in one simple, easy-to-use interface.
  * 
  * ## Architecture
- * - **HttpClient**: Handles HTTP communication and authentication
- * - **RequestManager**: Handles caching, deduplication, queuing, and retry
+ * - **HttpService**: Unified HTTP service handling authentication, caching, deduplication, queuing, and retry
  * - **OxyServices**: Provides high-level API methods
  * 
  * ## Mixin Composition

package/src/core/mixins/OxyServices.assets.ts

@@ -235,11 +235,12 @@ export function OxyServicesAssetsMixin<T extends typeof OxyServicesBase>(Base: T
           // Fallback: direct upload via API to avoid CORS issues
           const fd = new FormData();
           fd.append('file', file);
-          // Use httpClient directly for FormData uploads (bypasses RequestManager for special handling)
+          // Use httpService directly for FormData uploads (bypasses caching for special handling)
           await this.getClient().request({
             method: 'POST',
             url: `/api/assets/${encodeURIComponent(initResponse.fileId)}/upload-direct`,
             data: fd,
+            cache: false,
           });
         }
 

package/src/core/mixins/OxyServices.user.ts

@@ -189,14 +189,15 @@ export function OxyServicesUserMixin<T extends typeof OxyServicesBase>(Base: T)
      */
     async downloadAccountData(format: 'json' | 'csv' = 'json'): Promise<Blob> {
       try {
-        // Use axios instance directly for blob responses since RequestManager doesn't handle blobs
-        const axiosInstance = this.getClient().getAxiosInstance();
-        
-        const response = await axiosInstance.get(`/api/users/me/data?format=${format}`, {
-          responseType: 'blob',
+        // Use httpService for blob responses (it handles blob responses automatically)
+        const result = await this.getClient().request<Blob>({
+          method: 'GET',
+          url: `/api/users/me/data`,
+          params: { format },
+          cache: false,
         });
         
-        return response.data as Blob;
+        return result;
       } catch (error) {
         throw this.handleError(error);
       }

package/src/core/mixins/OxyServices.utility.ts

@@ -177,6 +177,7 @@ export function OxyServicesUtilityMixin<T extends typeof OxyServicesBase>(Base:
           const apiError = this.handleError(error) as any;
           
           if (debug) {
+            // Debug logging - using console.log is acceptable here for development
             console.log(`❌ Auth: Unexpected error:`, apiError);
           }
           

package/src/utils/errorUtils.ts

@@ -1,4 +1,5 @@
 import type { ApiError } from '../models/interfaces';
+import { logger } from './loggerUtils';
 
 /**
  * Error handling utilities for consistent error processing
@@ -61,32 +62,72 @@ export function handleHttpError(error: unknown): ApiError {
     return error as ApiError;
   }
 
-  // Handle axios errors - check if it looks like an axios error
-  if (error && typeof error === 'object' && 'response' in error) {
-    const axiosError = error as { response?: { status: number; data?: { message?: string; code?: string } } };
-    if (axiosError.response) {
-      const { status, data } = axiosError.response;
-      
+  // Handle AbortError (timeout or cancelled requests)
+  if (error instanceof Error && error.name === 'AbortError') {
+    return createApiError(
+      'Request timeout or cancelled',
+      ErrorCodes.TIMEOUT,
+      0
+    );
+  }
+
+  // Handle TypeError (network failures, CORS, etc.)
+  if (error instanceof TypeError) {
+    // Check if it's a network-related TypeError
+    if (error.message.includes('fetch') || error.message.includes('network') || error.message.includes('Failed to fetch')) {
       return createApiError(
-        data?.message || `HTTP ${status} error`,
-        data?.code || getErrorCodeFromStatus(status),
-        status,
-        data
+        'Network error - failed to connect to server',
+        ErrorCodes.NETWORK_ERROR,
+        0
       );
     }
-  }
-
-  // Handle network errors - check if it looks like a network error
-  if (error && typeof error === 'object' && 'request' in error) {
     return createApiError(
-      'Network error - no response received',
+      error.message || 'Network error occurred',
       ErrorCodes.NETWORK_ERROR,
       0
     );
   }
 
+  // Handle fetch Response errors - check if it has response property with status
+  if (error && typeof error === 'object' && 'response' in error) {
+    const fetchError = error as { 
+      response?: { 
+        status: number; 
+        statusText?: string;
+      };
+      status?: number;
+      message?: string;
+    };
+    
+    const status = fetchError.response?.status || fetchError.status;
+    if (status) {
+      return createApiError(
+        fetchError.message || `HTTP ${status} error`,
+        getErrorCodeFromStatus(status),
+        status
+      );
+    }
+  }
+
   // Handle standard errors
   if (error instanceof Error) {
+    // Check for common error patterns
+    if (error.message.includes('timeout') || error.message.includes('aborted')) {
+      return createApiError(
+        'Request timeout',
+        ErrorCodes.TIMEOUT,
+        0
+      );
+    }
+    
+    if (error.message.includes('network') || error.message.includes('fetch')) {
+      return createApiError(
+        error.message || 'Network error occurred',
+        ErrorCodes.NETWORK_ERROR,
+        0
+      );
+    }
+
     return createApiError(
       error.message || 'Unknown error occurred',
       ErrorCodes.INTERNAL_ERROR,
@@ -148,12 +189,17 @@ export function validateRequiredFields(data: Record<string, unknown>, fields: st
  * Safe error logging with context
  */
 export function logError(error: unknown, context?: string): void {
-  const prefix = context ? `[${context}]` : '[Error]';
-  
   if (error instanceof Error) {
-    console.error(`${prefix} ${error.message}`, error.stack);
+    logger.error(error.message, {
+      component: context || 'errorUtils',
+      method: 'logError',
+      stack: error.stack,
+    });
   } else {
-    console.error(`${prefix}`, error);
+    logger.error(String(error), {
+      component: context || 'errorUtils',
+      method: 'logError',
+    });
   }
 }
 

package/lib/commonjs/core/HttpClient.js

@@ -1,317 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.HttpClient = void 0;
-var _axios = _interopRequireDefault(require("axios"));
-var _jwtDecode = require("jwt-decode");
-var _errorUtils = require("../utils/errorUtils");
-var _requestUtils = require("../utils/requestUtils");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-/**
- * HTTP Client Service
- * 
- * Handles all HTTP communication with authentication, interceptors, and error handling.
- * This is the single source of truth for making authenticated HTTP requests.
- */
-
-/**
- * Token store for authentication
- */
-class TokenStore {
-  accessToken = null;
-  refreshToken = null;
-  constructor() {}
-  static getInstance() {
-    if (!TokenStore.instance) {
-      TokenStore.instance = new TokenStore();
-    }
-    return TokenStore.instance;
-  }
-  setTokens(accessToken, refreshToken = '') {
-    this.accessToken = accessToken;
-    this.refreshToken = refreshToken;
-  }
-  getAccessToken() {
-    return this.accessToken;
-  }
-  getRefreshToken() {
-    return this.refreshToken;
-  }
-  clearTokens() {
-    this.accessToken = null;
-    this.refreshToken = null;
-  }
-  hasAccessToken() {
-    return !!this.accessToken;
-  }
-}
-
-/**
- * HTTP Client Service
- * 
- * Manages Axios instance with authentication interceptors.
- * All HTTP requests should go through this service to ensure authentication.
- */
-class HttpClient {
-  constructor(config) {
-    this.baseURL = config.baseURL;
-    this.tokenStore = TokenStore.getInstance();
-    this.logger = new _requestUtils.SimpleLogger(config.enableLogging || false, config.logLevel || 'error', 'HttpClient');
-    const timeout = config.requestTimeout || 5000;
-
-    // Create Axios instance with optimized configuration
-    this.client = _axios.default.create({
-      baseURL: config.baseURL,
-      timeout,
-      headers: {
-        'Accept': 'application/json'
-      },
-      // Enable HTTP keep-alive for connection reuse (Node.js only)
-      ...(typeof process !== 'undefined' && process.env && typeof window === 'undefined' && typeof require !== 'undefined' ? {
-        httpAgent: new (require('http').Agent)({
-          keepAlive: true,
-          keepAliveMsecs: 1000,
-          maxSockets: 50
-        }),
-        httpsAgent: new (require('https').Agent)({
-          keepAlive: true,
-          keepAliveMsecs: 1000,
-          maxSockets: 50
-        })
-      } : {})
-    });
-    this.setupInterceptors();
-  }
-
-  /**
-   * Setup axios interceptors for authentication and error handling
-   */
-  setupInterceptors() {
-    // Request interceptor: Add authentication header
-    this.client.interceptors.request.use(async req => {
-      const accessToken = this.tokenStore.getAccessToken();
-      if (!accessToken) {
-        return req;
-      }
-      try {
-        const decoded = (0, _jwtDecode.jwtDecode)(accessToken);
-        const currentTime = Math.floor(Date.now() / 1000);
-
-        // If token expires in less than 60 seconds, refresh it
-        if (decoded.exp && decoded.exp - currentTime < 60) {
-          if (decoded.sessionId) {
-            try {
-              // Create a new axios instance to avoid interceptor recursion
-              const refreshClient = _axios.default.create({
-                baseURL: this.client.defaults.baseURL,
-                timeout: this.client.defaults.timeout
-              });
-              const res = await refreshClient.get(`/api/session/token/${decoded.sessionId}`);
-              this.tokenStore.setTokens(res.data.accessToken);
-              req.headers.Authorization = `Bearer ${res.data.accessToken}`;
-              this.logger.debug('Token refreshed');
-            } catch (refreshError) {
-              // If refresh fails, use current token anyway
-              req.headers.Authorization = `Bearer ${accessToken}`;
-              this.logger.warn('Token refresh failed, using current token');
-            }
-          } else {
-            req.headers.Authorization = `Bearer ${accessToken}`;
-          }
-        } else {
-          req.headers.Authorization = `Bearer ${accessToken}`;
-        }
-      } catch (error) {
-        this.logger.error('Error processing token:', error);
-        // Even if there's an error, still try to use the token
-        req.headers.Authorization = `Bearer ${accessToken}`;
-      }
-      return req;
-    }, error => {
-      this.logger.error('Request interceptor error:', error);
-      return Promise.reject(error);
-    });
-
-    // Response interceptor: Handle auth errors
-    this.client.interceptors.response.use(response => response, error => {
-      if (error.response?.status === 401) {
-        this.logger.warn('401 Unauthorized, clearing tokens');
-        this.tokenStore.clearTokens();
-      }
-      return Promise.reject(error);
-    });
-  }
-
-  /**
-   * Get the underlying Axios instance
-   * Use this only when you need direct access to Axios features
-   */
-  getAxiosInstance() {
-    return this.client;
-  }
-
-  /**
-   * Make a raw HTTP request (no caching, deduplication, etc.)
-   * Use this for requests that need to bypass performance features
-   */
-  async request(config) {
-    try {
-      const response = await this.client.request({
-        method: config.method,
-        url: config.url,
-        data: config.data,
-        params: config.params,
-        timeout: config.timeout,
-        signal: config.signal
-      });
-
-      // Unwrap standardized API response format: { data: ... }
-      // This handles responses from sendSuccess() and sendPaginated() helpers
-      const responseData = response.data;
-
-      // Handle paginated responses: { data: [...], pagination: {...} }
-      // Return the data array directly - the calling method will wrap it appropriately
-      if (responseData && typeof responseData === 'object' && 'data' in responseData && 'pagination' in responseData) {
-        // For paginated responses, return the data array directly
-        // The calling methods like getUserFollowers/getUserFollowing will handle wrapping
-        // We return the whole response so methods can access both data and pagination
-        return responseData;
-      }
-
-      // Handle regular success responses: { data: ... }
-      if (responseData && typeof responseData === 'object' && 'data' in responseData && !Array.isArray(responseData)) {
-        return responseData.data;
-      }
-
-      // Return as-is for responses that don't use sendSuccess wrapper
-      return responseData;
-    } catch (error) {
-      throw (0, _errorUtils.handleHttpError)(error);
-    }
-  }
-
-  /**
-   * GET request convenience method
-   */
-  async get(url, config) {
-    const response = await this.request({
-      method: 'GET',
-      url,
-      params: config?.params,
-      timeout: config?.timeout,
-      signal: config?.signal
-    });
-    return {
-      data: response
-    };
-  }
-
-  /**
-   * POST request convenience method
-   */
-  async post(url, data, config) {
-    const response = await this.request({
-      method: 'POST',
-      url,
-      data,
-      timeout: config?.timeout,
-      signal: config?.signal
-    });
-    return {
-      data: response
-    };
-  }
-
-  /**
-   * PUT request convenience method
-   */
-  async put(url, data, config) {
-    const response = await this.request({
-      method: 'PUT',
-      url,
-      data,
-      timeout: config?.timeout,
-      signal: config?.signal
-    });
-    return {
-      data: response
-    };
-  }
-
-  /**
-   * PATCH request convenience method
-   */
-  async patch(url, data, config) {
-    const response = await this.request({
-      method: 'PATCH',
-      url,
-      data,
-      timeout: config?.timeout,
-      signal: config?.signal
-    });
-    return {
-      data: response
-    };
-  }
-
-  /**
-   * DELETE request convenience method
-   */
-  async delete(url, config) {
-    const response = await this.request({
-      method: 'DELETE',
-      url,
-      timeout: config?.timeout,
-      signal: config?.signal
-    });
-    return {
-      data: response
-    };
-  }
-
-  /**
-   * Get base URL
-   */
-  getBaseURL() {
-    return this.baseURL;
-  }
-
-  /**
-   * Set authentication tokens
-   */
-  setTokens(accessToken, refreshToken = '') {
-    this.tokenStore.setTokens(accessToken, refreshToken);
-  }
-
-  /**
-   * Clear authentication tokens
-   */
-  clearTokens() {
-    this.tokenStore.clearTokens();
-  }
-
-  /**
-   * Get access token
-   */
-  getAccessToken() {
-    return this.tokenStore.getAccessToken();
-  }
-
-  /**
-   * Check if has access token
-   */
-  hasAccessToken() {
-    return this.tokenStore.hasAccessToken();
-  }
-
-  // Test-only utility to reset global tokens between jest tests
-  static __resetTokensForTests() {
-    try {
-      TokenStore.getInstance().clearTokens();
-    } catch {}
-  }
-}
-exports.HttpClient = HttpClient;
-//# sourceMappingURL=HttpClient.js.map