navis.js 1.0.0 → 3.0.0

package/src/utils/circuit-breaker.js

@@ -0,0 +1,107 @@
+/**
+ * Circuit Breaker - Prevents cascading failures in microservices
+ * v2: Circuit breaker pattern implementation
+ */
+
+class CircuitBreaker {
+  constructor(options = {}) {
+    this.failureThreshold = options.failureThreshold || 5; // Open circuit after 5 failures
+    this.resetTimeout = options.resetTimeout || 60000; // 60 seconds
+    this.monitoringWindow = options.monitoringWindow || 10000; // 10 seconds
+    
+    this.state = 'CLOSED'; // CLOSED, OPEN, HALF_OPEN
+    this.failureCount = 0;
+    this.successCount = 0;
+    this.lastFailureTime = null;
+    this.nextAttemptTime = null;
+  }
+
+  /**
+   * Record a successful request
+   */
+  recordSuccess() {
+    if (this.state === 'HALF_OPEN') {
+      this.successCount++;
+      if (this.successCount >= 2) {
+        // Reset to CLOSED after 2 successes in HALF_OPEN
+        this.state = 'CLOSED';
+        this.failureCount = 0;
+        this.successCount = 0;
+      }
+    } else if (this.state === 'CLOSED') {
+      this.failureCount = 0; // Reset failure count on success
+    }
+  }
+
+  /**
+   * Record a failed request
+   */
+  recordFailure() {
+    this.failureCount++;
+    this.lastFailureTime = Date.now();
+
+    if (this.state === 'CLOSED' && this.failureCount >= this.failureThreshold) {
+      // Open the circuit
+      this.state = 'OPEN';
+      this.nextAttemptTime = Date.now() + this.resetTimeout;
+    } else if (this.state === 'HALF_OPEN') {
+      // Failed in half-open, go back to open
+      this.state = 'OPEN';
+      this.nextAttemptTime = Date.now() + this.resetTimeout;
+      this.successCount = 0;
+    }
+  }
+
+  /**
+   * Check if request should be allowed
+   * @returns {boolean} - true if request should proceed
+   */
+  canAttempt() {
+    if (this.state === 'CLOSED') {
+      return true;
+    }
+
+    if (this.state === 'OPEN') {
+      if (Date.now() >= this.nextAttemptTime) {
+        // Transition to HALF_OPEN
+        this.state = 'HALF_OPEN';
+        this.successCount = 0;
+        return true;
+      }
+      return false; // Circuit is open, reject request
+    }
+
+    if (this.state === 'HALF_OPEN') {
+      return true; // Allow limited requests in half-open state
+    }
+
+    return false;
+  }
+
+  /**
+   * Get current circuit state
+   */
+  getState() {
+    return {
+      state: this.state,
+      failureCount: this.failureCount,
+      successCount: this.successCount,
+      lastFailureTime: this.lastFailureTime,
+      nextAttemptTime: this.nextAttemptTime,
+    };
+  }
+
+  /**
+   * Reset circuit breaker
+   */
+  reset() {
+    this.state = 'CLOSED';
+    this.failureCount = 0;
+    this.successCount = 0;
+    this.lastFailureTime = null;
+    this.nextAttemptTime = null;
+  }
+}
+
+module.exports = CircuitBreaker;
+

package/src/utils/retry.js

@@ -0,0 +1,88 @@
+/**
+ * Retry utility with exponential backoff
+ * v2: Retry logic for resilient service calls
+ */
+
+/**
+ * Sleep for specified milliseconds
+ * @private
+ */
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Calculate exponential backoff delay
+ * @param {number} attempt - Current attempt number (0-indexed)
+ * @param {number} baseDelay - Base delay in milliseconds
+ * @param {number} maxDelay - Maximum delay in milliseconds
+ * @param {number} jitter - Random jitter factor (0-1)
+ */
+function calculateBackoff(attempt, baseDelay = 1000, maxDelay = 30000, jitter = 0.1) {
+  const exponentialDelay = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
+  const jitterAmount = exponentialDelay * jitter * Math.random();
+  return Math.floor(exponentialDelay + jitterAmount);
+}
+
+/**
+ * Retry a function with exponential backoff
+ * @param {Function} fn - Function to retry (must return a Promise)
+ * @param {Object} options - Retry options
+ * @param {number} options.maxRetries - Maximum number of retry attempts (default: 3)
+ * @param {number} options.baseDelay - Base delay in milliseconds (default: 1000)
+ * @param {number} options.maxDelay - Maximum delay in milliseconds (default: 30000)
+ * @param {number} options.jitter - Jitter factor 0-1 (default: 0.1)
+ * @param {Function} options.shouldRetry - Function to determine if error should be retried (default: retry on all errors)
+ * @returns {Promise} - Result of the function
+ */
+async function retry(fn, options = {}) {
+  const {
+    maxRetries = 3,
+    baseDelay = 1000,
+    maxDelay = 30000,
+    jitter = 0.1,
+    shouldRetry = () => true, // Retry on all errors by default
+  } = options;
+
+  let lastError;
+  
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const result = await fn();
+      return result;
+    } catch (error) {
+      lastError = error;
+
+      // Check if we should retry this error
+      if (!shouldRetry(error, attempt)) {
+        throw error;
+      }
+
+      // Don't wait after the last attempt
+      if (attempt < maxRetries) {
+        const delay = calculateBackoff(attempt, baseDelay, maxDelay, jitter);
+        await sleep(delay);
+      }
+    }
+  }
+
+  throw lastError;
+}
+
+/**
+ * Check if HTTP status code should be retried
+ * @param {number} statusCode - HTTP status code
+ * @returns {boolean} - true if status code should be retried
+ */
+function shouldRetryHttpStatus(statusCode) {
+  // Retry on 5xx errors and 429 (Too Many Requests)
+  return statusCode >= 500 || statusCode === 429;
+}
+
+module.exports = {
+  retry,
+  calculateBackoff,
+  shouldRetryHttpStatus,
+  sleep,
+};
+

package/src/utils/service-client.js

@@ -1,105 +1,235 @@
-const http = require('http');
-const https = require('https');
-
-/**
- * ServiceClient - Lightweight HTTP client for service-to-service calls
- * v1: Basic get() and post() with timeout support
- */
-
-class ServiceClient {
-  constructor(baseUrl, options = {}) {
-    this.baseUrl = baseUrl;
-    this.timeout = options.timeout || 5000; // Default 5s timeout
-    // TODO v2: Add retry logic
-    // TODO v2: Add circuit breaker
-    // TODO v2: Add config-based services
-  }
-
-  /**
-   * Make HTTP request
-   * @private
-   */
-  _request(method, path, data = null, options = {}) {
-    return new Promise((resolve, reject) => {
-      const url = new URL(path, this.baseUrl);
-      const isHttps = url.protocol === 'https:';
-      const client = isHttps ? https : http;
-
-      const requestOptions = {
-        hostname: url.hostname,
-        port: url.port || (isHttps ? 443 : 80),
-        path: url.pathname + url.search,
-        method,
-        headers: {
-          'Content-Type': 'application/json',
-          ...options.headers,
-        },
-        timeout: options.timeout || this.timeout,
-      };
-
-      const req = client.request(requestOptions, (res) => {
-        let body = '';
-
-        res.on('data', (chunk) => {
-          body += chunk;
-        });
-
-        res.on('end', () => {
-          try {
-            const parsedBody = body ? JSON.parse(body) : {};
-            resolve({
-              statusCode: res.statusCode,
-              headers: res.headers,
-              data: parsedBody,
-            });
-          } catch (err) {
-            resolve({
-              statusCode: res.statusCode,
-              headers: res.headers,
-              data: body,
-            });
-          }
-        });
-      });
-
-      req.on('error', (err) => {
-        reject(err);
-      });
-
-      req.on('timeout', () => {
-        req.destroy();
-        reject(new Error('Request timeout'));
-      });
-
-      if (data) {
-        req.write(JSON.stringify(data));
-      }
-
-      req.end();
-    });
-  }
-
-  /**
-   * GET request
-   * @param {string} path - Request path
-   * @param {Object} options - Request options
-   */
-  async get(path, options = {}) {
-    return this._request('GET', path, null, options);
-  }
-
-  /**
-   * POST request
-   * @param {string} path - Request path
-   * @param {Object} data - Request body data
-   * @param {Object} options - Request options
-   */
-  async post(path, data, options = {}) {
-    return this._request('POST', path, data, options);
-  }
-
-  // TODO v2: Add PUT, DELETE, PATCH methods
-  // TODO v2: Add service discovery integration
-}
-
+const http = require('http');
+const https = require('https');
+const CircuitBreaker = require('./circuit-breaker');
+const { retry, shouldRetryHttpStatus } = require('./retry');
+
+/**
+ * ServiceClient - Lightweight HTTP client for service-to-service calls
+ * v2: Enhanced with retry logic, circuit breaker, and additional HTTP methods
+ */
+
+class ServiceClient {
+  constructor(baseUrl, options = {}) {
+    this.baseUrl = baseUrl;
+    this.timeout = options.timeout || 5000; // Default 5s timeout
+    
+    // Retry configuration
+    this.retryConfig = {
+      maxRetries: options.maxRetries !== undefined ? options.maxRetries : 3,
+      baseDelay: options.retryBaseDelay || 1000,
+      maxDelay: options.retryMaxDelay || 30000,
+      enabled: options.retry !== false, // Enabled by default
+    };
+
+    // Circuit breaker configuration
+    this.circuitBreakerEnabled = options.circuitBreaker !== false; // Enabled by default
+    if (this.circuitBreakerEnabled) {
+      this.circuitBreaker = new CircuitBreaker({
+        failureThreshold: options.circuitBreakerThreshold || 5,
+        resetTimeout: options.circuitBreakerResetTimeout || 60000,
+      });
+    }
+  }
+
+  /**
+   * Make HTTP request (internal, without retry/circuit breaker)
+   * @private
+   */
+  _requestInternal(method, path, data = null, options = {}) {
+    return new Promise((resolve, reject) => {
+      const url = new URL(path, this.baseUrl);
+      const isHttps = url.protocol === 'https:';
+      const client = isHttps ? https : http;
+
+      const requestOptions = {
+        hostname: url.hostname,
+        port: url.port || (isHttps ? 443 : 80),
+        path: url.pathname + url.search,
+        method,
+        headers: {
+          'Content-Type': 'application/json',
+          ...options.headers,
+        },
+        timeout: options.timeout || this.timeout,
+      };
+
+      const req = client.request(requestOptions, (res) => {
+        let body = '';
+
+        res.on('data', (chunk) => {
+          body += chunk;
+        });
+
+        res.on('end', () => {
+          try {
+            const parsedBody = body ? JSON.parse(body) : {};
+            const response = {
+              statusCode: res.statusCode,
+              headers: res.headers,
+              data: parsedBody,
+            };
+            
+            // Check if response indicates failure
+            if (res.statusCode >= 400) {
+              const error = new Error(`HTTP ${res.statusCode}: ${res.statusMessage || 'Request failed'}`);
+              error.statusCode = res.statusCode;
+              error.response = response;
+              reject(error);
+            } else {
+              resolve(response);
+            }
+          } catch (err) {
+            resolve({
+              statusCode: res.statusCode,
+              headers: res.headers,
+              data: body,
+            });
+          }
+        });
+      });
+
+      req.on('error', (err) => {
+        reject(err);
+      });
+
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new Error('Request timeout'));
+      });
+
+      if (data) {
+        req.write(JSON.stringify(data));
+      }
+
+      req.end();
+    });
+  }
+
+  /**
+   * Make HTTP request with retry and circuit breaker
+   * @private
+   */
+  async _request(method, path, data = null, options = {}) {
+    // Check circuit breaker
+    if (this.circuitBreakerEnabled && this.circuitBreaker) {
+      if (!this.circuitBreaker.canAttempt()) {
+        const error = new Error('Circuit breaker is OPEN - service unavailable');
+        error.circuitBreakerOpen = true;
+        error.circuitState = this.circuitBreaker.getState();
+        throw error;
+      }
+    }
+
+    // Execute request with retry if enabled
+    const executeRequest = async () => {
+      try {
+        const result = await this._requestInternal(method, path, data, options);
+        
+        // Record success in circuit breaker
+        if (this.circuitBreakerEnabled && this.circuitBreaker) {
+          this.circuitBreaker.recordSuccess();
+        }
+        
+        return result;
+      } catch (error) {
+        // Record failure in circuit breaker
+        if (this.circuitBreakerEnabled && this.circuitBreaker) {
+          this.circuitBreaker.recordFailure();
+        }
+        throw error;
+      }
+    };
+
+    if (this.retryConfig.enabled) {
+      return retry(executeRequest, {
+        maxRetries: this.retryConfig.maxRetries,
+        baseDelay: this.retryConfig.baseDelay,
+        maxDelay: this.retryConfig.maxDelay,
+        shouldRetry: (error) => {
+          // Don't retry if circuit breaker is open
+          if (error.circuitBreakerOpen) {
+            return false;
+          }
+          // Retry on network errors or 5xx/429 status codes
+          if (error.statusCode) {
+            return shouldRetryHttpStatus(error.statusCode);
+          }
+          // Retry on network/timeout errors
+          return true;
+        },
+      });
+    }
+
+    return executeRequest();
+  }
+
+  /**
+   * GET request
+   * @param {string} path - Request path
+   * @param {Object} options - Request options
+   */
+  async get(path, options = {}) {
+    return this._request('GET', path, null, options);
+  }
+
+  /**
+   * POST request
+   * @param {string} path - Request path
+   * @param {Object} data - Request body data
+   * @param {Object} options - Request options
+   */
+  async post(path, data, options = {}) {
+    return this._request('POST', path, data, options);
+  }
+
+  /**
+   * PUT request
+   * @param {string} path - Request path
+   * @param {Object} data - Request body data
+   * @param {Object} options - Request options
+   */
+  async put(path, data, options = {}) {
+    return this._request('PUT', path, data, options);
+  }
+
+  /**
+   * DELETE request
+   * @param {string} path - Request path
+   * @param {Object} options - Request options
+   */
+  async delete(path, options = {}) {
+    return this._request('DELETE', path, null, options);
+  }
+
+  /**
+   * PATCH request
+   * @param {string} path - Request path
+   * @param {Object} data - Request body data
+   * @param {Object} options - Request options
+   */
+  async patch(path, data, options = {}) {
+    return this._request('PATCH', path, data, options);
+  }
+
+  /**
+   * Get circuit breaker state
+   * @returns {Object} - Circuit breaker state information
+   */
+  getCircuitBreakerState() {
+    if (!this.circuitBreakerEnabled || !this.circuitBreaker) {
+      return null;
+    }
+    return this.circuitBreaker.getState();
+  }
+
+  /**
+   * Reset circuit breaker
+   */
+  resetCircuitBreaker() {
+    if (this.circuitBreakerEnabled && this.circuitBreaker) {
+      this.circuitBreaker.reset();
+    }
+  }
+}
+
 module.exports = ServiceClient;

package/src/utils/service-config.js

@@ -0,0 +1,88 @@
+/**
+ * Service Configuration Manager
+ * v2: Config-based service management for microservices
+ */
+
+class ServiceConfig {
+  constructor(config = {}) {
+    this.services = config.services || {};
+    this.defaultOptions = config.defaultOptions || {
+      timeout: 5000,
+      retry: {
+        maxRetries: 3,
+        baseDelay: 1000,
+        maxDelay: 30000,
+      },
+      circuitBreaker: {
+        failureThreshold: 5,
+        resetTimeout: 60000,
+      },
+    };
+  }
+
+  /**
+   * Register a service
+   * @param {string} name - Service name
+   * @param {string} baseUrl - Service base URL
+   * @param {Object} options - Service-specific options
+   */
+  register(name, baseUrl, options = {}) {
+    this.services[name] = {
+      baseUrl,
+      ...this.defaultOptions,
+      ...options,
+    };
+  }
+
+  /**
+   * Get service configuration
+   * @param {string} name - Service name
+   * @returns {Object|null} - Service configuration or null if not found
+   */
+  get(name) {
+    return this.services[name] || null;
+  }
+
+  /**
+   * Get all registered services
+   * @returns {Object} - All service configurations
+   */
+  getAll() {
+    return { ...this.services };
+  }
+
+  /**
+   * Remove a service
+   * @param {string} name - Service name
+   */
+  unregister(name) {
+    delete this.services[name];
+  }
+
+  /**
+   * Load services from configuration object
+   * @param {Object} config - Configuration object with services
+   */
+  load(config) {
+    if (config.services) {
+      this.services = { ...this.services, ...config.services };
+    }
+    if (config.defaultOptions) {
+      this.defaultOptions = { ...this.defaultOptions, ...config.defaultOptions };
+    }
+  }
+
+  /**
+   * Export current configuration
+   * @returns {Object} - Current configuration
+   */
+  export() {
+    return {
+      services: this.services,
+      defaultOptions: this.defaultOptions,
+    };
+  }
+}
+
+module.exports = ServiceConfig;
+