@oxyhq/services 5.13.25 → 5.13.27

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

@@ -22,8 +22,8 @@
  * const file = fileInput.files[0];
  * await oxy.uploadRawFile(file);
  *
- * // Get a file stream URL for <img src>
- * const url = oxy.getFileStreamUrl('fileId');
+ * // Get a file download URL for <img src>
+ * const url = oxy.getFileDownloadUrl('fileId', 'thumb');
  * ```
  *
  * ## Node.js (CommonJS/TypeScript)
@@ -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

@@ -66,13 +66,6 @@ export function OxyServicesAssetsMixin<T extends typeof OxyServicesBase>(Base: T
       }
     }
 
-    /**
-     * Get file stream URL (direct Oxy Cloud/CDN URL, no token)
-     */
-    getFileStreamUrl(fileId: string): string {
-      return `${this.getCloudURL()}/files/${fileId}/stream`;
-    }
-
     /**
      * List user files
      */
@@ -235,11 +228,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/index.ts

@@ -97,6 +97,7 @@ export { useAuthStore } from './ui/stores/authStore';
 export { useAssetStore, useAssets as useAssetsStore, useAsset, useUploadProgress, useAssetLoading, useAssetErrors, useAssetsByApp, useAssetsByEntity, useAssetUsageCount, useIsAssetLinked } from './ui/stores/assetStore';
 export { useSessionSocket } from './ui/hooks/useSessionSocket';
 export { useAssets, setOxyAssetInstance } from './ui/hooks/useAssets';
+export { useFileDownloadUrl, setOxyFileUrlInstance } from './ui/hooks/useFileDownloadUrl';
 
 // UI components
 export { OxySignInButton } from './ui/components/OxySignInButton';

package/src/ui/components/ProfileCard.tsx

@@ -4,6 +4,7 @@ import { Ionicons } from '@expo/vector-icons';
 import { useI18n } from '../hooks/useI18n';
 import Avatar from './Avatar';
 import { useOxy } from '../context/OxyContext';
+import { useFileDownloadUrl } from '../hooks';
 import { fontFamilies } from '../styles/fonts';
 
 interface ProfileCardProps {
@@ -33,6 +34,8 @@ const ProfileCard: React.FC<ProfileCardProps> = ({
     const secondaryBackgroundColor = isDarkTheme ? '#222222' : '#FFFFFF';
     const primaryColor = '#0066CC';
 
+    const avatarUrl = useFileDownloadUrl(user?.avatar, { variant: 'thumb' }).url || undefined;
+
     return (
         <View style={styles.headerSection}>
             <View style={[
@@ -43,7 +46,7 @@ const ProfileCard: React.FC<ProfileCardProps> = ({
             ]}>
                 <View style={styles.userProfile}>
                     <Avatar
-                        uri={user?.avatar ? oxyServices.getFileDownloadUrl(user.avatar as string, 'thumb') : undefined}
+                        uri={user?.avatar ? avatarUrl : undefined}
                         name={user?.name?.full || user?.username}
                         size={60}
                         theme={theme}

package/src/ui/hooks/index.ts

@@ -1 +1,2 @@
-export { useFollow, useFollowerCounts } from './useFollow'; 
+export { useFollow, useFollowerCounts } from './useFollow';
+export { useFileDownloadUrl, setOxyFileUrlInstance } from './useFileDownloadUrl';

package/src/ui/hooks/useFileDownloadUrl.ts

@@ -0,0 +1,118 @@
+import { useEffect, useState } from 'react';
+import { OxyServices } from '../../core/OxyServices';
+
+let oxyInstance: OxyServices | null = null;
+
+export const setOxyFileUrlInstance = (instance: OxyServices) => {
+  oxyInstance = instance;
+};
+
+export interface UseFileDownloadUrlOptions {
+  variant?: string;
+  expiresIn?: number;
+}
+
+export interface UseFileDownloadUrlResult {
+  url: string | null;
+  loading: boolean;
+  error: Error | null;
+}
+
+/**
+ * Hook to resolve a file's download URL asynchronously.
+ *
+ * Prefers `getFileDownloadUrlAsync` and falls back to the synchronous
+ * `getFileDownloadUrl` helper if the async call fails.
+ */
+export const useFileDownloadUrl = (
+  fileId?: string | null,
+  options?: UseFileDownloadUrlOptions
+): UseFileDownloadUrlResult => {
+  const [url, setUrl] = useState<string | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    if (!fileId) {
+      setUrl(null);
+      setLoading(false);
+      setError(null);
+      return;
+    }
+
+    if (!oxyInstance) {
+      // Fail silently but don't crash the UI – caller can decide what to do with null URL.
+      setUrl(null);
+      setLoading(false);
+      setError(new Error('OxyServices instance not configured for useFileDownloadUrl'));
+      return;
+    }
+
+    let cancelled = false;
+
+    const load = async () => {
+      setLoading(true);
+      setError(null);
+
+      // Store instance in local variable for TypeScript null checking
+      const instance = oxyInstance;
+      if (!instance) {
+        setLoading(false);
+        setError(new Error('OxyServices instance not configured for useFileDownloadUrl'));
+        return;
+      }
+
+      try {
+        const { variant, expiresIn } = options || {};
+        let resolvedUrl: string | null = null;
+
+        if (typeof instance.getFileDownloadUrlAsync === 'function') {
+          resolvedUrl = await instance.getFileDownloadUrlAsync(fileId, variant, expiresIn);
+        }
+
+        if (!resolvedUrl && typeof instance.getFileDownloadUrl === 'function') {
+          resolvedUrl = instance.getFileDownloadUrl(fileId, variant, expiresIn);
+        }
+
+        if (!cancelled) {
+          setUrl(resolvedUrl || null);
+        }
+      } catch (err: any) {
+        // Fallback to sync URL on error where possible
+        try {
+          if (typeof instance.getFileDownloadUrl === 'function') {
+            const { variant, expiresIn } = options || {};
+            const fallbackUrl = instance.getFileDownloadUrl(fileId, variant, expiresIn);
+            if (!cancelled) {
+              setUrl(fallbackUrl || null);
+              setError(err instanceof Error ? err : new Error(String(err)));
+            }
+            return;
+          }
+        } catch {
+          // ignore secondary failure, we'll surface the original error below
+        }
+
+        if (!cancelled) {
+          setError(err instanceof Error ? err : new Error(String(err)));
+        }
+      } finally {
+        if (!cancelled) {
+          setLoading(false);
+        }
+      }
+    };
+
+    load();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [fileId, options?.variant, options?.expiresIn]);
+
+  return { url, loading, error };
+};
+
+
+
+

package/src/ui/screens/AccountOverviewScreen.tsx

@@ -420,7 +420,10 @@ const AccountOverviewScreen: React.FC<BaseScreenProps> = ({
                                         <>
                                             <View style={styles.userIcon}>
                                                 {account.avatar ? (
-                                                    <Image source={{ uri: oxyServices.getFileStreamUrl(account.avatar as string) }} style={styles.accountAvatarImage} />
+                                                    <Image
+                                                        source={{ uri: oxyServices.getFileDownloadUrl(account.avatar as string, 'thumb') }}
+                                                        style={styles.accountAvatarImage}
+                                                    />
                                                 ) : (
                                                     <View style={styles.accountAvatarFallback}>
                                                         <Text style={styles.accountAvatarText}>

package/src/ui/screens/karma/KarmaFAQScreen.tsx

@@ -1,14 +1,10 @@
 import React, { useState, useMemo, useCallback } from 'react';
-import { View, Text, StyleSheet, ScrollView, Platform, TouchableOpacity, TextInput, LayoutAnimation, UIManager } from 'react-native';
+import { View, Text, StyleSheet, ScrollView, Platform, TouchableOpacity, TextInput, LayoutAnimation } from 'react-native';
 import type { BaseScreenProps } from '../../navigation/types';
 import { Ionicons } from '@expo/vector-icons';
 import { Header } from '../../components';
 import { useI18n } from '../../hooks/useI18n';
 
-if (Platform.OS === 'android' && UIManager.setLayoutAnimationEnabledExperimental) {
-    UIManager.setLayoutAnimationEnabledExperimental(true);
-}
-
 const FAQ_KEYS = ['what', 'earn', 'lose', 'use', 'transfer', 'support'] as const;
 
 /**

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',
+    });
   }
 }