Custom Middleware for Request Processing

What is Express Middleware?

At its core, middleware is simply a function that runs in the middle of the request-response cycle. When your Express server receives a request, it passes it through a chain or "pipeline" of middleware functions before your final route handler sends a response.

Each middleware function has access to three key objects:

• The request object (req): Contains information about the incoming HTTP request.
• The response object (res): Used to build and send the HTTP response.
• The next function: A callback function that, when called, passes control to the next middleware function in the chain.

A middleware function can:

1. Execute any code.
2. Make changes to the req and res objects.
3. End the request-response cycle by sending a response.
4. Call the next() function to pass control to the next middleware.

If a middleware function doesn't end the cycle or call next(), the request will simply be left hanging, and the client will time out.

To see this concept explained, watch the first part of the following video.

Writing Your First Middleware: A Request Logger

The classic first step is to create a logger. It's a simple, practical example that demonstrates the fundamental mechanics. A logger helps in debugging by showing you exactly what requests are hitting your server.

Let's write a function that logs the HTTP method and the path of every incoming request.

// A simple logger middleware
const logger = (req, res, next) => {
  console.log(`${req.method} ${req.originalUrl}`);
  next(); // Pass control to the next middleware
};

To make this logger run for every single request that comes into our application, we use app.use(). The order is crucial: middleware defined with app.use() must be placed before your route definitions to ensure it runs first.

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

const logger = (req, res, next) => {
  console.log(`${req.method} ${req.originalUrl}`);
  next();
};

// Use the logger middleware for all incoming requests
app.use(logger);

// Your routes
app.get('/', (req, res) => {
  res.send('Homepage');
});

app.get('/users', (req, res) => {
  res.send('Users Page');
});

// ... start the server

Now, every time you visit a page, you'll see a log in your terminal, like GET / or GET /users. Notice the next() call. Without it, the request would be logged, but it would never reach the route handlers for / or /users.

Common Middleware Use Cases

Middleware is incredibly versatile. Let's explore two of the most common and practical patterns you'll use constantly.

1. Validating Input and Terminating Requests

Middleware is the perfect place to put validation logic. You can check for required headers, query parameters, or body properties. If the validation fails, you can send an error response immediately, preventing invalid data from ever reaching your core business logic.

Let's watch how to create a middleware that validates the presence of an Authorization header.

As you saw in the video, a middleware function can add properties to the req object (e.g., req.userId = 1). This is a standard pattern for passing information from one middleware (like an authentication middleware) to the next middleware or to the final route handler.

Another common validation is ensuring the client is sending data in the correct format. For a REST API, you'll almost always want JSON. Here is a middleware function that checks the Content-Type header on incoming POST requests.

const requireJsonContent = (req, res, next) => {
  if (req.headers['content-type'] !== 'application/json') {
      res.status(400).send('Server requires application/json');
  } else {
      next();
  }
};

2. Applying Middleware Selectively

You don't always want middleware to run on every single request. Express gives you precise control over where it's applied.

• Globally (all routes): app.use(myMiddleware) - We've already seen this.
• For a specific router: router.use(myMiddleware) - This is very powerful. You can apply authentication middleware to your entire /users router, but not to your public /products router.
• For a single route: app.get('/secret', myMiddleware, routeHandler) - The middleware runs only for requests to this specific path and method.

The following video shows how to apply middleware to a single, specific route.

An Essential Best Practice: return When You Respond

One of the most common bugs when writing middleware involves forgetting to stop the function's execution after sending a response.

Consider this faulty code:

// BUGGY CODE!
const myMiddleware = (req, res, next) => {
  if (validationFails) {
    res.status(400).send('Invalid');
    // The function continues here!
  }
  next(); // This will still run!
}

If the validation fails, Express sends the 400 response. But the function doesn't stop; it continues and calls next(), which tries to send another response in the next handler. This causes the infamous error: Error: Cannot set headers after they are sent to the client.

The fix is simple: when you send a response and want to end the cycle, return.

// CORRECTED CODE
const myMiddleware = (req, res, next) => {
  if (validationFails) {
    return res.status(400).send('Invalid'); // Note the 'return'
  }
  next();
}

This concept is so important and can be tricky. This video explains the problem and solution perfectly.

Conclusion

You've just unlocked one of the most powerful and fundamental features of Express. Custom middleware allows you to keep your code DRY (Don't Repeat Yourself) and organized by separating cross-cutting concerns like logging, authentication, and validation from your core route logic.

Key Takeaways:

• Middleware functions are the building blocks of an Express application, running in a pipeline between the request and response.
• They always receive req, res, and next as arguments.
• You must either send a response or call next() to avoid hanging the request.
• Use return when sending a response from middleware to prevent the "headers already sent" error.
• Middleware can be applied globally with app.use(), to a group of routes with router.use(), or to a single endpoint.
• Common use cases include logging requests, validating input, checking authentication, and adding data to the request object.

Preview of the Next Lesson:
We've focused on what happens when things go right. But what happens when an error occurs deep inside one of your route handlers? In our next lesson, we'll explore a special kind of middleware designed specifically for this: a centralized error-handling middleware. This will allow us to catch all errors in one place and send back consistent, professional error responses, making our API much more robust.