Middleware and its type in expressjs/Nodejs
Tags: node, express, react, nextjs
Published: 2021-05-02 16:44:25

# What is middleware

Middleware is a kind of function that can change the `request` and `response` object and also can finish the request and response cycle.

> This article assumes that you have basic knowledge of middleware

## Rights of middleware

Middleware has all rights that any route handler can have in `expressjs`. Middleware can do everything which any route handler can do.

***Middleware can***

* Execute any code.
* Make changes to the request and the response objects.
* End the request-response cycle.
* Call the next middleware function in the stack.

> Withour wasting much time, lets queckly jump on the types of middleware

## Types of middleware

There are five types of middleware

1. Application-level middleware
2. Router level middleware
3. Error handling middleware
4. Built-in middleware
5. Third-party middleware

> Router level and application leven middleware can be loaded with optional mount path

- - -

**For the rest of the article, we'll use the following middleware for demonstration and express instance**

``` js
const express = require('express');
const app = express(); // express instance

function MW(req,res,next){
    console.log("I am middleware!");
    next(0;
}
```

### Application-level middleware

Application-level middleware can be registered with the `express` instance directly.

If we don't use any mount path then middleware will be executed for every request.

``` js
app.use(MW);
```

We can use any mount path to register middleware.

``` js
// here, /path and /path/:userid are mount paths
app.use("/path",MW);

// it can also accept params
app.use("/path/:userId",MW);
```

We can also register more than one middleware for a single mount path at once

``` js
// insted of doing
app.use("/path",MW1);
app.use("/path",MW2);
app.use("/path",MW3);

// we can do
app.use("/path",MW1,MW2,MW3);

// we can also pass array of middleware
app.use("/path",[MW1,MW2,MW3]);
```

### Router level middleware

Router level middleware can be defined in the same way as application-level middleware

``` js
var router = express.Router()
router.use("/path",MW1);
```

We can also assign middleware to any specific path.

``` js
router.use('/user/:id', function (req, res, next) {
  console.log('Request URL:', req.originalUrl)
  next()
}, function (req, res, next) {
  console.log('Request Type:', req.method)
  next()
})
```

### Error-handling middleware

> Error-handling middleware always takes four arguments `(err, req, res, next)`

``` js
app.use(function (err, req, res, next) {
  console.error(err.stack)
  res.status(500).send('Something broke!')
})
```

You must take care of the ordering of the middleware while declaring error handling middleware.

``` js
// i will be never called
app.use(function (err, req, res, next) {
  console.error(err.stack)
  res.status(500).send('Something broke!')
})

app.get("/*",(_,res,next)=>{
    try{
        throw new Error("This is the error!");
    }catch(e){
        next(e)
    }
})
```

Here, the above middleware will be never called because the route is declared after middleware, to make it work we need to define it after the route.

``` js
// This works fine
app.get("/*",(_,res,next)=>{
    try{
        throw new Error("This is the error!");
    }catch(e){
        next(e)
    }
})

app.use(function (err, req, res, next) {
  console.error(err.stack)
  res.status(500).send('Something broke!')
})
```

### Built-in middleware

Built-in middleware is provided by express itself like, `express.static()` etc.

### Third-party middleware

Third-party middleware is provided by any third party of any NPM module, like `cooki-parser`, `body-parser`, etc.

### Thanks