Migrating from Monolith to Microservices

// Domain Analysis Example
const domainBoundaries = {
  userManagement: {
    entities: ['User', 'Profile', 'Preferences', 'Authentication'],
    boundedContext: 'Identity & Access Management',
    dataConsistency: 'Strong',
    team: 'Platform Team'
  },
  orderManagement: {
    entities: ['Order', 'OrderItem', 'OrderStatus', 'Fulfillment'],
    boundedContext: 'Order Processing',
    dataConsistency: 'Eventual',
    team: 'Order Team'
  },
  inventoryManagement: {
    entities: ['Product', 'Stock', 'Reservation', 'Supplier'],
    boundedContext: 'Inventory Control',
    dataConsistency: 'Strong',
    team: 'Inventory Team'
  }
};

// Strangler Fig Pattern Implementation
class StranglerFigRouter {
  constructor() {
    this.microservices = new Map();
    this.monolithFallback = true;
  }
  
  async routeRequest(request) {
    const service = this.identifyService(request.path);
    
    if (this.microservices.has(service)) {
      try {
        return await this.callMicroservice(service, request);
      } catch (error) {
        if (this.monolithFallback) {
          return await this.callMonolith(request);
        }
        throw error;
      }
    }
    
    return await this.callMonolith(request);
  }
  
  identifyService(path) {
    if (path.startsWith('/api/users')) return 'user-service';
    if (path.startsWith('/api/orders')) return 'order-service';
    if (path.startsWith('/api/inventory')) return 'inventory-service';
    return 'monolith';
  }
}

// Database Migration Strategy
class DatabaseMigration {
  async migrateUserData() {
    // Step 1: Create new user service database
    await this.createUserServiceDB();
    
    // Step 2: Set up data synchronization
    await this.setupDataSync({
      source: 'monolith_users',
      target: 'user_service_users',
      strategy: 'dual-write',
      validation: true
    });
    
    // Step 3: Gradually shift traffic
    await this.graduallyShiftTraffic({
      startPercentage: 0,
      endPercentage: 100,
      duration: '2 weeks',
      rollbackThreshold: 0.05
    });
    
    // Step 4: Verify data consistency
    await this.verifyDataConsistency();
    
    // Step 5: Remove old data
    await this.removeOldData();
  }
}

// Kong API Gateway Configuration
{
  "name": "ecommerce-gateway",
  "upstream": {
    "name": "monolith",
    "targets": [
      { "target": "monolith:3000", "weight": 100 }
    ]
  },
  "routes": [
    {
      "name": "user-service",
      "paths": ["/api/users"],
      "upstream": "user-service:3001",
      "plugins": {
        "rate-limiting": {
          "minute": 1000,
          "hour": 10000
        },
        "cors": {
          "origins": ["*"],
          "methods": ["GET", "POST", "PUT", "DELETE"]
        }
      }
    },
    {
      "name": "order-service",
      "paths": ["/api/orders"],
      "upstream": "order-service:3002",
      "plugins": {
        "jwt": {
          "secret": "your-secret-key"
        }
      }
    }
  ]
}

// Consul Service Registration
const consul = require('consul')();

class ServiceRegistry {
  async registerService(serviceConfig) {
    const registration = {
      name: serviceConfig.name,
      id: `${serviceConfig.name}-${serviceConfig.instanceId}`,
      address: serviceConfig.host,
      port: serviceConfig.port,
      tags: serviceConfig.tags || [],
      check: {
        http: `http://${serviceConfig.host}:${serviceConfig.port}/health`,
        interval: '10s',
        timeout: '5s',
        deregistercriticalserviceafter: '1m'
      }
    };
    
    await consul.agent.service.register(registration);
  }
  
  async discoverService(serviceName) {
    const services = await consul.catalog.service.nodes(serviceName);
    return services.map(service => ({
      host: service.ServiceAddress,
      port: service.ServicePort
    }));
  }
}

// Health Check Endpoint
app.get('/health', (req, res) => {
  const health = {
    status: 'healthy',
    timestamp: new Date().toISOString(),
    uptime: process.uptime(),
    memory: process.memoryUsage(),
    checks: {
      database: checkDatabaseConnection(),
      redis: checkRedisConnection(),
      externalAPI: checkExternalAPI()
    }
  };
  
  const isHealthy = Object.values(health.checks).every(check => check.status === 'healthy');
  res.status(isHealthy ? 200 : 503).json(health);
});

// Circuit Breaker Pattern
class CircuitBreaker {
  constructor(failureThreshold = 5, timeout = 60000) {
    this.failureThreshold = failureThreshold;
    this.timeout = timeout;
    this.state = 'CLOSED';
    this.failureCount = 0;
    this.lastFailureTime = null;
  }
  
  async execute(operation) {
    if (this.state === 'OPEN') {
      if (this.shouldAttemptReset()) {
        this.state = 'HALF_OPEN';
      } else {
        throw new Error('Circuit breaker is OPEN');
      }
    }
    
    try {
      const result = await operation();
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure();
      throw error;
    }
  }
  
  onSuccess() {
    this.failureCount = 0;
    this.state = 'CLOSED';
  }
  
  onFailure() {
    this.failureCount++;
    this.lastFailureTime = Date.now();
    
    if (this.failureCount >= this.failureThreshold) {
      this.state = 'OPEN';
    }
  }
  
  shouldAttemptReset() {
    return Date.now() - this.lastFailureTime > this.timeout;
  }
}

// Usage Example
const circuitBreaker = new CircuitBreaker();
const userService = new UserService();

app.get('/api/users/:id', async (req, res) => {
  try {
    const user = await circuitBreaker.execute(() => 
      userService.getUser(req.params.id)
    );
    res.json(user);
  } catch (error) {
    res.status(503).json({ 
      error: 'Service temporarily unavailable',
      fallback: await getCachedUser(req.params.id)
    });
  }
});

// Pact Contract Testing
const { Pact } = require('@pact-foundation/pact');
const { UserService } = require('./user-service');

describe('User Service Contract', () => {
  let provider;
  
  beforeAll(async () => {
    provider = new Pact({
      consumer: 'order-service',
      provider: 'user-service',
      port: 1234,
      log: path.resolve(process.cwd(), 'logs', 'pact.log'),
      dir: path.resolve(process.cwd(), 'pacts'),
      logLevel: 'INFO',
      spec: 2
    });
    
    await provider.setup();
  });
  
  afterAll(async () => {
    await provider.finalize();
  });
  
  describe('get user by id', () => {
    beforeAll(async () => {
      await provider.addInteraction({
        state: 'user exists',
        uponReceiving: 'a request for user details',
        withRequest: {
          method: 'GET',
          path: '/api/users/123',
          headers: { 'Accept': 'application/json' }
        },
        willRespondWith: {
          status: 200,
          headers: { 'Content-Type': 'application/json' },
          body: {
            id: '123',
            name: 'John Doe',
            email: 'john@example.com',
            status: 'active'
          }
        }
      });
    });
    
    it('should return user details', async () => {
      const userService = new UserService('http://localhost:1234');
      const user = await userService.getUser('123');
      
      expect(user).toEqual({
        id: '123',
        name: 'John Doe',
        email: 'john@example.com',
        status: 'active'
      });
    });
  });
});

// Prometheus Metrics
const prometheus = require('prom-client');
const register = new prometheus.Registry();

// Custom metrics
const httpRequestDuration = new prometheus.Histogram({
  name: 'http_request_duration_seconds',
  help: 'Duration of HTTP requests in seconds',
  labelNames: ['method', 'route', 'status_code'],
  buckets: [0.1, 0.5, 1, 2, 5]
});

const httpRequestsTotal = new prometheus.Counter({
  name: 'http_requests_total',
  help: 'Total number of HTTP requests',
  labelNames: ['method', 'route', 'status_code']
});

// Middleware to collect metrics
app.use((req, res, next) => {
  const start = Date.now();
  
  res.on('finish', () => {
    const duration = (Date.now() - start) / 1000;
    
    httpRequestDuration
      .labels(req.method, req.route?.path || req.path, res.statusCode)
      .observe(duration);
    
    httpRequestsTotal
      .labels(req.method, req.route?.path || req.path, res.statusCode)
      .inc();
  });
  
  next();
});

// Metrics endpoint
app.get('/metrics', async (req, res) => {
  res.set('Content-Type', register.contentType);
  res.end(await register.metrics());
});