Rest API with JWT Access

In this article, we will discuss how to create a Rest API with JWT access using Node.js, Express.js, and Mongoose. JSON Web Tokens (JWT) are a popular way to authenticate and secure APIs, and they are often used with Node.js to create secure RESTful APIs.

Node.js

Node.js is a popular open-source, cross-platform JavaScript runtime environment that allows developers to build server-side and networking applications. It provides a fast and efficient way to run JavaScript on the server, making it an ideal choice for creating RESTful APIs.

Express.js

Express.js is a web application framework for Node.js that provides a set of features for building web and mobile applications. It is minimal and flexible, providing a robust set of features for web and mobile applications, including support for routing, middleware, and more.

Mongoose

Mongoose is a MongoDB object modeling tool designed to work in an asynchronous environment. It provides a straight-forward, schema-based solution to model your application data with built-in type casting, validation, query building, and business logic hooks. It is an essential tool for working with MongoDB in Node.js applications.

Creating a Rest API with JWT Access

To create a Rest API with JWT access using Node.js, Express.js, and Mongoose, we will need to set up a Node.js project, install the required dependencies, create a MongoDB database, and then set up routes and middleware for handling JWT authentication.

First, we need to install Node.js and npm if we haven’t already. Then create a new directory for our project and run npm init to initialize a new Node.js project. Next, install the required dependencies using npm:

    
      npm install express mongoose jsonwebtoken
    
  

Once we have our dependencies installed, we can start creating our Express.js app, defining the mongoose model for our data, and setting up JWT authentication middleware. We will also need to create routes for handling user authentication, creating, reading, updating, and deleting data, and protecting those routes with JWT authentication middleware.

Below is an example of how our Express.js app might look:

    
      const express = require('express');
      const mongoose = require('mongoose');
      const jwt = require('jsonwebtoken');

      // Set up our Express app and mongoose connection

      const app = express();
      mongoose.connect('mongodb://localhost/rest-api-with-jwt', {
        useNewUrlParser: true,
        useUnifiedTopology: true
      });

      // Set up our mongoose model for our data

      const User = mongoose.model('User', {
        email: String,
        password: String
      });

      // Set up JWT authentication middleware

      const authenticateJWT = (req, res, next) => {
        const token = req.headers['authorization'];
        if (!token) {
          res.status(401).json({ message: 'Unauthorized' });
        } else {
          jwt.verify(token, 'secret', (err, user) => {
            if (err) {
              res.status(403).json({ message: 'Invalid token' });
            } else {
              req.user = user;
              next();
            }
          });
        }
      }

      // Set up routes for user authentication, data CRUD operations, and protected routes

      app.post('/api/auth', async (req, res) => {
        const { email, password } = req.body;
        const user = await User.findOne({ email, password });
        if (user) {
          const token = jwt.sign({ email: user.email }, 'secret');
          res.json({ token });
        } else {
          res.status(401).json({ message: 'Invalid credentials' });
        }
      });

      app.get('/api/data', authenticateJWT, (req, res) => {
        res.json({ message: 'Protected data' });
      });

      // Start the Express app

      app.listen(3000, () => {
        console.log('Server started on http://localhost:3000');
      });
    
  

With this code, we have set up a basic Express.js app, defined a mongoose model for our user data, and created routes for user authentication and protected data. We have also set up JWT authentication middleware for protecting our routes.

Conclusion

Creating a Rest API with JWT access using Node.js, Express.js, and Mongoose is a popular and effective way to build secure APIs. With this combination of tools, we can create a robust and secure API for handling user authentication, data CRUD operations, and protecting our routes using JWT authentication middleware.