Middleware ordering in NestJS - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is middleware ordering in NestJS?

Middleware ordering in NestJS means the sequence in which middleware functions run for incoming requests. The order affects how requests are processed and which middleware runs first.

beginner

How does NestJS determine the order of middleware execution?

NestJS runs middleware in the order they are applied in the module's configure() method. The first middleware added runs first, then the next, and so on.

intermediate

Why is middleware order important in NestJS?

Middleware order is important because earlier middleware can modify the request or response before later middleware runs. Wrong order can cause unexpected behavior or errors.

intermediate

How do you apply multiple middleware in a specific order in NestJS?

In the configure() method of a module, call apply() with middleware functions in the desired order, chaining .forRoutes() to specify routes. The order of middleware in apply() sets execution order.

advanced

What happens if middleware calls next() multiple times or not at all?

If middleware calls next() multiple times, it can cause errors or unexpected behavior. If it never calls next(), the request will hang and not reach later middleware or handlers.

In NestJS, which middleware runs first?

A Middleware runs in alphabetical order

B The first middleware applied in the configure() method

C Middleware runs in random order

D The last middleware applied in the configure() method

NestJS executes middleware in the order they are applied in the configure() method, so the first applied middleware runs first.

What does calling next() inside middleware do?

A Restarts the middleware chain

B Stops the request processing immediately

C Passes control to the next middleware or route handler

D Sends a response to the client

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

If middleware A is applied before middleware B, which runs second?

A Middleware B

B Middleware A

C Both run simultaneously

D Depends on the route

Middleware runs in the order applied, so middleware B runs after middleware A.

What happens if a middleware does not call next()?

A The request hangs and does not proceed

B The next middleware runs anyway

C The server crashes

D The response is sent automatically

If next() is not called, the request stops and does not move to the next middleware or handler.

How do you apply middleware to specific routes in NestJS?

A Middleware applies globally by default

B NestJS does not support route-specific middleware

C Use decorators on middleware functions

D Use .forRoutes() with route paths or controllers

You specify routes or controllers in .forRoutes() when applying middleware to limit where it runs.

Explain how middleware ordering affects request handling in NestJS.

Think about how a request passes through each middleware step by step.

Describe how to apply multiple middleware in a specific order to routes in NestJS.

Focus on the configure() method and chaining apply() calls.

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()