Global middleware in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when a global middleware modifies the request object?

Consider a NestJS global middleware that adds a property requestTime to the request object. What will be the output of the controller logging req.requestTime?

NestJS

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

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    req['requestTime'] = '2024-06-01T12:00:00Z';
    next();
  }
}

// In main.ts
app.use(new LoggerMiddleware());

// In controller
@Get()
getHello(@Req() req: Request): string {
  console.log(req['requestTime']);
  return 'Hello World';
}

A Undefined is logged because request object is immutable

B '2024-06-01T12:00:00Z' is logged to the console

C An error is thrown because middleware cannot modify request

D The middleware does not run, so nothing is logged

💡 Hint

Think about how middleware can add properties to the request object before it reaches the controller.

Global middleware runs before the controller and can add properties to the request object. These properties are accessible in the controller, so the logged value is the string set in middleware.

❓ lifecycle

intermediate

When is a global middleware executed in NestJS?

At what point in the request lifecycle does a global middleware run in a NestJS application?

A Only when a specific route is matched

B After the controller returns a response

C Only after guards and interceptors run

D Before any route handler or controller processes the request

💡 Hint

Think about middleware as the first step in handling a request.

Global middleware runs before any controller or route handler. It processes the request early, allowing modifications or logging before the main logic.

🔧 Debug

advanced

Why does this global middleware not run in NestJS?

Given the following code, why does the middleware not run for incoming requests?

NestJS

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

@Injectable()
export class MyMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    console.log('Middleware running');
    next();
  }
}

// In main.ts
async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.use(new MyMiddleware());
  await app.listen(3000);
}
bootstrap();

A Middleware must implement OnModuleInit to run

B Middleware must be registered inside a module, not in main.ts

C app.use expects an instance, but MyMiddleware class was passed instead

D Middleware cannot log to console in NestJS

💡 Hint

Check how middleware is passed to app.use().

In NestJS, app.use() expects a function or middleware instance, not the class itself. Passing the class without instantiation means the middleware does not run.

📝 Syntax

advanced

Which option correctly applies a global middleware in NestJS 9+?

Choose the correct syntax to apply a global middleware in NestJS version 9 or later.

A app.use(new LoggerMiddleware());

B app.useGlobalMiddleware(new LoggerMiddleware());

C app.useGlobalPipes(new LoggerMiddleware());

D app.applyGlobalMiddleware(LoggerMiddleware);

💡 Hint

Remember how Express middleware is applied in NestJS.

In NestJS, global middleware is applied using app.use() with an instance or function. useGlobalMiddleware or applyGlobalMiddleware are not valid methods.

❓ state_output

expert

What is the final output after multiple global middleware modify the response header?

Two global middleware run in sequence. The first sets header X-First to one. The second sets X-Second to two. What headers will the client receive?

NestJS

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

@Injectable()
export class FirstMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    res.setHeader('X-First', 'one');
    next();
  }
}

@Injectable()
export class SecondMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    res.setHeader('X-Second', 'two');
    next();
  }
}

// In main.ts
app.use(new FirstMiddleware());
app.use(new SecondMiddleware());

// Controller returns 'OK'

A Headers include X-First: one and X-Second: two

B Only X-Second: two is present, X-First is overwritten

C Only X-First: one is present, X-Second is ignored

D No custom headers are sent due to middleware conflict

💡 Hint

Think about how HTTP headers are set and merged in Express response.

Each middleware sets a different header. Express merges headers, so both headers are sent to the client.