Search for a command to run...
Hi, Nice seeing you here I am a Software Engineer with a background in Computer Science having in-depth knowledge of Backend Development, Frontend Development and DevOps. I Love building and deploying systems with my knowledge and create a product that is easily accessible to all. Really appreciate your time.
No comments yet. Be the first to comment.
Welcome to "Mastering Node.js Concepts" series! Delve deep into Node.js, from core principles to advanced techniques, unleashing its full potential!
Authentication is the process of verifying the identity of a user or entity attempting to access a system or resource. It is a fundamental aspect of security in web development and is essential for ensuring that only authorized individuals or entitie...
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: Creating a server To create an express server we have to install express STEP 1.1: ...
Authentication is the process of verifying the identity of a user or entity attempting to access a system or resource. It is a fundamental aspect of security in web development and is essential for ensuring that only authorized individuals or entitie...
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: Creating a server To create an express server we have to install express STEP 1.1: I...
Given an array of N integers return an element that occurs more than N/2 times in the given array. The Brute Force The most Navie and brute force approach is - Loop through each of the elements of the array For each of the elements, find its count ...
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:
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.
Authentication and authorization: Middleware can handle user authentication and authorization by verifying credentials, checking access permissions, and managing user sessions or tokens.
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.
Caching: Middleware can implement caching mechanisms to store and retrieve frequently accessed data, reducing the load on backend systems and improving response times.
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.
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.
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.
Go to your desired directory and run the below command to setup an empty directory with package.json
npm init -y
npm i express jsonwebtoken
the above command will install the express and json web token to your project.
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`);
})
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.