Custom exception classes in NestJS - Step-by-Step Execution

Concept Flow - Custom exception classes

Define Custom Exception Class

↓

Throw Custom Exception

↓

NestJS Exception Filter Catches

↓

Send HTTP Response with Custom Status & Message

↓

End

This flow shows how you create a custom exception class, throw it in your code, and how NestJS catches it to send a proper HTTP response.

Execution Sample

NestJS

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

export class MyCustomException extends HttpException {
  constructor() {
    super('Custom error occurred', HttpStatus.BAD_REQUEST);
  }
}

Defines a custom exception class that sends a 400 Bad Request with a custom message.

Execution Table

Step	Action	Evaluation	Result
1	Define MyCustomException class extending HttpException	Class created	Ready to throw custom error
2	Throw new MyCustomException() in controller/service	Exception instance created	Exception thrown
3	NestJS catches exception	Checks exception type	Matches MyCustomException
4	NestJS sends HTTP response	Uses status 400 and message 'Custom error occurred'	Client receives 400 Bad Request with message
5	Request handling ends	No further processing	Response sent to client

💡 Exception thrown and handled, HTTP response sent, request cycle ends

Variable Tracker

Variable	Start	After Throw	After Catch	Final
exceptionInstance	undefined	MyCustomException instance	Caught by NestJS	Handled and response sent

Key Moments - 3 Insights

Why do we extend HttpException instead of Error?

Extending HttpException lets NestJS recognize and handle the exception properly with HTTP status codes, as shown in execution_table step 3.

What happens if we throw the custom exception without a message or status?

The constructor requires a message and status; missing these causes errors or default behavior, so step 2 in execution_table shows the importance of passing them.

How does NestJS know to send a 400 status code?

Because the custom exception passes HttpStatus.BAD_REQUEST to the super constructor, NestJS reads this in step 4 and sends the correct HTTP response.

Visual Quiz - 3 Questions

Look at the execution_table, what is the result of step 3?

A NestJS ignores the exception

B NestJS matches the exception type

C Exception is re-thrown

D HTTP response is sent immediately

💡 Hint

Check the 'Result' column in step 3 of execution_table

At which step does the client receive the HTTP response?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Look at the 'Action' and 'Result' columns in execution_table step 4

If we change the status in the custom exception to 404, what changes in the execution?

A Exception is not caught

B Client receives 500 error

C NestJS sends 404 instead of 400 in step 4

D No HTTP response is sent

💡 Hint

Refer to how status is used in execution_table step 4

Concept Snapshot

Custom exception classes in NestJS extend HttpException.
Use constructor to set message and HTTP status.
Throw the custom exception in your code.
NestJS catches it and sends the HTTP response.
This helps send clear error messages with proper status codes.

Full Transcript

In NestJS, you create custom exception classes by extending HttpException. This allows you to define your own error messages and HTTP status codes. When you throw this custom exception in your controller or service, NestJS catches it automatically. It then sends an HTTP response to the client with the status and message you defined. This process helps you handle errors clearly and consistently in your app.

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