Middleware ordering in NestJS - Mini Project: Build & Apply

Middleware Ordering in NestJS

📖 Scenario: You are building a simple NestJS application that logs requests and checks authentication. The order of middleware matters because logging should happen before authentication.

🎯 Goal: Create two middleware functions: one for logging requests and one for authentication. Apply them in the correct order so that logging runs before authentication for all routes.

📋 What You'll Learn

Create a logging middleware function named loggerMiddleware that logs the request method and URL.

Create an authentication middleware function named authMiddleware that checks for a header x-auth-token and rejects requests without it.

Apply both middleware functions globally in the correct order: loggerMiddleware first, then authMiddleware.

Use NestJS middleware consumer and configure method in the main app module.

💡 Why This Matters

🌍 Real World

Middleware ordering is important in web applications to ensure tasks like logging, authentication, and validation happen in the correct sequence.

💼 Career

Understanding middleware and its order is essential for backend developers working with NestJS or similar frameworks to build secure and maintainable APIs.

1

Create the logging middleware function

Create a middleware function called loggerMiddleware that logs the HTTP method and URL of each request using console.log. The function should accept req, res, and next parameters and call next() at the end.

NestJS

# Create loggerMiddleware function
// Your code here

Hint

Middleware functions in NestJS receive req, res, and next. Use console.log to print the method and URL.

2

Create the authentication middleware function

Create a middleware function called authMiddleware that checks if the request header x-auth-token exists. If it does not exist, respond with status 401 and message 'Unauthorized'. Otherwise, call next().

NestJS

function loggerMiddleware(req, res, next) {
  console.log(`Request: ${req.method} ${req.url}`);
  next();
}

// Create authMiddleware function
// Your code here

Hint

Check the header x-auth-token in req.headers. If missing, send a 401 response. Otherwise, call next().

3

Apply middleware in the correct order

In the AppModule class, implement the configure method. Use the consumer parameter to apply loggerMiddleware first, then authMiddleware to all routes using forRoutes('*').

NestJS

function loggerMiddleware(req, res, next) {
  console.log(`Request: ${req.method} ${req.url}`);
  next();
}

function authMiddleware(req, res, next) {
  if (!req.headers['x-auth-token']) {
    res.status(401).send('Unauthorized');
  } else {
    next();
  }
}

import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';

@Module({})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      // Apply loggerMiddleware first
      // Apply authMiddleware second
      // to all routes
    
    // Your code here
  }
}

Hint

Use consumer.apply() with both middleware functions in the correct order, then call forRoutes('*') to apply globally.

4

Export middleware functions and finalize module

Add export keywords before loggerMiddleware and authMiddleware functions so they can be imported elsewhere if needed. Ensure the AppModule class is exported as well.

NestJS

function loggerMiddleware(req, res, next) {
  console.log(`Request: ${req.method} ${req.url}`);
  next();
}

function authMiddleware(req, res, next) {
  if (!req.headers['x-auth-token']) {
    res.status(401).send('Unauthorized');
  } else {
    next();
  }
}

import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';

@Module({})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(loggerMiddleware, authMiddleware)
      .forRoutes('*');
  }
}

// Add export keyword before both middleware functions
// Your code here

Hint

Use export before the middleware functions and the AppModule class to make them available outside this file.

Practice

1. In NestJS, why is the order of middleware important when using the apply() method?

easy

A. Because middleware order controls the type of HTTP methods allowed.

B. Because middleware order changes the port number the server listens on.

C. Because middleware order determines the database connection settings.

D. Because middleware runs in the order they are applied, affecting request processing sequence.

Solution

1. Step 1: Understand middleware execution flow

   Middleware functions run in the order they are applied to the request pipeline.

2. Step 2: Recognize impact on request handling

   The order affects how requests are logged, authenticated, or modified before reaching the route handler.

3. Final Answer:

   Because middleware runs in the order they are applied, affecting request processing sequence. -> Option D

4. Quick Check:

   Middleware order = request handling sequence [OK]

Hint: Middleware order controls request flow sequence [OK]

Common Mistakes:

• Thinking middleware order changes server port
• Confusing middleware order with database settings
• Assuming middleware order controls HTTP methods

2. Which of the following is the correct way to apply two middleware functions authMiddleware and loggerMiddleware in order using NestJS apply() method?

easy

A. apply([authMiddleware, loggerMiddleware]).forRoutes('*')

B. apply(loggerMiddleware, authMiddleware).forRoutes('*')

C. apply(authMiddleware, loggerMiddleware).forRoutes('*')

D. apply(loggerMiddleware).apply(authMiddleware).forRoutes('*')

Solution

1. Step 1: Recall correct syntax for multiple middleware

   Use apply(middleware1, middleware2) to apply middleware in order.

2. Step 2: Confirm order matches desired sequence

   To run authMiddleware before loggerMiddleware, list authMiddleware first.

3. Final Answer:

   apply(authMiddleware, loggerMiddleware).forRoutes('*') -> Option C

4. Quick Check:

   apply(mw1, mw2) = correct syntax [OK]

Hint: List middleware in apply() in desired run order [OK]

Common Mistakes:

• Reversing middleware order in apply()
• Using multiple apply() calls incorrectly
• Passing middleware as an array inside apply()

3. Given the following middleware setup in NestJS:

apply(authMiddleware, loggerMiddleware).forRoutes('users')

What will be the order of middleware execution when a request hits the 'users' route?

medium

A. authMiddleware runs first, then loggerMiddleware

B. loggerMiddleware runs first, then authMiddleware

C. Both run simultaneously

D. Only authMiddleware runs

Solution

1. Step 1: Identify middleware order in apply()

   Middleware listed first runs first; here, authMiddleware is first.

2. Step 2: Confirm sequence on route match

   When a request matches 'users', authMiddleware runs before loggerMiddleware.

3. Final Answer:

   authMiddleware runs first, then loggerMiddleware -> Option A

4. Quick Check:

   apply order = execution order [OK]

Hint: First middleware in apply() runs first [OK]

Common Mistakes:

• Assuming middleware run simultaneously
• Thinking last middleware runs first
• Ignoring route matching

4. You wrote this middleware setup in NestJS:

apply(loggerMiddleware, authMiddleware).forRoutes('profile')

But you want authMiddleware to run before loggerMiddleware. What is the fix?

medium

A. Use apply(authMiddleware).apply(loggerMiddleware).forRoutes('profile')

B. Swap the middleware order to apply(authMiddleware, loggerMiddleware).forRoutes('profile')

C. Change forRoutes to forRoutes('auth')

D. No fix needed; order does not matter

Solution

1. Step 1: Identify current middleware order

   Currently, loggerMiddleware runs before authMiddleware.

2. Step 2: Swap middleware order in apply()

   To run authMiddleware first, list it first in apply().

3. Final Answer:

   Swap the middleware order to apply(authMiddleware, loggerMiddleware).forRoutes('profile') -> Option B

4. Quick Check:

   Middleware order in apply() = execution order [OK]

Hint: Swap middleware order in apply() to fix sequence [OK]

Common Mistakes:

• Changing route instead of middleware order
• Using multiple apply() calls incorrectly
• Assuming order does not affect execution

5. You want to log every request before authenticating it and then modify the request body only after authentication in NestJS. Which middleware order should you apply?

hard

A. apply(loggerMiddleware, authMiddleware, modifyBodyMiddleware).forRoutes('*')

B. apply(authMiddleware, loggerMiddleware, modifyBodyMiddleware).forRoutes('*')

C. apply(modifyBodyMiddleware, loggerMiddleware, authMiddleware).forRoutes('*')

D. apply(authMiddleware, modifyBodyMiddleware, loggerMiddleware).forRoutes('*')

Solution

1. Step 1: Determine desired middleware sequence

   Requests should be logged first, then authenticated, then modified.

2. Step 2: Arrange middleware in apply() accordingly

   List loggerMiddleware first, then authMiddleware, then modifyBodyMiddleware.

3. Final Answer:

   apply(loggerMiddleware, authMiddleware, modifyBodyMiddleware).forRoutes('*') -> Option A

4. Quick Check:

   Middleware order = log -> auth -> modify [OK]

Hint: Order middleware as log, auth, then modify [OK]

Common Mistakes:

• Placing modifyBodyMiddleware before authMiddleware
• Logging after authentication
• Incorrect middleware sequence in apply()