Build Api Gateway

Creates enterprise-grade API gateway infrastructure that serves as the single entry point for all microservices. Implements intelligent request routing, authentication, rate limiting, load balancing, and response transformation. Supports Kong, Express Gateway, AWS API Gateway, and custom implementations.

When to Use

Use this command when:

• Managing multiple microservices behind a unified API
• Implementing cross-cutting concerns (auth, logging, rate limiting)
• Needing request/response transformation between clients and services
• Requiring API composition from multiple backend services
• Implementing API versioning and backward compatibility
• Building for multi-tenant SaaS applications
• Enforcing consistent security policies across services

Do NOT use this command for:

• Simple monolithic applications with single API
• Internal service-to-service communication (use service mesh instead)
• Applications with only one or two endpoints
• Purely static content serving

Prerequisites

Before running this command, ensure:

• Microservice architecture is defined
• Service discovery mechanism is available
• Authentication strategy is determined
• Rate limiting requirements are specified
• Monitoring infrastructure is ready

Process

Step 1: Analyze Architecture Requirements

The command examines your system architecture:

• Maps all backend services and their endpoints
• Identifies authentication and authorization needs
• Determines rate limiting and throttling requirements
• Analyzes request/response transformation needs
• Plans for high availability and failover

Step 2: Generate Gateway Configuration

Creates comprehensive gateway setup:

• Route definitions with path matching
• Authentication middleware integration
• Rate limiting rules per client/endpoint
• Request/response transformation pipelines
• Circuit breaker configurations

Step 3: Implement Middleware Stack

Builds layered middleware architecture:

• CORS handling and preflight requests
• JWT validation and OAuth2 integration
• Request logging and metrics collection
• Response caching strategies
• Error handling and formatting

Step 4: Configure Load Balancing

Sets up intelligent traffic distribution:

• Round-robin, least connections, or weighted routing
• Health checking and automatic failover
• Sticky sessions when required
• Geographic routing for multi-region
• A/B testing and canary deployments

Step 5: Deploy Monitoring & Analytics

Integrates comprehensive observability:

• Request/response logging
• Performance metrics and tracing
• Error rate monitoring
• API usage analytics
• Real-time dashboards

Output Format

The command generates complete gateway infrastructure:

api-gateway/
├── src/
│   ├── gateway/
│   │   ├── server.js
│   │   ├── routes/
│   │   │   ├── router.js
│   │   │   └── service-registry.js
│   │   ├── middleware/
│   │   │   ├── authentication.js
│   │   │   ├── rate-limiter.js
│   │   │   ├── transformer.js
│   │   │   └── circuit-breaker.js
│   │   └── plugins/
│   │       ├── logging.js
│   │       └── monitoring.js
│   ├── config/
│   │   ├── gateway.config.js
│   │   ├── services.json
…

Examples

Example 1: Express Gateway with JWT Authentication

Scenario: Microservices gateway with JWT auth and rate limiting

Generated Express Gateway Implementation:

// gateway/server.js
import express from 'express';
import httpProxy from 'http-proxy-middleware';
import jwt from 'jsonwebtoken';
import rateLimit from 'express-rate-limit';
import CircuitBreaker from 'opossum';

class APIGateway {
  constructor(config) {
    this.app = express();
    this.services = config.services;
    this.setupMiddleware();
    this.setupRoutes();
    this.setupErrorHandling();
  }

  setupMiddleware() {
    // CORS configuration
…

Example 2: Kong Gateway Configuration

Scenario: Enterprise Kong gateway with plugins

Generated Kong Configuration:

# kong.yml
_format_version: "2.1"

services:
  - name: user-service
    url: http://user-service:3001
    routes:
      - name: user-routes
        paths:
          - /api/users
        strip_path: false
        methods:
          - GET
          - POST
          - PUT
          - DELETE
    plugins:
      - name: jwt
…

Example 3: API Composition and Response Aggregation

Scenario: Gateway that combines multiple service responses

Generated API Composition:

// gateway/api-composer.js
class APIComposer {
  async composeUserProfile(userId, req) {
    // Parallel requests to multiple services
    const [user, orders, preferences, recommendations] = await Promise.allSettled([
      this.fetchUser(userId, req.headers),
      this.fetchUserOrders(userId, req.headers),
      this.fetchUserPreferences(userId, req.headers),
      this.fetchRecommendations(userId, req.headers)
    ]);

    // Compose response with error handling
    const profile = {
      user: user.status === 'fulfilled' ? user.value : null,
      orders: orders.status === 'fulfilled' ? orders.value : [],
      preferences: preferences.status === 'fulfilled' ? preferences.value : {},
      recommendations: recommendations.status === 'fulfilled' ? recommendations.value : []
    };
…