@appliqation/automation-sdk 2.1.0

package/src/core/HttpClient.js

@@ -0,0 +1,475 @@
+const axios = require('axios');
+const https = require('https');
+const http = require('http');
+const logger = require('../utils/logger');
+const {
+  DEFAULT_TIMEOUT,
+  DEFAULT_RETRIES,
+  DEFAULT_RETRY_DELAY,
+  MAX_RETRY_DELAY,
+  RETRY_JITTER_FACTOR,
+  BACKOFF_MULTIPLIER,
+  DEFAULT_KEEP_ALIVE,
+  DEFAULT_MAX_SOCKETS,
+  DEFAULT_MAX_FREE_SOCKETS,
+  DEFAULT_KEEP_ALIVE_MSECS,
+  HTTP_TOO_MANY_REQUESTS,
+  HTTP_REQUEST_TIMEOUT,
+  HTTP_SERVER_ERROR_THRESHOLD
+} = require('../constants');
+
+/**
+ * Generic HTTP client for making requests to Appliqation API
+ */
+class HttpClient {
+  constructor(config, auth = null) {
+    this.config = {
+      baseUrl: config.baseUrl,
+      timeout: config.timeout || DEFAULT_TIMEOUT,
+      retries: config.retries || DEFAULT_RETRIES,
+      retryDelay: config.retryDelay || DEFAULT_RETRY_DELAY,
+      rejectUnauthorized: config.rejectUnauthorized !== undefined ? config.rejectUnauthorized : true, // Default to secure
+      // Connection pooling settings
+      keepAlive: config.keepAlive !== undefined ? config.keepAlive : DEFAULT_KEEP_ALIVE,
+      maxSockets: config.maxSockets || DEFAULT_MAX_SOCKETS,
+      maxFreeSockets: config.maxFreeSockets || DEFAULT_MAX_FREE_SOCKETS,
+      keepAliveMsecs: config.keepAliveMsecs || DEFAULT_KEEP_ALIVE_MSECS,
+      ...config
+    };
+
+    // Validate required baseUrl
+    if (!this.config.baseUrl) {
+      throw new Error('baseUrl is required. Please set APPLIQATION_BASE_URL environment variable or provide baseUrl in configuration.');
+    }
+
+    // Store auth manager reference
+    this.auth = auth;
+
+    // Create HTTP/HTTPS agents with connection pooling
+    const agentOptions = {
+      keepAlive: this.config.keepAlive,
+      maxSockets: this.config.maxSockets,
+      maxFreeSockets: this.config.maxFreeSockets,
+      keepAliveMsecs: this.config.keepAliveMsecs,
+      rejectUnauthorized: this.config.rejectUnauthorized
+    };
+
+    this.httpAgent = new http.Agent(agentOptions);
+    this.httpsAgent = new https.Agent(agentOptions);
+
+    logger.debug('HTTP connection pooling configured', {
+      keepAlive: agentOptions.keepAlive,
+      maxSockets: agentOptions.maxSockets,
+      maxFreeSockets: agentOptions.maxFreeSockets
+    });
+
+    this.axios = axios.create({
+      baseURL: this.config.baseUrl,
+      timeout: this.config.timeout,
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json'
+      },
+      // Use connection pooling agents
+      httpAgent: this.httpAgent,
+      httpsAgent: this.httpsAgent
+    });
+
+    this.setupInterceptors();
+
+    // Set API key if provided in config
+    if (this.config.apiKey) {
+      this.setApiKey(this.config.apiKey);
+      logger.debug('API key set in HttpClient');
+    }
+  }
+
+  setupInterceptors() {
+    // Response interceptor for error handling and JWT refresh
+    this.axios.interceptors.response.use(
+      (response) => response,
+      async (error) => {
+        const originalRequest = error.config;
+
+        // Handle 401 errors with automatic JWT token refresh
+        if (error.response?.status === 401 &&
+            this.auth &&
+            this.auth.hasApiKey() &&
+            !originalRequest._retry) {
+
+          // Mark this request as already retried to prevent infinite loops
+          originalRequest._retry = true;
+
+          logger.info('401 Unauthorized detected - attempting JWT token refresh...', {
+            url: originalRequest.url,
+            method: originalRequest.method
+          });
+
+          try {
+            // Attempt to refresh JWT token using AuthManager
+            await this.auth.refreshJwtToken();
+
+            logger.info('JWT token refreshed successfully, retrying original request');
+
+            // Retry the original request with the new token
+            return this.axios(originalRequest);
+          } catch (refreshError) {
+            logger.error('Failed to refresh JWT token', {
+              error: refreshError.message,
+              originalUrl: originalRequest.url
+            });
+
+            // If refresh fails, reject with the refresh error
+            return Promise.reject(refreshError);
+          }
+        }
+
+        // For non-401 errors or when refresh is not applicable, log and reject
+        if (error.response?.status === 401) {
+          logger.warn('Authentication failed (401) - JWT refresh not available or already attempted');
+        }
+
+        return Promise.reject(error);
+      }
+    );
+  }
+
+  /**
+   * Make a GET request
+   * @param {string} url - The URL path
+   * @param {Object} config - Axios config options
+   * @returns {Promise<Object>} Response data
+   */
+  async get(url, config = {}) {
+    try {
+      logger.debug(`GET ${url}`);
+      const response = await this.retryRequest(() =>
+        this.axios.get(url, config)
+      );
+      return {
+        success: true,
+        data: response.data,
+        status: response.status,
+        headers: response.headers
+      };
+    } catch (error) {
+      return this.handleError(error, 'GET', url);
+    }
+  }
+
+  /**
+   * Make a POST request
+   * @param {string} url - The URL path
+   * @param {Object} data - Request body
+   * @param {Object} config - Axios config options
+   * @returns {Promise<Object>} Response data
+   */
+  async post(url, data, config = {}) {
+    const startTime = Date.now();
+    try {
+      logger.debug(`POST ${url}`, { dataSize: JSON.stringify(data).length });
+      logger.debug(`POST request starting at ${new Date().toISOString()}`);
+
+      // Detailed logging for debugging project key issues
+      logger.debug(`POST ${url} - Request Body:`, JSON.stringify(data, null, 2));
+      logger.debug(`POST ${url} - Request Headers:`, JSON.stringify(this.axios.defaults.headers.common, null, 2));
+
+      const response = await this.retryRequest(() =>
+        this.axios.post(url, data, config)
+      );
+
+      const duration = Date.now() - startTime;
+      logger.debug(`POST ${url} completed in ${duration}ms`, {
+        status: response.status,
+        timestamp: new Date().toISOString()
+      });
+
+      // Detailed response logging
+      logger.debug(`POST ${url} - Response Status: ${response.status}`);
+      logger.debug(`POST ${url} - Response Body:`, JSON.stringify(response.data, null, 2));
+
+      return {
+        success: true,
+        data: response.data,
+        status: response.status,
+        headers: response.headers
+      };
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      logger.error(`POST ${url} failed after ${duration}ms`);
+      logger.error(`POST ${url} - Error Details:`, {
+        message: error.message,
+        status: error.response?.status,
+        statusText: error.response?.statusText,
+        responseData: error.response?.data
+      });
+      return this.handleError(error, 'POST', url);
+    }
+  }
+
+  /**
+   * Make a PUT request
+   * @param {string} url - The URL path
+   * @param {Object} data - Request body
+   * @param {Object} config - Axios config options
+   * @returns {Promise<Object>} Response data
+   */
+  async put(url, data, config = {}) {
+    try {
+      logger.debug(`PUT ${url}`);
+      const response = await this.retryRequest(() =>
+        this.axios.put(url, data, config)
+      );
+      return {
+        success: true,
+        data: response.data,
+        status: response.status,
+        headers: response.headers
+      };
+    } catch (error) {
+      return this.handleError(error, 'PUT', url);
+    }
+  }
+
+  /**
+   * Make a DELETE request
+   * @param {string} url - The URL path
+   * @param {Object} config - Axios config options
+   * @returns {Promise<Object>} Response data
+   */
+  async delete(url, config = {}) {
+    try {
+      logger.debug(`DELETE ${url}`);
+      const response = await this.retryRequest(() =>
+        this.axios.delete(url, config)
+      );
+      return {
+        success: true,
+        data: response.data,
+        status: response.status,
+        headers: response.headers
+      };
+    } catch (error) {
+      return this.handleError(error, 'DELETE', url);
+    }
+  }
+
+  /**
+   * Set authorization header
+   * @param {string} token - Authorization token
+   */
+  setAuthToken(token) {
+    if (token) {
+      this.axios.defaults.headers.common['Authorization'] = `Bearer ${token}`;
+    } else {
+      delete this.axios.defaults.headers.common['Authorization'];
+    }
+  }
+
+  /**
+   * Set API key header
+   * @param {string} apiKey - API key
+   */
+  setApiKey(apiKey) {
+    if (apiKey) {
+      this.axios.defaults.headers.common['X-API-Key'] = apiKey;
+    } else {
+      delete this.axios.defaults.headers.common['X-API-Key'];
+    }
+  }
+
+  /**
+   * Set custom header
+   * @param {string} key - Header name
+   * @param {string} value - Header value
+   */
+  setHeader(key, value) {
+    if (value) {
+      this.axios.defaults.headers.common[key] = value;
+    } else {
+      delete this.axios.defaults.headers.common[key];
+    }
+  }
+
+  /**
+   * Retry a request with exponential backoff
+   * @param {Function} requestFn - The request function to retry
+   * @param {number} attempt - Current attempt number
+   * @returns {Promise<Object>} Response
+   */
+  async retryRequest(requestFn, attempt = 1) {
+    try {
+      return await requestFn();
+    } catch (error) {
+      if (attempt < this.config.retries && this.shouldRetry(error)) {
+        const delay = this.calculateBackoff(attempt);
+
+        logger.warn(`Request failed, retrying... (${attempt}/${this.config.retries})`, {
+          error: error.message,
+          retryAfterMs: delay,
+          attempt: attempt
+        });
+
+        await this.delay(delay);
+        return this.retryRequest(requestFn, attempt + 1);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Calculate exponential backoff delay with jitter
+   * Formula: min(maxDelay, baseDelay * (2 ^ attempt)) + random jitter
+   * @param {number} attempt - Current retry attempt (1-indexed)
+   * @returns {number} Delay in milliseconds
+   */
+  calculateBackoff(attempt) {
+    const baseDelay = this.config.retryDelay || DEFAULT_RETRY_DELAY;
+    const maxDelay = this.config.maxRetryDelay || MAX_RETRY_DELAY;
+    const jitterFactor = this.config.retryJitter !== undefined ? this.config.retryJitter : RETRY_JITTER_FACTOR;
+
+    // Exponential backoff: baseDelay * (BACKOFF_MULTIPLIER ^ (attempt - 1))
+    // attempt 1: 1000 * 1 = 1000ms
+    // attempt 2: 1000 * 2 = 2000ms
+    // attempt 3: 1000 * 4 = 4000ms
+    const exponentialDelay = baseDelay * Math.pow(BACKOFF_MULTIPLIER, attempt - 1);
+
+    // Cap at maxDelay
+    const cappedDelay = Math.min(exponentialDelay, maxDelay);
+
+    // Add random jitter to prevent thundering herd
+    // jitter range: -jitterFactor to +jitterFactor
+    const jitter = cappedDelay * jitterFactor * (2 * Math.random() - 1);
+    const finalDelay = Math.max(0, Math.round(cappedDelay + jitter));
+
+    logger.debug('Backoff calculated', {
+      attempt,
+      baseDelay,
+      exponentialDelay,
+      cappedDelay,
+      jitter: Math.round(jitter),
+      finalDelay
+    });
+
+    return finalDelay;
+  }
+
+  /**
+   * Determine if request should be retried
+   * @param {Error} error - The error object
+   * @returns {boolean} True if should retry
+   */
+  shouldRetry(error) {
+    // Don't retry 4xx client errors (except 429 Too Many Requests and 408 Timeout)
+    if (error.response) {
+      const status = error.response.status;
+
+      // Retry server errors (5xx)
+      if (status >= HTTP_SERVER_ERROR_THRESHOLD) {
+        return true;
+      }
+
+      // Retry specific 4xx errors
+      if (status === HTTP_TOO_MANY_REQUESTS || status === HTTP_REQUEST_TIMEOUT) {
+        return true;
+      }
+
+      // Don't retry other 4xx errors
+      return false;
+    }
+
+    // Retry network errors (no response)
+    return true;
+  }
+
+  /**
+   * Delay for specified milliseconds
+   * @param {number} ms - Milliseconds to delay
+   * @returns {Promise<void>}
+   */
+  delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Handle error responses
+   * @param {Error} error - The error object
+   * @param {string} method - HTTP method
+   * @param {string} url - Request URL
+   * @returns {Object} Error response
+   */
+  handleError(error, method, url) {
+    const errorInfo = {
+      method,
+      url,
+      message: error.message,
+      status: error.response?.status || 500,
+      data: error.response?.data || null
+    };
+
+    logger.error(`HTTP ${method} failed: ${url}`, errorInfo);
+
+    // Re-throw error with preserved response data for upstream handlers
+    const enhancedError = new Error(error.message);
+    enhancedError.response = error.response; // Preserve full response for detailed error handling
+    enhancedError.status = errorInfo.status;
+    enhancedError.data = errorInfo.data;
+
+    throw enhancedError;
+  }
+
+  /**
+   * Test connection to server
+   * @returns {Promise<Object>} Connection test result
+   */
+  async testConnection() {
+    try {
+      const response = await this.axios.get('/');
+      return {
+        success: true,
+        message: 'Connection successful',
+        status: response.status
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Connection failed: ${error.message}`,
+        status: error.response?.status || 500
+      };
+    }
+  }
+
+  /**
+   * Get HTTP client statistics
+   * @returns {Object} Client stats
+   */
+  getStats() {
+    return {
+      baseUrl: this.config.baseUrl,
+      timeout: this.config.timeout,
+      retries: this.config.retries,
+      retryDelay: this.config.retryDelay,
+      keepAlive: this.config.keepAlive,
+      maxSockets: this.config.maxSockets,
+      maxFreeSockets: this.config.maxFreeSockets
+    };
+  }
+
+  /**
+   * Cleanup and destroy HTTP agents
+   * Closes all open connections in the pool
+   */
+  destroy() {
+    logger.debug('Destroying HTTP client and closing connection pools');
+
+    if (this.httpAgent) {
+      this.httpAgent.destroy();
+    }
+
+    if (this.httpsAgent) {
+      this.httpsAgent.destroy();
+    }
+  }
+}
+
+module.exports = HttpClient;