Diseño de API Gateway

// API Gateway routing configuration (conceptual)
interface RouteConfig {
  path: string;
  method: string;
  upstream: string;
  middleware: string[];
}

const routes: RouteConfig[] = [
  {
    path: '/api/users/*',
    method: 'ALL',
    upstream: 'http://user-service:3001',
    middleware: ['auth', 'rateLimit', 'logging'],
  },
  {
    path: '/api/orders/*',
    method: 'ALL',
    upstream: 'http://order-service:3002',
    middleware: ['auth', 'rateLimit', 'logging'],
  },
  {
    path: '/api/products/*',
    method: 'GET',
    upstream: 'http://product-service:3003',
    middleware: ['cache', 'rateLimit', 'logging'], // No auth for public product listing
  },
];

// Authentication middleware in API gateway
import jwt from 'jsonwebtoken';

async function authMiddleware(req: Request, res: Response, next: NextFunction) {
  const token = req.headers.authorization?.replace('Bearer ', '');

  if (!token) {
    return res.status(401).json({ error: 'Authentication required' });
  }

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET!);

    // Attach user info to headers for downstream services
    req.headers['x-user-id'] = decoded.userId;
    req.headers['x-user-role'] = decoded.role;

    // Remove the original auth header - downstream services
    // trust the x-user-* headers set by the gateway
    delete req.headers.authorization;

    next();
  } catch (error) {
    if (error.name === 'TokenExpiredError') {
      return res.status(401).json({ error: 'Token expired' });
    }
    return res.status(401).json({ error: 'Invalid token' });
  }
}

// Response aggregation - combine multiple service responses
async function getUserDashboard(req: Request, res: Response) {
  const userId = req.headers['x-user-id'];

  // Call multiple services in parallel
  const [profile, orders, notifications] = await Promise.all([
    fetch(`http://user-service:3001/users/${userId}`).then(r => r.json()),
    fetch(`http://order-service:3002/users/${userId}/recent`).then(r => r.json()),
    fetch(`http://notification-service:3003/users/${userId}/unread`).then(r => r.json()),
  ]);

  // Aggregate into a single response
  // Client makes ONE call instead of THREE
  res.json({
    profile,
    recentOrders: orders.slice(0, 5),
    unreadNotifications: notifications.count,
  });
}

// Circuit Breaker implementation
enum CircuitState {
  CLOSED = 'CLOSED',       // Normal operation
  OPEN = 'OPEN',           // Rejecting all requests
  HALF_OPEN = 'HALF_OPEN', // Testing if service recovered
}

class CircuitBreaker {
  private state: CircuitState = CircuitState.CLOSED;
  private failureCount: number = 0;
  private successCount: number = 0;
  private lastFailureTime: number = 0;

  constructor(
    private failureThreshold: number = 5,
    private recoveryTimeout: number = 30000,
    private halfOpenMaxAttempts: number = 3,
  ) {}

  async execute<T>(fn: () => Promise<T>): Promise<T> {
    if (this.state === CircuitState.OPEN) {
      if (Date.now() - this.lastFailureTime >= this.recoveryTimeout) {
        this.state = CircuitState.HALF_OPEN;
        this.successCount = 0;
      } else {
        throw new Error('Circuit breaker is OPEN - service unavailable');
      }
    }

    try {
      const result = await fn();
      if (this.state === CircuitState.HALF_OPEN) {
        this.successCount++;
        if (this.successCount >= this.halfOpenMaxAttempts) {
          this.state = CircuitState.CLOSED;
          this.failureCount = 0;
        }
      }
      return result;
    } catch (error) {
      this.failureCount++;
      this.lastFailureTime = Date.now();
      if (this.failureCount >= this.failureThreshold) {
        this.state = CircuitState.OPEN;
      }
      throw error;
    }
  }
}