Creating and Using Custom Middleware in Express.js

Middleware functions are the backbone of Express.js applications. They’re like magical gatekeepers that can process requests before they reach their final destination. Today, let’s dive into creating our own custom middleware functions.

What is Middleware?

Think of middleware as a chain of operations that your requests go through. Each middleware function can modify the request, response, or pass control to the next middleware in line. It’s like a conveyor belt in a factory, where each station adds or checks something specific.

Creating Your First Custom Middleware

Let’s start with a simple example. Here’s how you can create a middleware function that logs request details:

const requestLogger = (req, res, next) => {
    const timestamp = new Date().toISOString();
    console.log(`${timestamp} - ${req.method} ${req.url}`);
    next();
};

app.use(requestLogger);

Middleware for Authentication

One common use case is authentication. Here’s a basic authentication middleware:

const authMiddleware = (req, res, next) => {
    const apiKey = req.headers['api-key'];

    if (!apiKey || apiKey !== 'your-secret-key') {
        return res.status(401).json({ error: 'Unauthorized' });
    }

    next();
};

Error Handling Middleware

Error handling middleware is special - it takes four parameters instead of three:

const errorHandler = (err, req, res, next) => {
    console.error(err.stack);
    res.status(500).json({
        error: 'Something broke!'
    });
};

app.use(errorHandler);

Best Practices

1. Always call next() unless you’re ending the request-response cycle
2. Keep middleware functions focused and single-purpose
3. Order matters - place middleware in the correct sequence
4. Use error handling middleware last in your chain

Practical Use Cases

• Request validation
• Data transformation
• Response compression
• Rate limiting
• CORS handling
• Logging and monitoring

Remember, middleware is what makes Express.js so flexible and powerful. Master it, and you’ll be able to build more robust and maintainable applications.