Building Scalable Node.js Applications: Architecture Patterns

// User service
const express = require('express')
const app = express()
 
// User-specific routes and logic
app.get('/users/:id', async (req, res) => {
  const user = await userRepository.findById(req.params.id)
  res.json(user)
})
 
app.listen(3001, () => {
  console.log('User service running on port 3001')
})

// Order service
const express = require('express')
const app = express()
 
// Order-specific routes and logic
app.post('/orders', async (req, res) => {
  const order = await orderService.create(req.body)
  
  // Communicate with user service
  const user = await userServiceClient.getUser(order.userId)
  
  res.json({ order, user })
})
 
app.listen(3002, () => {
  console.log('Order service running on port 3002')
})

// Domain Layer - Business logic
class OrderService {
  constructor(orderRepository, paymentService) {
    this.orderRepository = orderRepository
    this.paymentService = paymentService
  }
  
  async createOrder(orderData) {
    // Business logic validation
    if (orderData.amount <= 0) {
      throw new Error('Order amount must be positive')
    }
    
    // Process payment
    const payment = await this.paymentService.charge(orderData.payment)
    
    // Save order
    return await this.orderRepository.save({
      ...orderData,
      paymentId: payment.id,
      status: 'confirmed'
    })
  }
}
 
// Infrastructure Layer - Data access
class OrderRepository {
  constructor(database) {
    this.db = database
  }
  
  async save(order) {
    return await this.db.collection('orders').insertOne(order)
  }
  
  async findById(id) {
    return await this.db.collection('orders').findOne({ _id: id })
  }
}
 
// Application Layer - API endpoints
class OrderController {
  constructor(orderService) {
    this.orderService = orderService
  }
  
  async createOrder(req, res) {
    try {
      const order = await this.orderService.createOrder(req.body)
      res.status(201).json(order)
    } catch (error) {
      res.status(400).json({ error: error.message })
    }
  }
}

const EventEmitter = require('events')
 
class OrderEventEmitter extends EventEmitter {}
const orderEvents = new OrderEventEmitter()
 
// Order service emits events
class OrderService {
  async createOrder(orderData) {
    const order = await this.repository.save(orderData)
    
    // Emit event instead of direct coupling
    orderEvents.emit('orderCreated', order)
    
    return order
  }
}
 
// Other services listen to events
orderEvents.on('orderCreated', async (order) => {
  // Send confirmation email
  await emailService.sendOrderConfirmation(order)
})
 
orderEvents.on('orderCreated', async (order) => {
  // Update inventory
  await inventoryService.updateStock(order.items)
})
 
orderEvents.on('orderCreated', async (order) => {
  // Analytics tracking
  await analyticsService.trackOrderCreated(order)
})

const cluster = require('cluster')
const numCPUs = require('os').cpus().length
 
if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`)
  
  // Fork workers
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork()
  }
  
  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died`)
    cluster.fork() // Restart worker
  })
} else {
  // Workers can share any TCP port
  const app = require('./app')
  app.listen(3000, () => {
    console.log(`Worker ${process.pid} started`)
  })
}

const Redis = require('redis')
const client = Redis.createClient()
 
// Cache middleware
const cacheMiddleware = (duration = 300) => {
  return async (req, res, next) => {
    const key = `cache:${req.originalUrl}`
    
    try {
      const cached = await client.get(key)
      if (cached) {
        return res.json(JSON.parse(cached))
      }
      
      // Store original res.json
      const originalJson = res.json
      res.json = function(data) {
        // Cache the response
        client.setex(key, duration, JSON.stringify(data))
        return originalJson.call(this, data)
      }
      
      next()
    } catch (error) {
      next()
    }
  }
}
 
// Usage
app.get('/api/products', cacheMiddleware(600), async (req, res) => {
  const products = await productService.getAll()
  res.json(products)
})

// Connection pooling
const { Pool } = require('pg')
 
const pool = new Pool({
  user: process.env.DB_USER,
  host: process.env.DB_HOST,
  database: process.env.DB_NAME,
  password: process.env.DB_PASSWORD,
  port: process.env.DB_PORT,
  max: 20, // Maximum number of connections
  idleTimeoutMillis: 30000,
  connectionTimeoutMillis: 2000,
})
 
// Query optimization with prepared statements
class UserRepository {
  async findByEmail(email) {
    const query = 'SELECT * FROM users WHERE email = $1'
    const result = await pool.query(query, [email])
    return result.rows[0]
  }
  
  async findActiveUsers() {
    const query = `
      SELECT u.*, p.name as profile_name 
      FROM users u 
      LEFT JOIN profiles p ON u.id = p.user_id 
      WHERE u.active = true 
      ORDER BY u.created_at DESC 
      LIMIT 100
    `
    const result = await pool.query(query)
    return result.rows
  }
}

// Error handling middleware
const errorHandler = (err, req, res, next) => {
  // Log error
  logger.error({
    error: err.message,
    stack: err.stack,
    url: req.url,
    method: req.method,
    ip: req.ip,
    userAgent: req.get('User-Agent')
  })
  
  // Don't leak error details in production
  if (process.env.NODE_ENV === 'production') {
    res.status(500).json({ error: 'Internal server error' })
  } else {
    res.status(500).json({ 
      error: err.message,
      stack: err.stack 
    })
  }
}
 
// Async error wrapper
const asyncHandler = (fn) => (req, res, next) => {
  Promise.resolve(fn(req, res, next)).catch(next)
}
 
// Usage
app.get('/api/users/:id', asyncHandler(async (req, res) => {
  const user = await userService.findById(req.params.id)
  if (!user) {
    throw new Error('User not found')
  }
  res.json(user)
}))
 
app.use(errorHandler)

// Health check endpoint
app.get('/health', async (req, res) => {
  const health = {
    status: 'ok',
    timestamp: new Date().toISOString(),
    uptime: process.uptime(),
    memory: process.memoryUsage(),
    checks: {}
  }
  
  try {
    // Database health check
    await pool.query('SELECT 1')
    health.checks.database = 'ok'
  } catch (error) {
    health.checks.database = 'error'
    health.status = 'error'
  }
  
  try {
    // Redis health check
    await client.ping()
    health.checks.redis = 'ok'
  } catch (error) {
    health.checks.redis = 'error'
    health.status = 'error'
  }
  
  const statusCode = health.status === 'ok' ? 200 : 503
  res.status(statusCode).json(health)
})

const helmet = require('helmet')
const rateLimit = require('express-rate-limit')
 
// Security middleware
app.use(helmet())
 
// Rate limiting
const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100, // Limit each IP to 100 requests per windowMs
  message: 'Too many requests from this IP'
})
 
app.use('/api/', limiter)
 
// Input validation
const { body, validationResult } = require('express-validator')
 
app.post('/api/users', [
  body('email').isEmail().normalizeEmail(),
  body('password').isLength({ min: 8 }).matches(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)/),
  body('name').trim().isLength({ min: 2, max: 50 })
], async (req, res) => {
  const errors = validationResult(req)
  if (!errors.isEmpty()) {
    return res.status(400).json({ errors: errors.array() })
  }
  
  // Process valid input
  const user = await userService.create(req.body)
  res.status(201).json(user)
})

# Multi-stage build for production
FROM node:18-alpine AS builder
 
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
 
FROM node:18-alpine AS production
 
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nextjs -u 1001
 
WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY . .
 
USER nextjs
 
EXPOSE 3000
 
CMD ["node", "server.js"]