Custom exception classes in NestJS - Mini Project: Build & Apply

Custom Exception Classes in NestJS

📖 Scenario: You are building a NestJS backend for a bookstore. You want to handle errors clearly by creating custom exception classes for specific error cases like when a book is not found or when a user tries to buy a book that is out of stock.

🎯 Goal: Create custom exception classes in NestJS by extending the built-in HttpException class. Use these classes to throw meaningful errors in your application.

📋 What You'll Learn

Create a custom exception class called BookNotFoundException that extends HttpException.

Create a custom exception class called OutOfStockException that extends HttpException.

Use the HttpStatus.NOT_FOUND status code for BookNotFoundException.

Use the HttpStatus.BAD_REQUEST status code for OutOfStockException.

Each exception class should have a constructor that calls the parent HttpException constructor with a custom message and status code.

💡 Why This Matters

🌍 Real World

Custom exceptions help backend developers give clear error messages and HTTP status codes. This improves API usability and debugging.

💼 Career

Understanding how to create and use custom exceptions is important for backend developers working with NestJS or similar frameworks to build robust and maintainable APIs.

1

Create the BookNotFoundException class

Create a class called BookNotFoundException that extends HttpException. Inside the constructor, call super with the message 'Book not found' and the status code HttpStatus.NOT_FOUND. Import HttpException and HttpStatus from @nestjs/common.

NestJS

import { HttpException, HttpStatus } from '@nestjs/common';

// Your code here

Hint

Remember to import HttpException and HttpStatus from @nestjs/common. Your class should extend HttpException and call super with the message and status code.

2

Create the OutOfStockException class

Create a class called OutOfStockException that extends HttpException. Inside the constructor, call super with the message 'Book is out of stock' and the status code HttpStatus.BAD_REQUEST. Make sure to export the class.

NestJS

import { HttpException, HttpStatus } from '@nestjs/common';

export class BookNotFoundException extends HttpException {
  constructor() {
    super('Book not found', HttpStatus.NOT_FOUND);
  }
}

// Create OutOfStockException class here

Hint

Follow the same pattern as BookNotFoundException. Use the message 'Book is out of stock' and status code HttpStatus.BAD_REQUEST.

3

Throw BookNotFoundException in a service method

Inside a class called BookService, create a method called findBookById that takes a parameter id. Inside the method, throw a new BookNotFoundException. Import BookNotFoundException from the current file.

NestJS

import { HttpException, HttpStatus } from '@nestjs/common';

export class BookNotFoundException extends HttpException {
  constructor() {
    super('Book not found', HttpStatus.NOT_FOUND);
  }
}

export class OutOfStockException extends HttpException {
  constructor() {
    super('Book is out of stock', HttpStatus.BAD_REQUEST);
  }
}

export class BookService {
  // Add findBookById method here
  // Your code here
}

Hint

Create the BookService class and add the findBookById method. Inside it, throw new BookNotFoundException().

4

Throw OutOfStockException in a service method

Inside the BookService class, create a method called buyBook that takes a parameter id. Inside the method, throw a new OutOfStockException. Make sure to keep the previous code intact.

NestJS

import { HttpException, HttpStatus } from '@nestjs/common';

export class BookNotFoundException extends HttpException {
  constructor() {
    super('Book not found', HttpStatus.NOT_FOUND);
  }
}

export class OutOfStockException extends HttpException {
  constructor() {
    super('Book is out of stock', HttpStatus.BAD_REQUEST);
  }
}

export class BookService {
  findBookById(id: number) {
    throw new BookNotFoundException();
  }

  // Add buyBook method here
  // Your code here
}

Hint

Add the buyBook method inside BookService and throw new OutOfStockException() inside it.

Practice

1. What is the main purpose of creating a custom exception class in NestJS?

easy

A. To create new HTTP methods like GET or POST

B. To replace the built-in JavaScript Error object globally

C. To automatically log errors to a database

D. To define specific error messages and HTTP status codes for your app

Solution

1. Step 1: Understand the role of custom exceptions

   Custom exceptions in NestJS help you send clear, specific error messages with HTTP status codes.

2. Step 2: Compare with other options

   Options B, C, and D describe unrelated features not handled by custom exceptions.

3. Final Answer:

   To define specific error messages and HTTP status codes for your app -> Option D

4. Quick Check:

   Custom exceptions = specific messages + status [OK]

Hint: Custom exceptions customize error messages and HTTP codes [OK]

Common Mistakes:

• Thinking custom exceptions replace JavaScript Error globally
• Assuming they log errors automatically
• Confusing exceptions with HTTP methods

2. Which of the following is the correct way to define a custom exception class in NestJS?

easy

A. const MyException = () => { return 'Error'; }

B. class MyException extends HttpException { constructor() { super('Error', 400); } }

C. class MyException { constructor() { this.message = 'Error'; } }

D. function MyException() { throw new Error('Error'); }

Solution

1. Step 1: Check syntax for custom exception

   In NestJS, custom exceptions extend HttpException and call super with message and status.

2. Step 2: Validate options

   class MyException extends HttpException { constructor() { super('Error', 400); } } correctly extends HttpException and calls super with message and status code. Others do not follow NestJS pattern.

3. Final Answer:

   class MyException extends HttpException { constructor() { super('Error', 400); } } -> Option B

4. Quick Check:

   Extend HttpException + super(message, status) [OK]

Hint: Custom exceptions must extend HttpException and call super() [OK]

Common Mistakes:

• Not extending HttpException
• Not calling super() with message and status
• Using plain functions instead of classes

3. Given this custom exception class, what will be the HTTP status code when it is thrown?

class ForbiddenException extends HttpException {
  constructor() {
    super('Access denied', 403);
  }
}

medium

A. 200

B. 500

C. 403

D. 404

Solution

1. Step 1: Read the constructor call

   The constructor calls super with message 'Access denied' and status 403.

2. Step 2: Understand HttpException behavior

   The second argument to super is the HTTP status code returned when exception is thrown.

3. Final Answer:

   403 -> Option C

4. Quick Check:

   Status code = 403 from super() call [OK]

Hint: Status code is second argument in super() call [OK]

Common Mistakes:

• Confusing message with status code
• Assuming default 500 status
• Ignoring the status argument in super()

4. What is wrong with this custom exception class?

class BadRequestException extends HttpException {
  constructor() {
    super('Bad request');
  }
}

medium

A. Missing HTTP status code in super() call

B. Class should not extend HttpException

C. Constructor should not call super()

D. Message should be a number, not a string

Solution

1. Step 1: Check super() arguments

   The super() call only has a message string, but HttpException requires message and status code.

2. Step 2: Understand HttpException constructor

   HttpException constructor needs both message and HTTP status code to work correctly.

3. Final Answer:

   Missing HTTP status code in super() call -> Option A

4. Quick Check:

   super() needs message + status [OK]

Hint: Always pass status code as second argument to super() [OK]

Common Mistakes:

• Forgetting the status code argument
• Thinking message alone is enough
• Misunderstanding HttpException constructor

5. You want to create a custom exception that returns a JSON response with a custom error code and message. Which approach correctly extends HttpException to achieve this?

class CustomErrorException extends HttpException {
  constructor() {
    super(
      { errorCode: 1234, message: 'Custom error' },
      400
    );
  }
}

hard

A. This code correctly sends a JSON object with errorCode and message and HTTP 400 status

B. HttpException cannot send JSON objects, only strings

C. The status code should be inside the JSON object, not a separate argument

D. Custom exceptions must not use objects in super(), only strings

Solution

1. Step 1: Review HttpException constructor usage

   HttpException accepts either a string or an object as the first argument for the response body.

2. Step 2: Confirm JSON response with status code

   Passing an object with errorCode and message as first argument and 400 as second is valid and sends JSON response with status 400.

3. Final Answer:

   This code correctly sends a JSON object with errorCode and message and HTTP 400 status -> Option A

4. Quick Check:

   HttpException supports object response + status [OK]

Hint: Pass object as first argument, status code as second in super() [OK]

Common Mistakes:

• Thinking only strings allowed in super()
• Putting status code inside JSON object
• Believing custom exceptions can't send JSON