Express Middleware

Express Middleware

In Express.js, middleware functions are the core building blocks for handling requests and responses. Middleware functions are functions that have access to the request object (req), the response object (res), and the next middleware function in the application’s request-response cycle.

Middleware can perform tasks such as executing code, modifying the request and response objects, ending the request-response cycle, or calling the next middleware in the stack. Express applications are essentially a chain of middleware functions that are executed in the order they are defined.

Types of Middleware

• Application-level middleware
• Router-level middleware
• Error-handling middleware
• Built-in middleware
• Third-party middleware

Application-Level Middleware

This middleware is bound to the instance of the Express application using app.use() or app.METHOD().

const express = require('express');
const app = express();

// Middleware function
app.use((req, res, next) => {
    console.log('Time:', Date.now());
    next();
});

app.get('/', (req, res) => {
    res.send('Hello from the root route!');
});

app.listen(3000);

Router-Level Middleware

Router-level middleware works in the same way as application-level middleware, except it is bound to an instance of express.Router().

const express = require('express');
const router = express.Router();

router.use((req, res, next) => {
    console.log('Request URL:', req.originalUrl);
    next();
});

router.get('/user', (req, res) => {
    res.send('User route');
});

const app = express();
app.use('/api', router);

app.listen(3000);

Built-in Middleware

Express includes several built-in middleware functions starting from version 4.x such as:

• express.static – Serves static assets
• express.json – Parses incoming JSON requests
• express.urlencoded – Parses URL-encoded data

const express = require('express');
const app = express();

app.use(express.json());

app.post('/data', (req, res) => {
    res.json(req.body);
});

app.listen(3000);

Third-Party Middleware

These are middleware modules created by the community and installed via npm. Examples include morgan, cors, helmet, and body-parser.

const express = require('express');
const morgan = require('morgan');
const app = express();

app.use(morgan('dev'));

app.get('/', (req, res) => {
    res.send('Logging HTTP requests with Morgan');
});

app.listen(3000);

Error-Handling Middleware

Error-handling middleware has four parameters: err, req, res, and next. It must be defined after all other app.use() and route calls.

const express = require('express');
const app = express();

app.get('/', (req, res) => {
    throw new Error('Something went wrong!');
});

// Error handling middleware
app.use((err, req, res, next) => {
    console.error(err.stack);
    res.status(500).send('Something broke!');
});

app.listen(3000);

Custom Middleware Example

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

app.use(logger);

app.get('/', (req, res) => {
    res.send('Middleware example with custom logger');
});

Order of Middleware Execution

Middleware functions execute in the order they are defined. This is crucial for correct behavior, especially for parsing, logging, and error handling.

app.use(middleware1);
app.use(middleware2);

app.get('/', (req, res) => {
    res.send('Final route handler');
});

Middleware is at the heart of Express.js. It provides a powerful and flexible way to intercept and manipulate requests and responses. Whether you’re logging data, validating input, handling errors, or adding custom functionality, middleware allows you to modularize and control your application’s behavior at every stage of the request-response cycle.