Error Handling & Validation — Express Error Middleware

Instead of throwing generic Error objects, create a custom AppError class that includes status codes and operational flags. This makes error handling cleaner and more consistent.

// utils/AppError.js — Custom Error Class
class AppError extends Error {
  constructor(message, statusCode) {
    super(message);
    this.statusCode = statusCode;
    this.status = String(statusCode).startsWith('4') ? 'fail' : 'error';
    this.isOperational = true; // Differentiate from programming errors

    // Capture stack trace
    Error.captureStackTrace(this, this.constructor);
  }
}

export default AppError;

Using AppError in controllers:

// controllers/biryani.controller.js — Using AppError
import Biryani from '../models/Biryani.js';
import AppError from '../utils/AppError.js';

// GET /api/biryani/:id — Get single biryani
export const getBiryani = async (req, res, next) => {
  try {
    const biryani = await Biryani.findById(req.params.id);

    if (!biryani) {
      // Throw custom error with 404 status
      throw new AppError('Biryani not found! Yeh biryani exist nahi karti! 🍔', 404);
    }

    res.json({ success: true, data: biryani });
  } catch (error) {
    // Pass to error middleware
    next(error);
  }
};

// POST /api/biryani — Create biryani (admin only)
export const createBiryani = async (req, res, next) => {
  try {
    const { name, price, category } = req.body;

    // Manual validation (or use express-validator)
    if (!name || !price) {
      throw new AppError('Name and price required! Biryani ka naam aur price toh daalo bhai!', 400);
    }

    if (price < 10) {
      throw new AppError('Itni sasti biryani nahi hoti! Minimum Rs.10', 400);
    }

    const biryani = await Biryani.create(req.body);

    res.status(201).json({ success: true, data: biryani });
  } catch (error) {
    next(error);
  }
};

Async handler wrapper — no more try-catch in every route!

// utils/asyncHandler.js — Wraps async routes, catches errors automatically
const asyncHandler = (fn) => {
  return (req, res, next) => {
    // If fn returns a promise, catch rejects and pass to next()
    Promise.resolve(fn(req, res, next)).catch(next);
  };
};

export default asyncHandler;

// Usage — no try-catch needed!
import asyncHandler from '../utils/asyncHandler.js';

export const getBiryani = asyncHandler(async (req, res, next) => {
  const biryani = await Biryani.findById(req.params.id);

  if (!biryani) {
    throw new AppError('Biryani not found!', 404);
  }

  res.json({ success: true, data: biryani });
  // No try-catch! asyncHandler catches any error and calls next(error)
});

Complete error classes:

// utils/errors.js — All custom error classes
class AppError extends Error {
  constructor(message, statusCode) {
    super(message);
    this.statusCode = statusCode;
    this.isOperational = true;
  }
}

class NotFoundError extends AppError {
  constructor(resource = 'Resource') {
    super(resource + ' not found!', 404);
  }
}

class UnauthorizedError extends AppError {
  constructor(message = 'Please login first! Login karo bhai!') {
    super(message, 401);
  }
}

class ForbiddenError extends AppError {
  constructor(message = 'Aapke paas permission nahi hai bhai!') {
    super(message, 403);
  }
}

class ValidationError extends AppError {
  constructor(message = 'Validation failed! Sahi data daalo bhai!') {
    super(message, 400);
  }
}

export { AppError, NotFoundError, UnauthorizedError, ForbiddenError, ValidationError };