perspectapi-ts-sdk 1.1.1

package/src/utils/http-client.ts

@@ -0,0 +1,268 @@
+/**
+ * HTTP Client for PerspectAPI SDK
+ * Cloudflare Workers compatible - uses native fetch API
+ */
+
+import type { 
+  ApiResponse, 
+  ApiError, 
+  RequestOptions, 
+  PerspectApiConfig 
+} from '../types';
+
+export class HttpClient {
+  private baseUrl: string;
+  private defaultHeaders: Record<string, string>;
+  private timeout: number;
+  private retries: number;
+
+  constructor(config: PerspectApiConfig) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, ''); // Remove trailing slash
+    this.timeout = config.timeout || 30000;
+    this.retries = config.retries || 3;
+    
+    this.defaultHeaders = {
+      'Content-Type': 'application/json',
+      'User-Agent': 'perspectapi-ts-sdk/1.0.0',
+      ...config.headers,
+    };
+
+    // Add authentication headers
+    if (config.apiKey) {
+      this.defaultHeaders['X-API-Key'] = config.apiKey;
+    }
+    if (config.jwt) {
+      this.defaultHeaders['Authorization'] = `Bearer ${config.jwt}`;
+    }
+  }
+
+  /**
+   * Update authentication token
+   */
+  setAuth(jwt: string) {
+    this.defaultHeaders['Authorization'] = `Bearer ${jwt}`;
+  }
+
+  /**
+   * Update API key
+   */
+  setApiKey(apiKey: string) {
+    this.defaultHeaders['X-API-Key'] = apiKey;
+  }
+
+  /**
+   * Remove authentication
+   */
+  clearAuth() {
+    delete this.defaultHeaders['Authorization'];
+    delete this.defaultHeaders['X-API-Key'];
+  }
+
+  /**
+   * Make HTTP request with retry logic
+   */
+  async request<T = any>(
+    endpoint: string,
+    options: RequestOptions = {}
+  ): Promise<ApiResponse<T>> {
+    const url = this.buildUrl(endpoint, options.params);
+    const requestOptions = this.buildRequestOptions(options);
+
+    // Log the full request details
+    console.log(`[HTTP Client] Making ${options.method || 'GET'} request to: ${url}`);
+    console.log(`[HTTP Client] Base URL: ${this.baseUrl}`);
+    console.log(`[HTTP Client] Endpoint: ${endpoint}`);
+    console.log(`[HTTP Client] Full URL: ${url}`);
+    if (options.params) {
+      console.log(`[HTTP Client] Query params:`, options.params);
+    }
+
+    let lastError: Error;
+    
+    for (let attempt = 0; attempt <= this.retries; attempt++) {
+      try {
+        const response = await this.fetchWithTimeout(url, requestOptions);
+        return await this.handleResponse<T>(response);
+      } catch (error) {
+        lastError = error as Error;
+        
+        // Don't retry on client errors (4xx)
+        if (error && typeof error === 'object' && 'status' in error && 
+            typeof (error as any).status === 'number' && (error as any).status < 500) {
+          throw error;
+        }
+        
+        // Don't retry on last attempt
+        if (attempt === this.retries) {
+          break;
+        }
+        
+        // Exponential backoff
+        await this.delay(Math.pow(2, attempt) * 1000);
+      }
+    }
+    
+    throw lastError!;
+  }
+
+  /**
+   * GET request
+   */
+  async get<T = any>(endpoint: string, params?: Record<string, any>): Promise<ApiResponse<T>> {
+    return this.request<T>(endpoint, { method: 'GET', params });
+  }
+
+  /**
+   * POST request
+   */
+  async post<T = any>(endpoint: string, body?: any): Promise<ApiResponse<T>> {
+    return this.request<T>(endpoint, { method: 'POST', body });
+  }
+
+  /**
+   * PUT request
+   */
+  async put<T = any>(endpoint: string, body?: any): Promise<ApiResponse<T>> {
+    return this.request<T>(endpoint, { method: 'PUT', body });
+  }
+
+  /**
+   * DELETE request
+   */
+  async delete<T = any>(endpoint: string): Promise<ApiResponse<T>> {
+    return this.request<T>(endpoint, { method: 'DELETE' });
+  }
+
+  /**
+   * PATCH request
+   */
+  async patch<T = any>(endpoint: string, body?: any): Promise<ApiResponse<T>> {
+    return this.request<T>(endpoint, { method: 'PATCH', body });
+  }
+
+  /**
+   * Build full URL with query parameters
+   */
+  private buildUrl(endpoint: string, params?: Record<string, any>): string {
+    const url = `${this.baseUrl}${endpoint.startsWith('/') ? '' : '/'}${endpoint}`;
+    
+    if (!params || Object.keys(params).length === 0) {
+      return url;
+    }
+
+    const searchParams = new URLSearchParams();
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== undefined && value !== null) {
+        searchParams.append(key, String(value));
+      }
+    });
+
+    return `${url}?${searchParams.toString()}`;
+  }
+
+  /**
+   * Build request options
+   */
+  private buildRequestOptions(options: RequestOptions): RequestInit {
+    const headers = {
+      ...this.defaultHeaders,
+      ...options.headers,
+    };
+
+    const requestOptions: RequestInit = {
+      method: options.method || 'GET',
+      headers,
+    };
+
+    if (options.body && options.method !== 'GET') {
+      if (typeof options.body === 'string') {
+        requestOptions.body = options.body;
+      } else {
+        requestOptions.body = JSON.stringify(options.body);
+      }
+    }
+
+    return requestOptions;
+  }
+
+  /**
+   * Fetch with timeout support
+   */
+  private async fetchWithTimeout(url: string, options: RequestInit): Promise<Response> {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal,
+      });
+      return response;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+
+  /**
+   * Handle response and errors
+   */
+  private async handleResponse<T>(response: Response): Promise<ApiResponse<T>> {
+    const contentType = response.headers.get('content-type');
+    const isJson = contentType?.includes('application/json');
+
+    let data: any;
+    try {
+      data = isJson ? await response.json() : await response.text();
+    } catch (error) {
+      data = null;
+    }
+
+    if (!response.ok) {
+      const error: ApiError = {
+        message: data?.error || data?.message || `HTTP ${response.status}: ${response.statusText}`,
+        status: response.status,
+        code: data?.code,
+        details: data,
+      };
+      throw error;
+    }
+
+    // Handle different response formats
+    if (isJson && typeof data === 'object') {
+      // If response has data property, return as-is
+      if ('data' in data || 'message' in data || 'error' in data) {
+        return data as ApiResponse<T>;
+      }
+      // Otherwise wrap in data property
+      return { data: data as T, success: true };
+    }
+
+    return { data: data as T, success: true };
+  }
+
+  /**
+   * Delay utility for retries
+   */
+  private delay(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+
+/**
+ * Create API Error from unknown error
+ */
+export function createApiError(error: unknown): ApiError {
+  if (error instanceof Error) {
+    return error as ApiError;
+  }
+  
+  // Check if it's already an ApiError-like object
+  if (error && typeof error === 'object' && 'message' in error) {
+    return error as ApiError;
+  }
+  
+  return {
+    message: 'Unknown error occurred',
+    details: error,
+  };
+}