onlinecode

Generate JWT token after login and verify with Node.js API

onlinecode

Generate JWT token after login and verify with Node.js API

In this post we will give you information about Generate JWT token after login and verify with Node.js API. Hear we will give you detail about Generate JWT token after login and verify with Node.js APIAnd how to use it also give you demo for it if it is necessary.

Generate JWT token after login and verify with Node.js API

In my last tutorial, I explained about how to login and register the user in the Node.js without using any security token.

But now I will tell you how to create a token using JWT library and authenticate APIs using the generated token in Node.js application.

Authentication, is what? It is just the way to keep unauthorized users out from accessing your secure APIs to interact with the database. Authentication is a main concern of the secure application.

Token based authentication is called stateless and session less because whenever we authenticate any user then we do not save any user details on the server, We simply generate a token that is signed by a private key and send it to the user to authenticate all secure api with generated token.

In this post, The flow of authenticate a token is as follows :

  • Verify username and password from the database.

  • Generate a JWT token if user credentials match with database record and send it to the client.

  • The client saves token and sends it with all secure APIs.

  • Use middleware to verifies the token and process the request.

You can send token in any way but this is good practice to send token in an HTTP header.


Getting Started

Before going with the steps, Make sure you have installed node and npm.

Let’s have a look at our directory structure for Node application.


Directory Structure 

  1. ├── controllers
  2. │ └── authenticate-controller.js
  3. ├── node_modules
  4. ├── config.js
  5. ├── index.js
  6. └── package.json
├── controllers
│ └── authenticate-controller.js
├── node_modules
├── config.js
├── index.js
└── package.json



Require the dependencies for Node Application

package.json is a beginning file for node application where you can see the list installed packages in your node application.


package.json 

{
  "name": "jwt",
  "version": "1.0.0",
  "description": "jwt authentication",
  "main": "index.js",
  "dependencies": {
    "body-parser": "^1.17.1",
    "express": "^4.14.1",
    "jsonwebtoken": "^7.3.0",
    "mysql": "^2.13.0"
  },
  "devDependencies": {},
  "scripts": {
    "test": "echo "Error: no test specified" && exit 1"
  },
  "author": "",
  "license": "ISC"
}

express module is the very popular Node framework.

body-parser module is used to get data from POST request.

jsonwebtoken module is used to generate and authenticate our JSON Web Tokens.

mysql module is how you work with database.


Configure database connection

In this step, we will create a connection object that will used with every database query.


config.js

  1. var mysql      =require('mysql');
  2. var connection = mysql.createConnection({
  3.   host     :'localhost',
  4.   user     :'root',
  5.   password :'',
  6.   database :'test'
  7. });
  8. connection.connect(function(err){
  9. if(!err){
  10.     console.log("Database is connected");
  11. }else{
  12.     console.log("Error while connecting with database");
  13. }
  14. });
  15. module.exports = connection;
var mysql      = require('mysql');
var connection = mysql.createConnection({
  host     : 'localhost',
  user     : 'root',
  password : '',
  database : 'test'
});
connection.connect(function(err){
if(!err) {
    console.log("Database is connected");
} else {
    console.log("Error while connecting with database");
}
});
module.exports = connection;


Node Application : index.js

In this step, we will include the packages we installed.

  1. var express=require("express");
  2. var bodyParser=require('body-parser');
  3. var jwt=require("jsonwebtoken");
  4. var app =express();
  5. var router=express.Router();
  7. var authenticateController=require('./controllers/authenticate-controller');
  9. process.env.SECRET_KEY="thisismysecretkey";
  11. app.use(bodyParser.urlencoded({extended:true}));
  12. app.use(bodyParser.json());
  14. app.post('/api/authenticate',authenticateController.authenticate);
  16. app.use('/secure-api',router);
  17. // validation middleware
  18. router.use(function(req,res,next){
  19.     var token=req.body.token || req.headers['token'];
  20.     if(token){
  21.         jwt.verify(token,process.env.SECRET_KEY,function(err,ress){
  22.             if(err){
  23.                 res.status(500).send('Token Invalid');
  24.             }else{
  25.                 next();
  26.             }
  27.         })
  28.     }else{
  29.         res.send('Please send a token')
  30.     }
  31. })
  33. router.get('/home',function(req,res){
  34.     res.send('Token Verified')
  35. })
  37. app.listen(8012);
var express=require("express");
var bodyParser=require('body-parser');
var jwt= require("jsonwebtoken");
var app = express();
var router=express.Router();

var authenticateController=require('./controllers/authenticate-controller');

process.env.SECRET_KEY="thisismysecretkey";

app.use(bodyParser.urlencoded({extended:true}));
app.use(bodyParser.json());

app.post('/api/authenticate',authenticateController.authenticate);

app.use('/secure-api',router);
// validation middleware
router.use(function(req,res,next){
	var token=req.body.token || req.headers['token'];
	if(token){
		jwt.verify(token,process.env.SECRET_KEY,function(err,ress){
			if(err){
				res.status(500).send('Token Invalid');
			}else{
				next();
			}
		})
	}else{
		res.send('Please send a token')
	}
})

router.get('/home',function(req,res){
	res.send('Token Verified')
})

app.listen(8012);

In above code, i use middleware to protect last API prefix with ‘secure-api’ (localhost:8012/secure-api/home).


Create Authenticate Controller to generate token

In above code, I have defined a route to handle post request from the url localhost:8012/api/authenticate and respectively I have called authenticate method which is defined into authenticate controller.

So let’s create a authenticate-controller.js, Where we validate user details and then generate a token.


controllers/authenticate-controller.js

  1. var jwt=require('jsonwebtoken');
  2. var connection =require('./../config');
  4. module.exports.authenticate=function(req,res){
  5.     var email=req.body.email;
  6.     var password=req.body.password;
  7.     connection.query('SELECT * FROM users WHERE email = ?',[email],function(error, results, fields){
  8.       if(error){
  9.           res.json({
  10.             status:false,
  11.             message:'there are some error with query'
  12.             })
  13.       }else{
  14.         if(results.length >){
  15.             if(password==results[].password){
  16.                 var token=jwt.sign(results[],process.env.SECRET_KEY,{
  17.                     expiresIn:5000
  18.                 });
  19.                 res.json({
  20.                     status:true,
  21.                     token:token
  22.                 })
  23.             }else{
  24.                 res.json({
  25.                   status:false,                  
  26.                   message:"Email and password does not match"
  27.                  });
  28.             }
  29.          
  30.         }
  31.         else{
  32.           res.json({
  33.               status:false,
  34.             message:"Email does not exits"
  35. });
  36.         }
  37.       }
  38.     });
  39. }
var jwt=require('jsonwebtoken');
var connection = require('./../config');

module.exports.authenticate=function(req,res){
	var email=req.body.email;
	var password=req.body.password;
	connection.query('SELECT * FROM users WHERE email = ?',[email], function (error, results, fields) {
	  if (error) {
		  res.json({
			status:false,
			message:'there are some error with query'
			})
	  }else{
	    if(results.length >0){
	    	if(password==results[0].password){
	    		var token=jwt.sign(results[0],process.env.SECRET_KEY,{
					expiresIn:5000
				});
				res.json({
					status:true,
					token:token
				})
	    	}else{
	    		res.json({
				  status:false,		          
		          message:"Email and password does not match"
		         });
	    	}
	     
	    }
	    else{
	      res.json({
	      	status:false,
	        message:"Email does not exits"
          });
	    }
	  }
	});
}

Now start the server by running following command :

node index.js



Test Our API to Authenticate User and Create a Token with Postman


Test Our API to Authenticate token

First, i will hit api localhost:8012/secure-api/home without sending any token to test our middleware.

Now let’s send the token with request.

Click here to know how to login and registration a user using nodejs and mysql with example

Label :

How To

Web Development

Node.js

Hope this code and post will helped you for implement Generate JWT token after login and verify with Node.js API. if you need any help or any feedback give it in comment section or you have good idea about this post you can give it comment section. Your comment will help us for help you more and improve us. we will give you this type of more interesting post in featured also so, For more interesting post and code Keep reading our blogs

For More Info See :: laravel And github

See also  Angular 10 Tutorial By Example: REST CRUD APIs & HTTP GET Requests with HttpClient
Exit mobile version