Catch decorator in NestJS - Step-by-Step Execution

Concept Flow - Catch decorator

Define Catch Decorator

↓

Apply Decorator to Method

↓

Method Executes

↓

Error Occurs?

No→Return Result

Yes↓

Catch Decorator Handles Error

↓

Return Custom Error Response

The Catch decorator wraps a method to catch errors during execution and handle them gracefully.

Execution Sample

NestJS

import { Catch, ExceptionFilter, ArgumentsHost } from '@nestjs/common';

@Catch()
export class MyExceptionFilter implements ExceptionFilter {
  catch(exception: any, host: ArgumentsHost) {
    return 'Error handled';
  }
}

Defines a Catch decorator that intercepts errors thrown in a method and returns a custom message.

Execution Table

Step	Action	Method Execution	Error Thrown?	Catch Decorator Response	Final Output
1	Method called	Runs normally	No	No action	Method result
2	Method called	Throws error	Yes	Catch decorator intercepts	Returns 'Error handled'
3	Execution ends	N/A	N/A	N/A	Output returned to caller

💡 Execution stops after method returns or catch decorator handles error

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
exception	undefined	undefined	Error object	Error object
host	undefined	Request context	Request context	Request context
method result	undefined	Normal result	undefined	Error handled

Key Moments - 2 Insights

Why does the catch decorator run only when an error occurs?

Because as shown in execution_table row 2, the catch decorator intercepts only when the method throws an error; otherwise, it lets the normal result pass (row 1).

What happens if the method does not throw an error?

The catch decorator does nothing and the method returns its normal result, as seen in execution_table row 1.

Visual Quiz - 3 Questions

Look at the execution_table, what is the final output when the method throws an error?

A Undefined

B Method result

C 'Error handled'

D Exception object

💡 Hint

Check execution_table row 2 under 'Final Output'

At which step does the catch decorator intercept the error?

A Step 2

B Step 1

C Step 3

D Never

💡 Hint

See execution_table row 2 under 'Catch Decorator Response'

If the method never throws an error, what will the catch decorator do?

A Return 'Error handled'

B Do nothing

C Modify the method result

D Throw a new error

💡 Hint

Refer to execution_table row 1 where 'Error Thrown?' is No

Concept Snapshot

Catch decorator in NestJS:
- Wraps methods to catch thrown errors
- Executes only if an error occurs
- Returns custom error response
- Allows normal method result if no error
- Used for centralized error handling

Full Transcript

The Catch decorator in NestJS is used to handle errors thrown by methods. When a method runs, if it completes without error, the catch decorator does nothing and the method's result is returned. If the method throws an error, the catch decorator intercepts it and returns a custom response, such as an error message. This helps keep error handling clean and centralized. The execution table shows the steps: method call, error thrown or not, catch decorator response, and final output. Variables like the exception object and method result change accordingly. Understanding when the catch decorator activates is key to using it effectively.

Practice

1. What is the primary purpose of the @Catch() decorator in NestJS?

easy

A. To mark a class as an exception filter that handles errors

B. To define a route handler for HTTP requests

C. To inject dependencies into a service

D. To create a middleware function

Solution

1. Step 1: Understand the role of @Catch()

   The @Catch() decorator is used to mark a class as an exception filter in NestJS, which means it handles errors thrown in the application.

2. Step 2: Differentiate from other decorators

   Other decorators like route handlers or dependency injections serve different purposes, so @Catch() specifically relates to error handling.

3. Final Answer:

   To mark a class as an exception filter that handles errors -> Option A

4. Quick Check:

   Error handling = @Catch() [OK]

Hint: Catch decorator marks error handlers in NestJS classes [OK]

Common Mistakes:

• Confusing @Catch() with route or middleware decorators
• Thinking @Catch() injects dependencies
• Assuming @Catch() handles normal requests

2. Which of the following is the correct syntax to create an exception filter that catches all exceptions using the @Catch() decorator?

easy

A. @Catch()\nexport class AllExceptionsFilter implements ExceptionFilter { ... }

B. @Catch(Error)\nexport class AllExceptionsFilter implements ExceptionFilter { ... }

C. @Catch(HttpException)\nexport class AllExceptionsFilter implements ExceptionFilter { ... }

D. @Catch(Exception)\nexport class AllExceptionsFilter implements ExceptionFilter { ... }

Solution

1. Step 1: Understand @Catch() usage without parameters

   Using @Catch() with no arguments means the filter will catch all exceptions.

2. Step 2: Check other options

   Options A, C, and D specify particular exception types, so they do not catch all exceptions.

3. Final Answer:

   @Catch()\nexport class AllExceptionsFilter implements ExceptionFilter { ... } -> Option A

4. Quick Check:

   No argument = catch all exceptions [OK]

Hint: Empty @Catch() catches all exceptions [OK]

Common Mistakes:

• Passing incorrect exception types to @Catch()
• Using @Catch() with a non-error class
• Confusing @Catch() with middleware syntax

3. Given the following exception filter code, what will be the output when a NotFoundException is thrown?

import { Catch, ExceptionFilter, ArgumentsHost, NotFoundException } from '@nestjs/common';

@Catch(NotFoundException)
export class NotFoundFilter implements ExceptionFilter {
  catch(exception: NotFoundException, host: ArgumentsHost) {
    const response = host.switchToHttp().getResponse();
    response.status(404).json({ message: 'Resource not found' });
  }
}

medium

A. HTTP response with status 404 and default NestJS error message

B. HTTP response with status 500 and default error message

C. No response sent, request hangs

D. HTTP response with status 404 and JSON { message: 'Resource not found' }

Solution

1. Step 1: Analyze the exception filter behavior

   The filter catches only NotFoundException and sends a 404 status with a custom JSON message.

2. Step 2: Understand the response sent

   The response is explicitly set to status 404 with JSON { message: 'Resource not found' }, overriding default behavior.

3. Final Answer:

   HTTP response with status 404 and JSON { message: 'Resource not found' } -> Option D

4. Quick Check:

   Custom 404 JSON response = HTTP response with status 404 and JSON { message: 'Resource not found' } [OK]

Hint: Filter sends custom response for caught exception type [OK]

Common Mistakes:

• Assuming default error message is sent
• Thinking status 500 is returned
• Missing the JSON response in output

4. Identify the error in the following exception filter code:

import { Catch, ExceptionFilter, ArgumentsHost } from '@nestjs/common';

@Catch()
export class MyFilter implements ExceptionFilter {
  catch(exception, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    response.status(500).send('Internal Server Error');
  }
}

medium

A. The response object is not correctly retrieved

B. The exception parameter lacks a type annotation

C. The catch method should return a value

D. The @Catch() decorator must specify an exception type

Solution

1. Step 1: Check method signature

   The catch method's first parameter exception should have a type annotation, typically unknown or any.

2. Step 2: Verify other parts

   The @Catch() decorator can be empty to catch all exceptions, returning void is allowed, and response retrieval is correct.

3. Final Answer:

   The exception parameter lacks a type annotation -> Option B

4. Quick Check:

   Missing parameter type = The exception parameter lacks a type annotation [OK]

Hint: Always type the exception parameter in catch method [OK]

Common Mistakes:

• Forgetting to type the exception parameter
• Thinking @Catch() requires arguments
• Expecting catch to return a value

5. You want to create a single exception filter that handles both BadRequestException and UnauthorizedException with different custom messages. Which is the correct way to use the @Catch() decorator to achieve this?

hard

A. @Catch()\nexport class MultiExceptionFilter implements ExceptionFilter { ... }

B. @Catch([BadRequestException, UnauthorizedException])\nexport class MultiExceptionFilter implements ExceptionFilter { ... }

C. @Catch(BadRequestException, UnauthorizedException)\nexport class MultiExceptionFilter implements ExceptionFilter { ... }

D. Create two separate filters each with @Catch() for one exception

Solution

1. Step 1: Understand how to catch multiple exceptions

   The @Catch() decorator accepts multiple exception classes as separate arguments to catch them in one filter.

2. Step 2: Evaluate options

   @Catch(BadRequestException, UnauthorizedException)\nexport class MultiExceptionFilter implements ExceptionFilter { ... } correctly passes multiple exceptions as separate arguments. @Catch([BadRequestException, UnauthorizedException])\nexport class MultiExceptionFilter implements ExceptionFilter { ... } incorrectly passes an array. @Catch()\nexport class MultiExceptionFilter implements ExceptionFilter { ... } catches all exceptions. Create two separate filters each with @Catch() for one exception uses multiple filters, not one.

3. Final Answer:

   @Catch(BadRequestException, UnauthorizedException)\nexport class MultiExceptionFilter implements ExceptionFilter { ... } -> Option C

4. Quick Check:

   Multiple exceptions as arguments = @Catch(BadRequestException, UnauthorizedException)\nexport class MultiExceptionFilter implements ExceptionFilter { ... } [OK]

Hint: Pass multiple exceptions as separate arguments to @Catch() [OK]

Common Mistakes:

• Passing exceptions as an array to @Catch()
• Using multiple filters instead of one
• Using empty @Catch() to catch specific exceptions