Middleware ordering in NestJS - Step-by-Step Execution

Concept Flow - Middleware ordering

Request Received

↓

Middleware 1 Executes

↓

Middleware 2 Executes

↓

Route Handler Executes

↓

Response Sent Back

Middleware run in the order they are registered. Each middleware processes the request before passing it on.

Execution Sample

NestJS

app.use(middlewareOne);
app.use(middlewareTwo);

// Request -> middlewareOne -> middlewareTwo -> handler

Shows how two middlewares run in sequence before the route handler.

Execution Table

Step	Middleware	Action	Next Step
1	middlewareOne	Processes request, calls next()	Pass to middlewareTwo
2	middlewareTwo	Processes request, calls next()	Pass to route handler
3	Route Handler	Handles request, sends response	Response sent
4	-	Request cycle complete	End

💡 All middlewares called next(), request reached handler and response sent

Variable Tracker

Variable	Start	After middlewareOne	After middlewareTwo	Final
request.processedBy	[]	[middlewareOne]	[middlewareOne, middlewareTwo]	[middlewareOne, middlewareTwo, handler]

Key Moments - 2 Insights

Why does middlewareTwo run after middlewareOne?

Because middleware are called in the order they are registered, as shown in execution_table steps 1 and 2.

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

The request stops there and does not reach the next middleware or handler, so response is never sent. This is why calling next() is crucial.

Visual Quiz - 3 Questions

Look at the execution_table, what happens at step 2?

A middlewareTwo processes request and calls next()

B middlewareOne sends response

C Route handler executes

D Request ends without response

💡 Hint

Check execution_table row with Step 2 for middlewareTwo action

At which step does the route handler execute?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at execution_table row where Middleware is 'Route Handler'

If middlewareOne did not call next(), what would happen?

A middlewareTwo would still run

B Route handler would run immediately

C Request would stop at middlewareOne

D Response would be sent twice

💡 Hint

Refer to key_moments about importance of calling next()

Concept Snapshot

Middleware ordering in NestJS:
- Middleware run in registration order
- Each middleware must call next() to continue
- Request flows through all middlewares before handler
- Missing next() stops request chain
- Order affects processing and response timing

Full Transcript

In NestJS, middleware are functions that run in the order they are registered. When a request comes in, it first passes through the first middleware, which can process or modify the request, then calls next() to pass control to the next middleware. This continues until all middlewares have run, then the route handler executes to send the response. If any middleware does not call next(), the request stops there and the response is not sent. This flow is shown step-by-step in the execution table and variable tracker, illustrating how the request is processed sequentially. Understanding this order helps avoid bugs and ensures middleware behave as expected.

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