@oxyhq/services 5.13.24 → 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/ui/components/FollowButton.tsx

@@ -233,59 +233,6 @@ const FollowButton: React.FC<FollowButtonProps> = ({
   );
 };
 
-const styles = StyleSheet.create({
-  // Legacy styles kept for backward compatibility but not used in new implementation
-  buttonSmall: {
-    paddingVertical: 4,
-    paddingHorizontal: 12,
-    borderRadius: 16,
-    minWidth: 60,
-    alignItems: 'center',
-    justifyContent: 'center',
-  },
-  buttonMedium: {
-    paddingVertical: 8,
-    paddingHorizontal: 20,
-    borderRadius: 20,
-    minWidth: 90,
-    alignItems: 'center',
-    justifyContent: 'center',
-  },
-  buttonLarge: {
-    paddingVertical: 12,
-    paddingHorizontal: 32,
-    borderRadius: 24,
-    minWidth: 120,
-    alignItems: 'center',
-    justifyContent: 'center',
-  },
-  following: {
-    backgroundColor: '#007AFF',
-  },
-  notFollowing: {
-    backgroundColor: '#fff',
-    borderWidth: 1,
-    borderColor: '#007AFF',
-  },
-  textSmall: {
-    fontSize: 13,
-    fontFamily: fontFamilies.phuduMedium,
-  },
-  textMedium: {
-    fontSize: 15,
-    fontFamily: fontFamilies.phuduMedium,
-  },
-  textLarge: {
-    fontSize: 18,
-    fontFamily: fontFamilies.phuduMedium,
-  },
-  textFollowing: {
-    color: '#fff',
-  },
-  textNotFollowing: {
-    color: '#007AFF',
-  },
-});
 
 export { FollowButton };
 export default FollowButton;

package/src/utils/asyncUtils.ts

@@ -3,9 +3,11 @@
  */
 
 import { TTLCache, registerCacheForCleanup } from './cache';
+import { logger } from './loggerUtils';
 
 /**
  * Wrapper for async operations with automatic error handling
+ * Returns null on error instead of throwing
  */
 export async function withErrorHandling<T>(
   operation: () => Promise<T>,
@@ -18,7 +20,10 @@ export async function withErrorHandling<T>(
     if (errorHandler) {
       errorHandler(error);
     } else {
-      console.error(`Error in ${context || 'operation'}:`, error);
+      logger.error(`Error in ${context || 'operation'}`, error instanceof Error ? error : new Error(String(error)), {
+        component: 'asyncUtils',
+        method: 'withErrorHandling',
+      });
     }
     return null;
   }
@@ -44,6 +49,9 @@ export async function parallelWithErrorHandling<T>(
 
 /**
  * Retry an async operation with exponential backoff
+ * 
+ * By default, does not retry on 4xx errors (client errors).
+ * Use shouldRetry callback to customize retry behavior.
  */
 export async function retryAsync<T>(
   operation: () => Promise<T>,
@@ -53,6 +61,17 @@ export async function retryAsync<T>(
 ): Promise<T> {
   let lastError: any;
   
+  // Default shouldRetry: don't retry on 4xx errors
+  const defaultShouldRetry = (error: any): boolean => {
+    // Don't retry on 4xx errors (client errors)
+    if (error?.response?.status >= 400 && error?.response?.status < 500) {
+      return false;
+    }
+    return true;
+  };
+  
+  const retryCheck = shouldRetry || defaultShouldRetry;
+  
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     try {
       return await operation();
@@ -63,11 +82,12 @@ export async function retryAsync<T>(
         break;
       }
       
-      if (shouldRetry && !shouldRetry(error)) {
+      if (!retryCheck(error)) {
         break;
       }
       
-      const delay = baseDelay * Math.pow(2, attempt);
+      // Calculate delay with exponential backoff and jitter
+      const delay = baseDelay * Math.pow(2, attempt) + Math.random() * 1000;
       await new Promise(resolve => setTimeout(resolve, delay));
     }
   }

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
@@ -16,6 +17,7 @@ export const ErrorCodes = {
   
   // Validation errors
   VALIDATION_ERROR: 'VALIDATION_ERROR',
+  BAD_REQUEST: 'BAD_REQUEST',
   MISSING_PARAMETER: 'MISSING_PARAMETER',
   INVALID_FORMAT: 'INVALID_FORMAT',
   
@@ -60,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,
@@ -103,11 +145,12 @@ export function handleHttpError(error: unknown): ApiError {
 
 /**
  * Get error code from HTTP status
+ * Exported for use in other modules
  */
-function getErrorCodeFromStatus(status: number): string {
+export function getErrorCodeFromStatus(status: number): string {
   switch (status) {
     case 400:
-      return ErrorCodes.VALIDATION_ERROR;
+      return ErrorCodes.BAD_REQUEST;
     case 401:
       return ErrorCodes.UNAUTHORIZED;
     case 403:
@@ -146,39 +189,23 @@ 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',
+    });
   }
 }
 
 /**
  * Retry function with exponential backoff
+ * Re-exports retryAsync for backward compatibility
+ * @deprecated Use retryAsync from asyncUtils instead
  */
-export async function retryWithBackoff<T>(
-  fn: () => Promise<T>,
-  maxRetries = 3,
-  baseDelay = 1000
-): Promise<T> {
-  let lastError: unknown;
-  
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error;
-      
-      if (attempt === maxRetries) {
-        break;
-      }
-      
-      const delay = baseDelay * 2 ** attempt;
-      await new Promise(resolve => setTimeout(resolve, delay));
-    }
-  }
-  
-  throw lastError;
-} 
+export { retryAsync as retryWithBackoff } from './asyncUtils'; 

package/src/utils/validationUtils.ts

@@ -137,6 +137,20 @@ export function sanitizeHTML(input: string): string {
     .replace(/'/g, ''');
 }
 
+/**
+ * Validate MongoDB ObjectId format
+ * Note: This is a basic format check. For full validation, use mongoose.Types.ObjectId.isValid()
+ * This function works in environments where mongoose may not be available (e.g., client-side)
+ */
+export function isValidObjectId(id: string): boolean {
+  if (typeof id !== 'string') {
+    return false;
+  }
+  // MongoDB ObjectId is 24 hex characters
+  const OBJECT_ID_REGEX = /^[0-9a-fA-F]{24}$/;
+  return OBJECT_ID_REGEX.test(id);
+}
+
 /**
  * Validate and sanitize user input
  */