Applying middleware to routes in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

Middleware effect on route response

Given this NestJS middleware that adds a header, what will be the response headers when accessing the /hello route?

NestJS

import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';

@Injectable()
export class HeaderMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    res.setHeader('X-Custom-Header', 'NestJS');
    next();
  }
}

// In AppModule
import { Module, MiddlewareConsumer, RequestMethod } from '@nestjs/common';
import { HeaderMiddleware } from './header.middleware';
import { HelloController } from './hello.controller';

@Module({
  controllers: [HelloController],
})
export class AppModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(HeaderMiddleware)
      .forRoutes({ path: 'hello', method: RequestMethod.GET });
  }
}

// HelloController
import { Controller, Get } from '@nestjs/common';

@Controller('hello')
export class HelloController {
  @Get()
  getHello() {
    return 'Hello World';
  }
}

A The middleware will cause a runtime error and no response is sent.

B The response will not include any custom headers.

C The response will include the header 'X-Custom-Header' but with an empty value.

D The response will include the header 'X-Custom-Header' with value 'NestJS'.

💡 Hint

Middleware runs before the route handler and can modify the response.

The middleware sets the header 'X-Custom-Header' to 'NestJS' before calling next(), so the route response includes this header.

📝 Syntax

intermediate

Correct middleware application syntax

Which option correctly applies a middleware to all POST routes in NestJS?

NestJS

import { MiddlewareConsumer, Module, RequestMethod } from '@nestjs/common';
import { LoggerMiddleware } from './logger.middleware';

@Module({})
export class AppModule {
  configure(consumer: MiddlewareConsumer) {
    // Apply middleware here
  }
}

A consumer.apply(LoggerMiddleware).forRoutes({ path: '*', method: RequestMethod.POST });

B consumer.apply(LoggerMiddleware).forRoutes({ path: '*', method: 'POST' });

C consumer.apply(LoggerMiddleware).forRoutes({ path: '*', method: RequestMethod.GET });

D consumer.apply(LoggerMiddleware).forRoutes('*', RequestMethod.POST);

💡 Hint

Use RequestMethod enum for HTTP methods.

The correct syntax uses forRoutes with an object specifying path and method using RequestMethod.POST enum.

🔧 Debug

advanced

Middleware not running on expected route

Why does this middleware not run when accessing /api/users even though it is applied to /api/*?

NestJS

consumer.apply(AuthMiddleware).forRoutes('api/*');

A The middleware must be applied in the controller, not in the module.

B The forRoutes method does not support wildcard strings like 'api/*'.

C The middleware only runs on POST requests by default.

D The middleware is missing the @Injectable decorator.

💡 Hint

Check how forRoutes accepts paths.

forRoutes does not support wildcard strings. It expects exact paths, controller classes, or RequestMethod objects.

❓ state_output

advanced

Order of middleware execution

Given two middlewares applied in this order, what will be the console output when accessing /test?

NestJS

consumer
  .apply(FirstMiddleware, SecondMiddleware)
  .forRoutes('test');

// FirstMiddleware logs 'First start' before next() and 'First end' after next()
// SecondMiddleware logs 'Second start' before next() and 'Second end' after next()

A

Second start
First start
First end
Second end

B

First start
Second start
First end
Second end

C

First start
Second start
Second end
First end

D

Second start
First start
Second end
First end

💡 Hint

Middleware calls next() to pass control to the next middleware.

Middlewares run in the order applied. Each logs before next(), then next middleware runs, then logs after next().

🧠 Conceptual

expert

Middleware scope and lifecycle

Which statement about NestJS middleware is true?

A Middleware can modify the request and response objects before reaching route handlers.

B Middleware is instantiated per request and can hold request-specific state.

C Middleware can only be applied globally, not to specific routes.

D Middleware is instantiated once per application and shared across all requests.

💡 Hint

Think about what middleware does in the request lifecycle.

Middleware runs before route handlers and can modify request and response objects. It is instantiated once and shared, not per request.