What is a Middleware ?

In Backend development middleware is the code snippet that resides before the server and the main purpose of a middleware is to filter out the request that does not perform a specific criteria which is written on the middleware.

In backend engineering, middleware refers to software components or functions that sit between the web server and the application logic, intercepting and processing incoming requests and outgoing responses. It provides a way to add additional functionality, modify requests or responses, and perform common tasks shared across multiple endpoints or routes in a web application.

Middleware functions are typically organized in a chain, where each middleware function can modify the request or response and pass it along to the next middleware in the chain. This allows for modular and reusable code, as different middleware functions can be combined and composed to build complex processing pipelines.

Some common use cases of middleware in backend engineering include:

1. Request parsing and validation: Middleware can parse incoming requests, extract data from headers or request bodies, and perform validation to ensure the request is properly formatted and meets certain criteria.

2. Authentication and authorization: Middleware can handle user authentication and authorization by verifying credentials, checking access permissions, and managing user sessions or tokens.

3. Logging and error handling: Middleware can log request details, response information, and errors for debugging and monitoring purposes. It can also handle and format error responses in a consistent manner.

4. Caching: Middleware can implement caching mechanisms to store and retrieve frequently accessed data, reducing the load on backend systems and improving response times.

5. Compression and response formatting: Middleware can compress response data to reduce bandwidth usage and format responses in a specific format, such as JSON or XML.

6. Rate limiting and throttling: Middleware can enforce limits on the number of requests a client can make within a certain timeframe to prevent abuse and ensure fair usage of resources.

Popular web frameworks often provide built-in middleware functionality, allowing developers to easily integrate and configure middleware in their applications. For example, in Express.js (a Node.js web framework), middleware functions are used to handle routing, parsing, authentication, and other common tasks.

By utilizing middleware, backend engineers can enhance the functionality, performance, and security of their applications, while keeping the core application logic focused and modular.

AuthMiddleware

The most common example of middleware is AuthMiddleware.

Auth middleware, short for authentication middleware, is a crucial component in web application development that enhances security by enforcing access control and validating user identities. It acts as a protective layer between the client and server, ensuring that only authorized users can access protected resources and perform specific actions within the application.

The primary function of auth middleware is to verify the authenticity of user requests and ensure that they have the necessary permissions to access certain endpoints or perform specific operations. It acts as a gatekeeper by intercepting incoming requests and validating the associated authentication credentials, such as tokens, session data, or API keys. If the credentials are valid and the user is authorized, the request is allowed to proceed to the intended endpoint or action. Otherwise, the middleware can deny access or redirect the user to an appropriate error page.

Creating AuthMiddleware in Node.js

STEP 0: Creating an empty Nodejs repository

Go to your desired directory and run the below command to setup an empty directory with package.json

npm init -y

STEP 1: Setting up the project

STEP 1.1: Installing Express & JsonWebToken

npm i express jsonwebtoken

the above command will install the express and json web token to your project.

STEP 1.2: Setting up the server

To create an express server we have to install express. Create a new javascript file - you can name it anything, for the sake of simplicity let's call it server.js A node server can be set up by just three lines of code as

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

// Apply the authMiddleware to all routes or 
// specific routes where authentication is required
app.use(authMiddleware);

// Define your routes here

// Example protected route
app.get('/protected', (req, res) => {
  // Access the user from the request object
  const { user } = req;
  res.json({ message: `Hello, ${user.username}! This is a protected route.` });
});

app.listen(3000, () => {
    console.log(`App is up and running at port 3000`);
})

STEP 1.3: Creating the Middleware

To implement the Middleware, we need to utilize JSON Web Tokens (JWT). The purpose of the Middleware is to parse the incoming token, allowing us to verify whether the corresponding user exists within our system or not. Let's create a new JavaScript file called "authMiddleware.js" for this functionality.

const jwt = require('jsonwebtoken');

module.exports = (req, res, next) => {
  // Get the token from the request headers
  const token = req.headers.authorization;

  // Check if the token is provided
  if (!token) {
    return res.status(401).json({ error: 'Authorization token not provided' });
  }

  try {
    // Verify and decode the token
    // Replace 'secret_key' with your own secret key
    const decodedToken = jwt.verify(token, 'secret_key');

    // Attach the decoded token to the request object for future use
    req.user = decodedToken;

    // Proceed to the next middleware or route handler
    next();
  } catch (error) {
    // Handle invalid or expired tokens
    return res.status(401).json({ error: 'Invalid token' });
  }
};

That's all, Thanks for scrolling.