Exception filters in NestJS - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a basic exception filter class in NestJS.

NestJS

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

@Catch()
export class AllExceptionsFilter implements [1] {
  catch(exception: any, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    response.status(500).json({
      statusCode: 500,
      message: 'Internal server error',
    });
  }
}

Drag options to blanks, or click blank then click option'

AController

BExceptionFilter

CHttpException

DMiddleware

Attempts:

3 left

💡 Hint

Common Mistakes

Using HttpException instead of ExceptionFilter as the implemented interface.

Not implementing any interface.

Using Controller or Middleware which are unrelated here.

The class must implement the ExceptionFilter interface to be a valid exception filter in NestJS.

2fill in blank

medium

Complete the code to catch only HTTP exceptions in the filter.

NestJS

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

@Catch([1])
export class HttpExceptionFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    const status = exception.getStatus();
    response.status(status).json({
      statusCode: status,
      message: exception.message,
    });
  }
}

Drag options to blanks, or click blank then click option'

AExceptionFilter

BError

CHttpException

DAllExceptionsFilter

Attempts:

3 left

💡 Hint

Common Mistakes

Using Error which is too general.

Using ExceptionFilter which is an interface, not an exception class.

Using a custom filter class name instead of an exception class.

The @Catch() decorator takes the exception type to catch. To catch HTTP exceptions only, use HttpException.

3fill in blank

hard

Fix the error in the catch method to correctly get the request object.

NestJS

catch(exception: HttpException, host: ArgumentsHost) {
  const ctx = host.switchToHttp();
  const response = ctx.getResponse();
  const request = ctx.[1]();
  const status = exception.getStatus();
  response.status(status).json({
    statusCode: status,
    timestamp: new Date().toISOString(),
    path: request.url,
  });
}

Drag options to blanks, or click blank then click option'

AgetReq

Brequest

CgetRequestObject

DgetRequest

Attempts:

3 left

💡 Hint

Common Mistakes

Using getReq which is not a method on ArgumentsHost.

Using getRequestObject which does not exist.

Using request which is a property, not a method.

The ArgumentsHost method to get the request object is getRequest().

4fill in blank

hard

Fill both blanks to create a filter that catches multiple exception types.

NestJS

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

@Catch([1], [2])
export class MultiExceptionFilter implements ExceptionFilter {
  catch(exception: any, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    const status = exception instanceof HttpException ? exception.getStatus() : 500;
    response.status(status).json({
      statusCode: status,
      message: exception.message || 'Unknown error',
    });
  }
}

Drag options to blanks, or click blank then click option'

AHttpException

BExceptionFilter

CBadRequestException

DError

Attempts:

3 left

💡 Hint

Common Mistakes

Using ExceptionFilter which is an interface, not an exception class.

Using Error which is too general.

Using the same exception class twice.

The @Catch() decorator can take multiple exception classes to catch. Here, it catches HttpException and BadRequestException.

5fill in blank

hard

Fill all three blanks to create a custom exception filter that logs the error and sends a JSON response.

NestJS

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

@Catch([1])
export class LoggingExceptionFilter implements ExceptionFilter {
  private readonly logger = new [2](LoggingExceptionFilter.name);

  catch(exception: HttpException, host: ArgumentsHost) {
    this.logger.[3](exception.message);
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    const status = exception.getStatus();
    response.status(status).json({
      statusCode: status,
      message: exception.message,
    });
  }
}

Drag options to blanks, or click blank then click option'

AHttpException

BLogger

Cerror

DExceptionFilter

Attempts:

3 left

💡 Hint

Common Mistakes

Using ExceptionFilter instead of HttpException in the decorator.

Using a wrong logger method like 'log' instead of 'error'.

Not creating a Logger instance properly.

The filter catches HttpException, uses the Logger class to create a logger instance, and calls the error method to log the exception message.

Practice

1. What is the main purpose of an exception filter in NestJS?

easy

A. To catch and handle errors in a centralized way

B. To create database connections automatically

C. To define routes for HTTP requests

D. To manage user authentication

Solution

1. Step 1: Understand what exception filters do

   Exception filters catch errors thrown during request handling and allow custom responses.

2. Step 2: Compare with other options

   Options B, C, and D relate to other NestJS features, not error handling.

3. Final Answer:

   To catch and handle errors in a centralized way -> Option A

4. Quick Check:

   Exception filters = centralized error handling [OK]

Hint: Exception filters handle errors centrally, not routes or auth [OK]

Common Mistakes:

• Confusing exception filters with middleware
• Thinking filters manage routes or database
• Assuming filters handle authentication

2. Which decorator is used to define an exception filter class in NestJS?

easy

A. @Exception()

B. @Catch()

C. @Filter()

D. @ErrorHandler()

Solution

1. Step 1: Recall the decorator for exception filters

   The correct decorator to mark a class as an exception filter is @Catch().

2. Step 2: Verify other decorators

   @Exception(), @Filter(), and @ErrorHandler() are not valid NestJS decorators for filters.

3. Final Answer:

   @Catch() -> Option B

4. Quick Check:

   @Catch() marks exception filters [OK]

Hint: Remember: @Catch() catches exceptions in filters [OK]

Common Mistakes:

• Using @Exception() instead of @Catch()
• Confusing with @Filter() which is not a decorator
• Assuming @ErrorHandler() exists in NestJS

3. Given this filter code, what will be the HTTP status code sent when a NotFoundException is thrown?

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

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

medium

A. 404

B. 200

C. 500

D. 400

Solution

1. Step 1: Analyze the response status set in the filter

   The filter explicitly sets the status code to 404 using response.status(404).

2. Step 2: Understand the exception type caught

   The filter catches NotFoundException, which corresponds to HTTP 404 errors.

3. Final Answer:

   404 -> Option A

4. Quick Check:

   NotFoundException triggers 404 status [OK]

Hint: Check response.status() call inside catch method [OK]

Common Mistakes:

• Assuming default 500 status without custom filter
• Confusing 404 with 400 or 200
• Ignoring the status set in the filter

4. Identify the error in this exception filter code:

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

@Catch(HttpException)
export class AllExceptionsFilter implements ExceptionFilter {
  catch(exception, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    response.status(500).json({ message: exception.message });
  }
}

medium

A. Missing exception type in @Catch() decorator

B. catch method missing return type

C. Using exception.message instead of exception.getMessage()

D. Not importing HttpException class

Solution

1. Step 1: Check the @Catch() decorator usage

   The @Catch(HttpException) references HttpException, but it is not imported from '@nestjs/common'.

2. Step 2: Validate other parts

   catch method can omit return type and exception type in loose TS, exception.message is valid.

3. Final Answer:

   Not importing HttpException class -> Option D

4. Quick Check:

   Import HttpException for @Catch(HttpException) [OK]

Hint: Import exception classes used in @Catch() [OK]

Common Mistakes:

• Not importing referenced exception types like HttpException
• Assuming catch method needs strict return type
• Thinking exception needs getMessage() method

5. You want to create a global exception filter that catches all exceptions and logs the error before sending a generic message. Which of these is the correct way to apply it globally in NestJS?

hard

A. Register the filter in a module's providers array only

B. Add @Global() decorator to the filter class

C. Use app.useGlobalFilters(new YourFilter()) in main.ts after creating the filter class

D. Call app.setGlobalExceptionFilter(YourFilter) in main.ts

Solution

1. Step 1: Recall how to apply global filters in NestJS

   Global filters are applied using app.useGlobalFilters() method in the main bootstrap file.

2. Step 2: Evaluate other options

   @Global() is for modules, not filters; registering in providers is local; app.setGlobalExceptionFilter() does not exist.

3. Final Answer:

   Use app.useGlobalFilters(new YourFilter()) in main.ts after creating the filter class -> Option C

4. Quick Check:

   Global filters use app.useGlobalFilters() [OK]

Hint: Global filters need app.useGlobalFilters() call [OK]

Common Mistakes:

• Using @Global() decorator on filter class
• Registering filter only in providers without global call
• Assuming app.setGlobalExceptionFilter() exists