Middleware ordering in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

Order of Middleware Execution in NestJS

Given the following NestJS middleware setup, what will be the order of console logs when a request hits the '/test' route?

NestJS

import { Injectable, NestMiddleware } from '@nestjs/common';

@Injectable()
class FirstMiddleware implements NestMiddleware {
  use(req, res, next) {
    console.log('First');
    next();
  }
}

@Injectable()
class SecondMiddleware implements NestMiddleware {
  use(req, res, next) {
    console.log('Second');
    next();
  }
}

// In AppModule
export class AppModule {
  configure(consumer) {
    consumer
      .apply(FirstMiddleware, SecondMiddleware)
      .forRoutes('/test');
  }
}

A First

B Second\nFirst

C Second

D First\nSecond

💡 Hint

Middleware are executed in the order they are applied in the consumer.

In NestJS, middleware functions run in the order they are passed to the apply() method. Here, FirstMiddleware runs before SecondMiddleware, so 'First' logs before 'Second'.

❓ lifecycle

intermediate

Middleware Execution with next() Skipped

What happens if a middleware in NestJS does NOT call next() in its use() method?

NestJS

import { Injectable, NestMiddleware } from '@nestjs/common';

@Injectable()
class BlockMiddleware implements NestMiddleware {
  use(req, res, next) {
    res.status(403).send('Blocked');
    // next() is NOT called
  }
}

// Applied as the only middleware on '/block' route

A An error is thrown because next() is missing.

B The request stops at BlockMiddleware and response 'Blocked' is sent; no further middleware or route handlers run.

C The request continues to next middleware or route handler despite missing next().

D The server crashes due to unhandled middleware.

💡 Hint

Calling next() passes control to the next middleware or handler.

If next() is not called, the middleware chain stops. Here, the middleware sends a response and does not call next(), so no other middleware or handlers run.

🔧 Debug

advanced

Unexpected Middleware Execution Order

You applied two middleware in this order: AuthMiddleware, LoggerMiddleware. But the logs show LoggerMiddleware runs before AuthMiddleware. What is the most likely cause?

NestJS

consumer
  .apply(AuthMiddleware, LoggerMiddleware)
  .forRoutes('*');

A LoggerMiddleware was globally applied before this consumer.apply call, so it runs first.

B Middleware order in apply() is reversed internally by NestJS.

C Middleware with longer names run later automatically.

D AuthMiddleware calls next() asynchronously, so LoggerMiddleware runs first.

💡 Hint

Global middleware run before route-specific middleware.

If LoggerMiddleware was registered globally before, it runs before route-specific middleware like AuthMiddleware, regardless of apply() order.

📝 Syntax

advanced

Correct Middleware Application Syntax

Which option correctly applies two middleware to the '/api' route in NestJS?

A consumer.use(AuthMiddleware, LoggerMiddleware).forRoutes('/api');

B consumer.apply([AuthMiddleware, LoggerMiddleware]).forRoutes('/api');

C consumer.apply(AuthMiddleware, LoggerMiddleware).forRoutes('/api');

D consumer.apply(AuthMiddleware).apply(LoggerMiddleware).forRoutes('/api');

💡 Hint

apply() accepts middleware as separate arguments, not as an array.

The apply() method takes middleware as separate arguments. Option C passes an array which is invalid. Option C chains apply() incorrectly. Option C uses a non-existent method 'use'.

❓ state_output

expert

Middleware Modifying Request Object

Consider two middleware applied in order: AddUserMiddleware adds req.user = {id: 1}, then LogUserMiddleware logs req.user. What will LogUserMiddleware output?

NestJS

import { Injectable, NestMiddleware } from '@nestjs/common';

@Injectable()
class AddUserMiddleware implements NestMiddleware {
  use(req, res, next) {
    req.user = { id: 1 };
    next();
  }
}

@Injectable()
class LogUserMiddleware implements NestMiddleware {
  use(req, res, next) {
    console.log(req.user);
    next();
  }
}

// Applied as consumer.apply(AddUserMiddleware, LogUserMiddleware).forRoutes('*');

A { id: 1 }

B undefined

C null

D Throws ReferenceError

💡 Hint

Middleware run in order and share the same request object.

AddUserMiddleware adds a user property to req before calling next(). LogUserMiddleware runs after and logs req.user, which is { id: 1 }.