CRM & ERP Integration Showcase

class APIClient {
  constructor(baseURL, options = {}) {
    this.baseURL = baseURL;
    this.timeout = options.timeout || 30000;
    this.retries = options.retries || 3;
    this.backoffMs = options.backoffMs || 1000;
  }

  async request(endpoint, options = {}) {
    let lastError;

    for (let attempt = 1; attempt <= this.retries; attempt++) {
      try {
        const controller = new AbortController();
        const timeoutId = setTimeout(
          () => controller.abort(),
          this.timeout
        );

        const response = await fetch(`${this.baseURL}${endpoint}`, {
          ...options,
          signal: controller.signal,
          headers: {
            'Content-Type': 'application/json',
            ...options.headers
          }
        });

        clearTimeout(timeoutId);

        if (!response.ok) {
          throw new APIError(response.status, await response.text());
        }

        return await response.json();

      } catch (error) {
        lastError = error;

        if (error.name === 'AbortError') {
          console.warn(`Request timeout, attempt ${attempt}/${this.retries}`);
        }

        if (attempt < this.retries && this.isRetryable(error)) {
          await this.sleep(this.backoffMs * Math.pow(2, attempt - 1));
          continue;
        }

        throw error;
      }
    }
  }

  isRetryable(error) {
    if (error.name === 'AbortError') return true;
    if (error instanceof APIError) {
      return [408, 429, 500, 502, 503, 504].includes(error.status);
    }
    return error.code === 'ECONNRESET' || error.code === 'ETIMEDOUT';
  }

  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

const express = require('express');
const helmet = require('helmet');
const cors = require('cors');

function createServer(config = {}) {
  const app = express();

  // Security middleware
  app.use(helmet());
  app.use(cors(config.corsOptions));
  app.use(express.json({ limit: '10mb' }));

  // Request ID for tracing
  app.use((req, res, next) => {
    req.id = req.headers['x-request-id'] || crypto.randomUUID();
    res.setHeader('x-request-id', req.id);
    next();
  });

  // Request logging
  app.use((req, res, next) => {
    const start = Date.now();
    res.on('finish', () => {
      logger.info({
        requestId: req.id,
        method: req.method,
        path: req.path,
        status: res.statusCode,
        duration: Date.now() - start
      });
    });
    next();
  });

  // Global error handler
  app.use((err, req, res, next) => {
    const status = err.status || 500;
    const isOperational = err.isOperational || false;

    logger.error({
      requestId: req.id,
      error: err.message,
      stack: isOperational ? undefined : err.stack,
      status
    });

    res.status(status).json({
      error: isOperational ? err.message : 'Internal server error',
      requestId: req.id
    });
  });

  // Graceful shutdown
  const server = app.listen(config.port || 3000);

  process.on('SIGTERM', async () => {
    logger.info('SIGTERM received, shutting down gracefully');
    server.close(() => {
      logger.info('Server closed');
      process.exit(0);
    });
  });

  return { app, server };
}

// Smart retry logic with exponential backoff and circuit breaker
class ResilientApiClient {
  constructor(config) {
    this.baseUrl = config.baseUrl;
    this.maxRetries = config.maxRetries || 3;
    this.baseDelay = config.baseDelay || 1000;
    this.maxDelay = config.maxDelay || 30000;
    this.timeout = config.timeout || 10000;

    // Circuit breaker state
    this.failures = 0;
    this.circuitOpen = false;
    this.circuitResetTime = null;
    this.failureThreshold = config.failureThreshold || 5;
    this.circuitResetTimeout = config.circuitResetTimeout || 60000;
  }

  async request(endpoint, options = {}) {
    // Check circuit breaker
    if (this.circuitOpen) {
      if (Date.now() < this.circuitResetTime) {
        throw new CircuitOpenError('Circuit breaker is open - API temporarily unavailable');
      }
      // Try to reset circuit
      this.circuitOpen = false;
    }

    let lastError;

    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
      try {
        const response = await this.executeWithTimeout(endpoint, options);

        // Success - reset failure count
        this.failures = 0;
        return response;

      } catch (error) {
        lastError = error;

        // Don't retry on client errors (4xx) except 429 (rate limit)
        if (error.status >= 400 && error.status < 500 && error.status !== 429) {
          throw error;
        }

        // Record failure for circuit breaker
        this.failures++;
        if (this.failures >= this.failureThreshold) {
          this.openCircuit();
        }

        // Calculate delay with exponential backoff + jitter
        if (attempt < this.maxRetries) {
          const delay = this.calculateDelay(attempt, error);

          await this.logRetry({
            endpoint,
            attempt: attempt + 1,
            maxRetries: this.maxRetries,
            delay,
            error: error.message,
            status: error.status
          });

          await this.sleep(delay);
        }
      }
    }

    // All retries exhausted
    await this.alertOps({
      type: 'api_failure',
      endpoint,
      error: lastError.message,
      attempts: this.maxRetries + 1,
      circuitStatus: this.circuitOpen ? 'OPEN' : 'CLOSED'
    });

    throw lastError;
  }

  async executeWithTimeout(endpoint, options) {
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), this.timeout);

    try {
      const response = await fetch(`${this.baseUrl}${endpoint}`, {
        ...options,
        signal: controller.signal,
        headers: {
          'Content-Type': 'application/json',
          ...options.headers
        }
      });

      if (!response.ok) {
        const error = new Error(`API error: ${response.status}`);
        error.status = response.status;
        error.retryAfter = response.headers.get('Retry-After');
        throw error;
      }

      return await response.json();
    } finally {
      clearTimeout(timeoutId);
    }
  }

  calculateDelay(attempt, error) {
    // Use Retry-After header if provided (rate limiting)
    if (error.retryAfter) {
      return parseInt(error.retryAfter) * 1000;
    }

    // Exponential backoff: 1s, 2s, 4s, 8s... with jitter
    const exponentialDelay = this.baseDelay * Math.pow(2, attempt);
    const jitter = Math.random() * 1000; // 0-1s random jitter

    return Math.min(exponentialDelay + jitter, this.maxDelay);
  }

  openCircuit() {
    this.circuitOpen = true;
    this.circuitResetTime = Date.now() + this.circuitResetTimeout;

    this.alertOps({
      type: 'circuit_breaker_open',
      message: 'Too many failures - circuit breaker activated',
      resetTime: new Date(this.circuitResetTime).toISOString()
    });
  }

  async logRetry(details) {
    // Log to your monitoring system
    console.log(`[RETRY] ${JSON.stringify(details)}`);
    await metrics.increment('api.retry', { endpoint: details.endpoint });
  }

  async alertOps(alert) {
    // Send to Slack, PagerDuty, etc - but batched, not spammy
    await alertService.send({
      ...alert,
      timestamp: new Date().toISOString(),
      service: this.baseUrl
    });
  }

  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

// Usage example
const salesforce = new ResilientApiClient({
  baseUrl: 'https://yourinstance.salesforce.com/services/data/v57.0',
  maxRetries: 3,
  timeout: 15000,          // 15s timeout
  failureThreshold: 5,     // Open circuit after 5 consecutive failures
  circuitResetTimeout: 60000  // Try again after 1 minute
});