Functional middleware in NestJS

Introduction

Functional middleware lets you run code before your NestJS route handlers. It helps you add features like logging or checking user access simply.

You want to log every request to your server.

You need to check if a user is logged in before accessing certain pages.

You want to modify request data before it reaches your route.

You want to add headers or cookies to responses.

You want to block requests from certain IP addresses.

Syntax

NestJS

import { Request, Response, NextFunction } from 'express';

export function myMiddleware(req: Request, res: Response, next: NextFunction) {
  // your code here
  next();
}

Functional middleware is a simple function with three parameters: request, response, and next.

Always call next() to pass control to the next middleware or route handler.

Examples

This middleware logs the URL of every request.

NestJS

export function logger(req, res, next) {
  console.log(`Request to: ${req.url}`);
  next();
}

This middleware checks if the request has an authorization header and blocks if missing.

NestJS

export function checkAuth(req, res, next) {
  if (!req.headers.authorization) {
    return res.status(401).send('Unauthorized');
  }
  next();
}

Sample Program

This example shows a functional middleware logger that logs every request's method and URL. It is applied to all routes in the app module. When you visit http://localhost:3000, the middleware logs the request, and the controller returns 'Hello World!'.

NestJS

import { NestFactory } from '@nestjs/core';
import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';

// Functional middleware to log requests
export function logger(req: Request, res: Response, next: NextFunction) {
  console.log(`Request Method: ${req.method}, URL: ${req.url}`);
  next();
}

// Simple controller
import { Controller, Get } from '@nestjs/common';

@Controller()
class AppController {
  @Get()
  getHello() {
    return 'Hello World!';
  }
}

@Module({
  controllers: [AppController],
})
class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(logger) // apply functional middleware
      .forRoutes('*'); // for all routes
  }
}

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
  console.log('Server running on http://localhost:3000');
}

bootstrap();

Important Notes

Functional middleware is easy to write and use for simple tasks.

Remember to always call next() or the request will hang.

You can apply middleware to specific routes or all routes.

Summary

Functional middleware is a simple function that runs before route handlers.

It helps add features like logging, authentication, or modifying requests.

Always call next() to continue the request cycle.

Practice

1. What is the main purpose of functional middleware in NestJS?

easy

A. To run code before the route handler to modify requests or add features

B. To define database models for the application

C. To create UI components for the frontend

D. To compile TypeScript code into JavaScript

Solution

1. Step 1: Understand middleware role

   Middleware runs before route handlers to process requests or add features like logging or authentication.

2. Step 2: Identify correct purpose

   Options A, B, and D relate to other parts of development, not middleware.

3. Final Answer:

   To run code before the route handler to modify requests or add features -> Option A

4. Quick Check:

   Middleware runs before routes = C [OK]

Hint: Middleware runs before routes to add features [OK]

Common Mistakes:

• Confusing middleware with database models
• Thinking middleware creates UI components
• Believing middleware compiles code

2. Which of the following is the correct way to define a functional middleware in NestJS?

easy

A. function logger(req, res) { console.log(req.url); }

B. class Logger { log(req, res) { console.log(req.url); } }

C. const logger = () => { console.log('log'); }

D. function logger(req, res, next) { console.log(req.url); next(); }

Solution

1. Step 1: Check middleware signature

   Functional middleware must accept (req, res, next) and call next() to continue.

2. Step 2: Validate options

   function logger(req, res, next) { console.log(req.url); next(); } matches this pattern. class Logger { log(req, res) { console.log(req.url); } } is a class, not functional middleware. const logger = () => { console.log('log'); } lacks parameters and next call. function logger(req, res) { console.log(req.url); } misses next parameter and call.

3. Final Answer:

   function logger(req, res, next) { console.log(req.url); next(); } -> Option D

4. Quick Check:

   Middleware needs (req, res, next) and calls next() [OK]

Hint: Middleware needs (req, res, next) and calls next() [OK]

Common Mistakes:

• Omitting the next parameter
• Not calling next() inside middleware
• Using class instead of function for functional middleware

3. Given this middleware code, what will be logged when a request to '/home' is made?

function logger(req, res, next) {
  console.log('Request URL:', req.url);
  next();
}

medium

A. Request URL: undefined

B. Request URL: /home

C. No output because next() stops logging

D. Error: req.url is not defined

Solution

1. Step 1: Understand req.url property

   In middleware, req.url contains the path of the incoming request, here '/home'.

2. Step 2: Analyze console.log output

   The middleware logs 'Request URL:' followed by req.url, so it prints 'Request URL: /home'.

3. Final Answer:

   Request URL: /home -> Option B

4. Quick Check:

   req.url logs request path = A [OK]

Hint: req.url holds the request path string [OK]

Common Mistakes:

• Assuming next() stops console.log
• Thinking req.url is undefined
• Confusing middleware with route handler output

4. Identify the error in this functional middleware code:

function auth(req, res, next) {
  if (!req.headers.authorization) {
    res.status(401).send('Unauthorized');
  }
  next();
}

medium

A. res.status should be res.sendStatus

B. Missing req parameter in function signature

C. next() is called even after sending response, causing errors

D. Authorization header check is incorrect

Solution

1. Step 1: Analyze flow after sending response

   If authorization header is missing, response is sent with 401, but next() is still called, which can cause errors by continuing the request cycle.

2. Step 2: Identify correct fix

   To fix, add return before res.status(401).send(...) to stop execution or call next() only if authorized.

3. Final Answer:

   next() is called even after sending response, causing errors -> Option C

4. Quick Check:

   Call next() only if no response sent [OK]

Hint: Don't call next() after sending response [OK]

Common Mistakes:

• Calling next() after res.send causes errors
• Forgetting to stop middleware after response
• Misusing res.status vs res.sendStatus

5. You want to create a functional middleware that adds a custom header 'X-App-Version' with value '1.0' to every response. Which code correctly implements this?

hard

A. function addVersion(req, res, next) { res.setHeader('X-App-Version', '1.0'); next(); }

B. function addVersion(req, res) { res.setHeader('X-App-Version', '1.0'); }

C. function addVersion(req, res, next) { next(); res.setHeader('X-App-Version', '1.0'); }

D. function addVersion(req, res, next) { req.setHeader('X-App-Version', '1.0'); next(); }

Solution

1. Step 1: Confirm middleware signature and header setting

   Middleware must accept (req, res, next) and call next() after setting headers. res.setHeader is correct method.

2. Step 2: Evaluate options

   function addVersion(req, res, next) { res.setHeader('X-App-Version', '1.0'); next(); } sets header then calls next() correctly. function addVersion(req, res) { res.setHeader('X-App-Version', '1.0'); } misses next parameter and call. function addVersion(req, res, next) { next(); res.setHeader('X-App-Version', '1.0'); } calls next() before setting header, so header may not be sent. function addVersion(req, res, next) { req.setHeader('X-App-Version', '1.0'); next(); } uses req.setHeader which is incorrect because req cannot set response headers.

3. Final Answer:

   function addVersion(req, res, next) { res.setHeader('X-App-Version', '1.0'); next(); } -> Option A

4. Quick Check:

   Set header before next() with correct method [OK]

Hint: Set header before next() using res.setHeader [OK]

Common Mistakes:

• Calling next() before setting headers
• Omitting next parameter or call
• Confusing req and res when setting headers