🛒 E-commerce Platform

// High-performance product service with advanced caching
const express = require('express');
const mongoose = require('mongoose');
const Redis = require('ioredis');
const { body, validationResult } = require('express-validator');

class ProductService {
  constructor() {
    this.redis = new Redis(process.env.REDIS_URL);
    this.app = express();
    this.setupMiddleware();
    this.setupRoutes();
  }

  // Advanced caching with intelligent invalidation
  async getProduct(id) {
    const cacheKey = `product:${id}`;
    
    // Try cache first
    let product = await this.redis.get(cacheKey);
    if (product) {
      return JSON.parse(product);
    }
    
    // Fetch from database
    product = await Product.findById(id)
      .populate('category')
      .lean();
    
    if (product) {
      // Cache with TTL
      await this.redis.setex(cacheKey, 3600, JSON.stringify(product));
    }
    
    return product;
  }

  // Real-time inventory management
  async updateInventory(productId, quantity, operation = 'decrement') {
    const session = await mongoose.startSession();
    
    try {
      session.startTransaction();
      
      const product = await Product.findById(productId).session(session);
      if (!product) {
        throw new Error('Product not found');
      }
      
      const newQuantity = operation === 'decrement' 
        ? product.inventory - quantity 
        : product.inventory + quantity;
      
      if (newQuantity < 0) {
        throw new Error('Insufficient inventory');
      }
      
      product.inventory = newQuantity;
      await product.save({ session });
      
      // Invalidate cache
      await this.redis.del(`product:${productId}`);
      
      // Broadcast inventory update
      this.broadcastInventoryUpdate(productId, newQuantity);
      
      await session.commitTransaction();
      return product;
      
    } catch (error) {
      await session.abortTransaction();
      throw error;
    } finally {
      session.endSession();
    }
  }
}

# Production-grade deployment with autoscaling
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ecommerce-backend
spec:
  replicas: 5
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 2
      maxUnavailable: 1
  template:
    spec:
      containers:
      - name: ecommerce-api
        image: temitayocharles/ecommerce-backend:latest
        ports:
        - containerPort: 3000
        env:
        - name: NODE_ENV
          value: "production"
        - name: MONGODB_URI
          valueFrom:
            secretKeyRef:
              name: ecommerce-secrets
              key: mongodb-uri
        resources:
          requests:
            memory: "512Mi"
            cpu: "250m"
          limits:
            memory: "1Gi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5

---
# Horizontal Pod Autoscaler
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: ecommerce-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: ecommerce-backend
  minReplicas: 3
  maxReplicas: 20
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80