Implement Error Handling

Create standardized, production-ready error handling middleware with proper HTTP status codes, consistent error formats, and comprehensive logging. This command generates custom error classes, middleware, and error recovery strategies for Node.js, Python, and other backend frameworks.

Design Decisions

Why standardized error handling matters:

• Client experience: Consistent error formats make client integration predictable
• Debugging: Structured errors with context accelerate troubleshooting
• Security: Proper error handling prevents information leakage in production
• Monitoring: Standardized errors integrate cleanly with observability tools

Alternatives considered:

• HTTP-only errors: Simpler but lacks context for debugging
• Framework defaults: Inconsistent across endpoints, lacks business context
• Exception-based only: Can leak sensitive information, harder to test

This approach balances: Developer experience, security, debugging, and API consistency.

When to Use

Use this command when:

• Starting a new API project that needs error handling
• Refactoring inconsistent error responses across endpoints
• Adding error monitoring and alerting to an existing API
• Migrating from generic framework errors to business-specific errors
• Implementing error handling for microservices that need consistency

Don't use when:

• Your framework's default error handling already meets your needs
• Building proof-of-concept code without production requirements
• Working with legacy systems that can't adopt new error formats

Prerequisites

• Node.js 16+ (for Express/Fastify examples) or Python 3.8+ (for Flask/FastAPI)
• Existing API project structure
• Basic understanding of HTTP status codes (4xx client errors, 5xx server errors)
• (Optional) Logging framework installed (Winston, Pino, Structlog)
• (Optional) Monitoring service (Sentry, DataDog, New Relic)

Process

1. Generate Custom Error Classes

• Create base error class with HTTP status codes
• Define specific error types (ValidationError, NotFoundError, AuthError)
• Add error codes for programmatic handling

1. Build Error Middleware

• Catch all errors in centralized handler
• Format errors consistently (RFC 7807 Problem Details or custom)
• Handle both operational and programmer errors

1. Configure Environment-Specific Behavior

• Development: Include stack traces, detailed messages
• Production: Sanitize errors, log internally, return safe messages

1. Integrate Logging

• Log all errors with context (request ID, user, endpoint)
• Add severity levels (error, warning, critical)
• Include metadata for troubleshooting

1. Add Error Recovery

• Graceful degradation strategies
• Retry logic for transient failures
• Circuit breaker integration

Output Format

Express.js Error Handler

// errors/AppError.js
class AppError extends Error {
  constructor(message, statusCode, errorCode = null) {
    super(message);
    this.statusCode = statusCode;
    this.errorCode = errorCode;
    this.isOperational = true;
    this.timestamp = new Date().toISOString();
    Error.captureStackTrace(this, this.constructor);
  }
}

class ValidationError extends AppError {
  constructor(message, errors = []) {
    super(message, 400, 'VALIDATION_ERROR');
    this.errors = errors;
  }
}
…

FastAPI (Python) Error Handler

# errors/exceptions.py
from typing import Optional, Any, Dict
from fastapi import HTTPException
from datetime import datetime

class AppError(HTTPException):
    def __init__(
        self,
        status_code: int,
        message: str,
        error_code: Optional[str] = None,
        details: Optional[Dict[str, Any]] = None
    ):
        self.status_code = status_code
        self.message = message
        self.error_code = error_code
        self.details = details or {}
        self.timestamp = datetime.utcnow().isoformat()
…

Example Usage

Example 1: Handling Validation Errors

const { ValidationError } = require('./errors/AppError');
const { body, validationResult } = require('express-validator');

router.post('/users',
  [
    body('email').isEmail().normalizeEmail(),
    body('password').isLength({ min: 8 }),
    body('name').trim().notEmpty()
  ],
  async (req, res, next) => {
    try {
      const errors = validationResult(req);
      if (!errors.isEmpty()) {
        throw new ValidationError('Validation failed', errors.array());
      }

      const user = await createUser(req.body);
      res.status(201).json(user);
…

Example 2: Resource Not Found

from fastapi import APIRouter
from errors.exceptions import NotFoundError

router = APIRouter()

@router.get("/users/{user_id}")
async def get_user(user_id: int):
    user = await db.get_user(user_id)
    if not user:
        raise NotFoundError("User")
    return user

# Response:
# {
#   "error": {
#     "message": "User not found",
#     "code": "NOT_FOUND",
#     "statusCode": 404,
…