DEV Community: Grayman Evans

Why do we use 0 and 1 to represent Boolean values in SQL

Grayman Evans — Thu, 24 Apr 2025 15:41:12 +0000

In SQL, Boolean values (True or False) are typically represented using 1 for True and 0 for False. Let’s look more into how this works:

Many SQL databases don’t have a native Boolean type (especially older Dbs), so they use integers to represent Boolean values:
1 = True
0 = False

Here are some reasons why

Computers use binary (0s and 1s), so it’s normal to represent Boolean values this way.
Works across databases like MySQL, SQLite, and older systems without a native BOOLEAN type.
Using TINYINT(1) in databases such as MySQL is space-efficient and offers fast evaluation performance.

Example

SELECT * FROM soul WHERE is_useful= 1;

Final Say

In SQL, 1 represents True and 0 represents False. This is a simple concept that’s rooted in binary logic, but useful for writing clear and effective SQL queries. Cheers🎯

Upload Images With Node.js And Express To The Cloud Using Cloudinary

Grayman Evans — Wed, 02 Feb 2022 04:13:32 +0000

Today's websites and mobile applications worldwide requires the functionality to upload image somewhere to the cloud for storing and easy retrieval since in most cases images must be stored somewhere in the cloud for easy management (storing, retrieval, integration etc. ) and not directly into a database. Luckily Cloudinary comes to help us get this done in a few simple steps using Node.js and Express so

WHAT IS CLOUDINARY ?

Cloudinary is a SaaS technology company that provides a cloud-based image and video management services.

WHAT IS CLOUDINARY USED FOR ?

With Cloudinary, you can easily upload images and videos to the cloud and automate smart manipulations of those media without installing any other software. Cloudinary then seamlessly delivers your media through a fast content delivery network (CDN), optimized with the industry’s best practices. It basically enables users to upload, store, manage, manipulate, and deliver images and videos for websites and applications.

Additionally, Cloudinary offers comprehensive APIs and administration capabilities, which you can easily integrate with your web and mobile applications.

In this guide you'll learn how to upload images to Cloudinary with the Node.js SDK which provides simple, yet comprehensive image and video upload, transformation, optimization, and delivery capabilities that you can implement using code that integrates seamlessly with your existing Node.js application.

To begin, you must be able to use the terminal, familiar with Node.js , Npm , Github , you must also have Cloudinary account, if you don't, sign up for free here to get your API Key and other credentials needed for the project.

After signing up, it should take you to the dashboard, which looks like this

You can find your CLOUD NAME, API and SECRET KEY on the dashboard good!! that means we are ready, you can even go to the settings page to see how you can upgrade your current plan to suit your business needs, but for now we will go with the free plan which gives us 1,000 Transformations OR 1 GB Storage OR 1 GB Bandwidth.

To begin, you should get the exercise files from my Github, follow the instructions in the README.md file to get started. Everything is arranged for you so we can start integrating the image upload functionality.

After you're done, your project structure should look like this

Start the development server with npm:

npm start

And navigate to http://localhost:8080 in your internet explorer to see the starter project

CAUTION ⚠️

If you get any error with nodemon because it's not installed on your machine you can solve it by installing it via npm :

npm install -g nodemon

Or yarn :

yarn global add nodemon

Now we can install the rest of the packages needed for the project which is Cloudinary , multer( ** Node.js middleware for handling multipart/form-data, which is primarily used for uploading files **),multer-storage-cloudinary ( A multer storage engine for Cloudinary ) and dotenv to set up the environment variables, with npm :

npm install  cloudinary multer multer-storage-cloudinary dotenv

After these are done installing, we need to configure the storage, in the top level directory ( same as index.js) create a storage directory by running this command or create it manually :

mkdir storage

This will create storage directory, open and create a file storage.js inside the storage directory,
run this command to create it :

cd storage && touch storage.js

Good! now our project structure should look like this

Open storage.js and require Cloudinary and multer-storage-cloudinary

const cloudinary = require('cloudinary').v2;
const { CloudinaryStorage } = require('multer-storage-cloudinary');

Now we can use multer-storage-cloudinary' to create the storage engine to store images in Cloudinary , firstly we need to configure Cloudinary with the cloud_name, ** api_key** and api_secret and use the configuration to create the storage engine with multer-storage-cloudinary', paste the following code below what you just required on storage.js :

cloudinary.config({
    cloud_name:process.env.CLOUD_NAME,
    api_key: process.env.CLOUDINARY_KEY,
    api_secret:process.env.CLOUDINARY_SECRET
});

const storage = new CloudinaryStorage({
    cloudinary,
    params: {
        folder: 'CloudinaryDemo',
        allowedFormats: ['jpeg', 'png', 'jpg'],
    }
});

module.exports = {
    storage
};

So the storage.js file should look like this

const cloudinary = require('cloudinary').v2;
const { CloudinaryStorage } = require('multer-storage-cloudinary');

cloudinary.config({
    cloud_name:process.env.CLOUD_NAME,
    api_key: process.env.CLOUDINARY_KEY,
    api_secret:process.env.CLOUDINARY_SECRET
});

const storage = new CloudinaryStorage({
    cloudinary,
    params: {
        folder: 'CloudinaryDemo',
        allowedFormats: ['jpeg', 'png', 'jpg'],
    }                                                              
}); 

module.exports = {
    storage
};

** NOTE** : Allowed formats can be omitted and cloudinary will deliver the image as the original image's format.

Since we are the using the environment variables to configure Cloudinary which does not exist yet in the project, we can create the file and embed the CLOUD_NAME, CLOUDINARY_KEY and CLOUDINARY_SECRET

In the same directory as index.js run :

touch .env

This will create .env file

Open and paste the following code in it :

CLOUD_NAME= your cloud name goes here 
CLOUDINARY_KEY=  your API KEY goes here 
CLOUDINARY_SECRET= your secrete goes here

Now go back to Cloudinary's dashboard to copy the details and set them in the .env file accordingly
[ see below image]

Once you are done, your .env file should copy this

Good now let's require multer and the storage we exported from storage.js so we can configure it to work with express to upload images, open index.js file and require (on the top level preferably below port):

const { storage } = require('./storage/storage');
const multer = require('multer');
const upload = multer({ storage });

If you check above, we are requiring multer and the storage configuration we exported from storage.js and passing the storage to multer to use the cloudinary storage instance. (Multer acts as a storage engine for Cloudinary).

Finally we can configure the route and pass upload to it so we can upload images, in the same index.js, paste this code (below " code goes here"):

//we used upload.single to tell "multer" to upload
// only single image 
 app.post('/upload', upload.single('image'), (req, res) => {
  console.log(req.file);
  res.send('Done');
});

NOTE: Cloudinary gives us the flexibility to specify the maximum and minimum number of images we wish to upload, here we specified single meaning to upload one image file, conversely we can pass upload.array to upload multiple images.

We need to make the environment variables available in the project so paste this on (line 1 top level) in index.js file:

require('dotenv').config();

The complete entry file ** index.js** should look like this :

require('dotenv').config();
const express = require('express');
const app = express();
const path = require('path');
const ejs = require('ejs');
const port = 8080;

const { storage } = require('./storage/storage');
const multer = require('multer');
const upload = multer({ storage });

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

app.set('view engine', 'ejs');
app.set('views', path.join(__dirname, './views'));

app.get('', (req, res) => {
  res.render("home");
});

// code goes here
 app.post('/upload', upload.single('image'), (req, res) => {
  console.log(req.file);
  res.send('Done');
});

app.listen(port, () => {
  console.log(`Server is listening on port ${port}`);
});

In order to upload images, open home.ejs file, specify the form action to /upload and method to POST additionally set the form encoding data type attribute to accept multipart/form-data so we can upload images and files through the form.

 <form action="/upload" method="POST" enctype="multipart/form-data">
              <div class="mb-3">
                    <div class="form-file custom-file">
                        <input class="form-control" type="file" id="formFile" name="image" multiple>
                        <label class="form-file-label" for="image"
                        </label>
                    </div>
           </div>
     <button type="submit" class="btn btn-success">Upload</button>
</form>

The action attribute specifies where to send the form-data when a form is submitted. We specified in the post route to /upload and that is where the form will be submitted to.

The enctype attribute specifies how the form-data should be encoded when submitting it to the server. It can be used only if method="POST"
And the method specifies the HTTP verb we are using in this case POST.

Now with all this in place, we can we can start the server if not already started and navigate to http://localhost:8080 in your internet explorer, upload image through the form within the specified formats eg. jpeg, jpg, png.

If everything goes well , you should get something like this

Indicating that the image was uploaded successfully, and when you go to Cloudinary's dashboard, Media library you can see Cloudinary made a new folder for us as specified in the storage configuration CloudinaryDemo and stored the uploaded image in that folder.

And in the terminal since we logged req.file to the console, we can see what cloudinary gives us in return to the image upload.

{
  fieldname: 'image',
  originalname: 'download.png',
  encoding: '7bit',
  mimetype: 'image/png',
  path: 'https://res.cloudinary.com/evans646/image/upload/v1643114879/CloudinaryDemo/n496jz94zhwcte8kskhh.png',
  size: 5761,
  filename: 'CloudinaryDemo/n496jz94zhwcte8kskhh'
}

The path is the url of the image that we can use in our projects and or web applications. When you click on it (command+ left click) on mac or copy the path and paste it in your browser and you can see the same image that we uploaded to Cloudinary .

Summary

You have learned how to upload images with node.js and express to Cloudinary with the Node.js SDK which provides simple image and video upload, transformation, optimization, and delivery capabilities that you can implement using code that integrates seamlessly with your appliaction.

Cloudinary enables users to upload, store, manage, manipulate, and deliver images and videos for websites and applications. You can check out the documentation here

If you run into any issue, you can always comment here or connect with me on Linkedin Instagram Twitter

Congratulations

Thanks a lot for coming through and Good luck! to you as well.

Send Emails with NodeJs + Express Using SendGrid

Grayman Evans — Wed, 12 Jan 2022 23:23:17 +0000

In almost every web application, there is a need to add the functionality to send transactional emails in response to various event triggers like account registration, resetting of user passwords, invoices, purchase receipts and verification of users. We can accomplish these tasks through email service platforms such as SendGrid , Mailgun and Nodemailer which takes care of sending emails on our behalf.

What is SendGrid ?

SendGrid is a cloud-based SMTP provider that allows you to send email without having to maintain email servers. It provides two ways to send email:

Through SMTP relay
Through Web API.

Why SendGrid ?

There are a variety of email as a service platforms and APIs, such as SendGrid and Mailgun among others which allows you to send up to 100 emails per month for free. SendGrid is much more user friendly than other services. So in this article, I’ll demonstrate sending emails from within a NodeJs application using SendGrid Web API.

The ability to send emails from a NodeJs server is a very important thing to do in today's web applications since these emails are crucial for notifying users of important updates and enabling key user workflows in your application.

Send Emails

To start sending emails with SendGrid, the first step is to sign up for the service. Then you’ll need to create a SendGrid API key for sending email. Sign up here

After creating an account we need to set up a sender id which is the email address that sendGrid is going to use to send emails on our behalf.

Set up the sender id by navigating to => Marketing => *senders *=> *create new sender *(Use the name that the user will see when they get the verification/notification email, so something like customer service or the name of your app).

For example, if a user signs up on www.deff.com, we can set the sender’s id to be something like support@deff.com to deliver the email to the client.

create new sender

Fill up the form and once you are done hit save. The email address you used to set up the id needs to be verified so check your inbox and you should see the verification email, verify the sender's email to be able to start sending emails.

Once you are done verifying.We need to create an API Key that will allow our backend to send emails.

Create an API key by navigating to SendGrid’s dashboard, Email api **=> **integration guide => web api =>nodejs. Give the key a name, then click “Create Key”. This will generate an api key for us which looks like this

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

Copy the key and keep it safe for later use (see images guide below).

Choose NodeJs

Next give the key a name and click Create Key this will generate the API Key.

Now scroll down and check (** I've integrated the code above**) and hit next.

Great!! we are done setting up the email service, let's initialize a new project with git so we can integrate the functionalities, change directory to where you want to save your project and run this command:

git init

Follow the prompts, afterwards, we can install express, dotenv to set up the environment variables and SendGrid JavaScript client with npm:

npm install --save @sendgrid/mail express dotenv

After these are done installing, we need to create a new index.js file to serve as the main file and paste the following code in it :

run this code :

touch index.js

This will create index.js file in the directory

Now open and paste this code in it :

const express = require ('express');
const app = express();
const port= 3000;





app.listen(port, () =>{
    console.log(`Server is listening on port ${port}`);
});

To make sure everything is good, we can run the development server with :

node index.js

If everything went well, you should see

Server is listening on port 3000

Logged to the console, GREAT!!! now we can begin integrating the send email workflow. In the same directory as index.js file create a utils directory either manually or run this command:

mkdir utils

This will create a new utils directory for us, let's create a new file sendEmail.js inside the utils
directory :

Run this code or create it manually in the utils directory

cd utils && touch sendEmail.js

Good! we need to require sendGrid in sendEmail.js :

const sendgrid = require ('@sendgrid/mail');

And configure it to send emails (add this code just below the import) :

sendgrid.setApiKey(process.env.SENDGRID_API_KEY);

 const sendEmail = ({ to, from, subject, text, html }) => {
    const msg = { to, from, subject, text, html };
    return sendgrid.send(msg);
};

module.exports = sendEmail;

The sendEmail.js file should look like this :

const sendgrid = require ('@sendgrid/mail');


sendgrid.setApiKey(process.env.SENDGRID_API_KEY);

 const sendEmail = ({ to, from, subject, text, html }) => {
    const msg = { to, from, subject, text, html };
    return sendgrid.send(msg);
};

module.exports = sendEmail;

Now this is where the sendGrid API Key we created comes to play, if you check the above code, you can see that we are setting the api key from the environment variables, but it does not exist in our project yet so let's create a new .env file to embed the SENDGRID_API_KEY, in the top level directory (same as index.js) run:

touch .env

Open the .env file and add the api key :

SENDGRID_API_KEY=your api key goes here

Great, we are done setting up the sendGrid email client but lastly we need to make the sendEmail.js file pay attention to the environment variable so let's configure it by adding this code above in sendEmail.js file (line 1):

require('dotenv').config();

Now let's open index.js file and require the sendEmail function we exported so we can configure it to work with express :

const sendEmail = require ('./utils/sendEmail');

And add this code below :

app.post('/api/test-email', async(req, res)=>{
    try {
        await sendEmail({
            //the client email 
            to: 'address you intend sending email to’(Try with any of your emails)',
            //sendGrid sender id 
            from: 'your real email goes here (the one you signed up with)',
            subject: 'Does this work?',
            text: 'Glad you are here .. yes you!',
            html:'<strong>It is working!!</strong>'
        });
        res.sendStatus(200);
    } catch (e) {
        console.log(e);
        res.sendStatus(500);
    }
});

So the complete index.js file should look like this :

const express = require ('express');
const app = express();
const port= 3000;
const sendEmail = require ('./utils/sendEmail');

//don't forget to set ( to and from email)

app.post('/api/test-email', async(req, res)=>{
    try {
        await sendEmail({
            //the client email 
            to: 'address you intend sending email to’(Try with any of your emails)',
            //sendGrid sender id 
            from: 'your real email goes here (the one you signed up with)',
            subject: 'Does this work?',
            text: 'Glad you are here .. yes you!',
            html:'<strong>It is working!!</strong>'
        });
        res.sendStatus(200);
    } catch (e) {
        console.log(e);
        res.sendStatus(500);
    }
});

app.listen(port, () =>{
    console.log(`Server is listening on port ${port}`);
});

this is how i set up my emails, you can follow the same pattern

 to: 'evansansongg+test@gmail.com',

 from: 'evansansongg@gmail.com',

Congrats ** for making it up to this point, we can now test our route with postman.
start the development server and send a POST request to ** localhost:3000/api/test-email
:

node index

Now open postman and send the request and if everything went smooth you should get ok response.

And when you check your inbox, we can see the email has been delivered successfully (if not in your inbox you can check your spam messages and mark it as not spam and every subsequent email will be delivered to your inbox)

CONGRATULATIONS 🎉🔥

Conclusion

In this article, you’ve learned how to use a transactional email service (in this case, SendGrid) to send email from within NodeJs application, hopefully this helps someone out there!!!

If you run into any problem , you can get the complete code here, comment below or get in touch with me on my Linkedin Instagram Twitter Good luck!

UDERSTANDING JWT -JSONWEBTOKEN

Grayman Evans — Thu, 23 Dec 2021 22:10:48 +0000

In token-based authentication, we store the user’s state on the client. JSON Web Token (JWT) is an open standard (RFC 7519) that defines a way of securely transmitting information between a client and a server as a JSON object. In this blog, I will use tokens and JWT terms to demonstrate how the transmission between the client and the server actually works.

ANATOMY OF JWT

The anatomy of a JWT contains three forms that is the Header , Payload and the Signature . The headers tells the signing algorithm of the token, payload is the data that the JWT contains which can be the users profile and other information and the signature part verifies the authenticity of the parts. The pieces of data are referred to us claims.

Example of JWT

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

The above example uses the Base64 URL-encoded JSON object. It contains information describing the type of token and the signing algorithm used, such as HMAC, SHA256, or RSA.

Example

{
   "alg": “RSA”,
   "typ": "JWT"
}

The JWT Payload contains claims that are pieces of information asserted about a subject. The claims will contain the statements about the user and any other additional information. The claims in a JWT are encoded as a JSON object that is used as the payload of a JSON Web Signature. Claims will either be registered, public or private.

Example

{
   “Username”: “Jackman”,
   “Email”: "Jackman@example.com”,
   "admin": true
}

Creating the JWT signature involves taking the encoded header, payload, the signing using the signing algorithm specified and a secret key.

Example

HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(payload), secret)

The above will create a JWT token using the HMAC SHA256 algorithm. This is the signature to verify that the token has not been modified when the secret key is applied on the back-end. Meaning anyone who have the token can see the data of the token unless encrypted but they cannot modify the data in the token unless they have the secrete key which should not be possible since the server is the only thing that have access to the secrete key.

HOW JWT IS USED

The user logs in ( they send their credentials to the server and the server will check if it's correct and logs in)
Upon the request, the server verifies the credentials and generates a JWT token containing the user information and sends it back to the client (front-end)
The front-end then stores the JWT (usually in cookies, sessions or local storage) and includes this JWT whenever it needs privilege access to.
The server then uses the JWT to verify the validity of the token that the client sent is legit and has not been modified.

But before the front-end send a JWT to the server ,it will look like this in the request header {authentication:'Bearer ’}

SIGNING VRS ENCYPTING TOKENS

Signing proves that the data in the JWT has not been modified, where as encrypting is like preventing the data in the JWT from being seen by third parties. JWT are not encrypted by default.

ADVANTAGES OF JWT (Token-based authentication)

Token based authentication is stateless (all the information is inside the token itself)
They also uses JSON(JavaScript object notation) which is compact and secure compared to others like xml.
The data is stored in the JWT, meaning it can contain any type of data giving the flexibility on what information is to be included in the token.
And Tokens remain valid until they expire or until the data has been modified.
Logout is also simple by destroying the token in the browser without server interaction.

NOTE:The user will have to re-authenticate the tokens when they expire so they have to login every two days or something depending on the expiration date set on the token.

LIMITATIONS

Storing a lot of data in the token makes it huge, which slows the requests.
Token in the client-side might be hijacked by an attacker making it vulnerable to Cross-site scripting (XSS) attacks which often occurs when an outside entity can execute code within your domain by embedding malicious JavaScript on the page to read and compromise the contents of the browser storage.

DEMO

To carry on with this Demo, you must have NodeJs, MongoDB installed on your system, you can install the latest MongoDB version here, latest NodeJs version here,you must also know how to use basic terminal commands and have postman account, you can sign up here.

We will build a simple RESTful API to use JWT to understand how all this works. To begin you need to get the starter template on my GitHub here. Follow the instructions in the README.md to get the server up and running and come back to this demo.

There are a few packages we will need to install :

Bcrypt to encrypt the user password.
dotenv to configure the environment variables and,
Jsonwebtokens

So open the project and install the packages we will need , in the project directory (outside the src directory) run this command :

npm install  bcrypt  dotenv jsonwebtoken

After these are installed , we will have to configure the signup route to be able to sign up users and get the user information:

src -> routes/ :

touch signUpRoute.js

Good! now let’s import the packages and add the following code to the signUpRoute.js file :

import bcrypt from 'bcrypt';
import jwt from 'jsonwebtoken';
import { getDbConnection } from '../db';


export const signUpRoute = {
    path: '/api/signup',
    method: 'post',
    handler: async (req, res) => {
        const { email, password } = req.body;
        // this is the name of the database 
       //which  will be created by default 
        const db = getDbConnection('jwt-demo-db');
        // checking to see if the user already exists in the db
        const user = await db.collection('users').findOne({ email });
        if (user) {
            res.sendStatus(409);
        };
      //if no user exist in the database with such credentials, 
      //we hash the password and save the user to the db 
        const passwordHash = await bcrypt.hash(password, 10);
        const personalInfo= {
            hairColor: 'brown',
            favoriteFood: 'rice ',
            bio: 'I am the father of all',
        };
        const result = await db.collection('users').insertOne({
            email,
            passwordHash,
            info: personalInfo,
            isAdmin: false,
        });
        const { insertedId } = result;
 // code here 
    }
};

With this in place, we can now generate json web token for the information that will be send back to the client so they can store and use it. We need to configure the JWT environment variable, so in the top level folder outside the src folder , run this command :

touch .env

This will create a new file for us so we can insert out secret key:

JWT_SECRET=thywillbedone

NOTE : you can change the secrete key to your own

Now we can generate json web token by adding this code just below the inserted id on the signUpRoute.js :

  jwt.sign({
            id: insertedId,
            email,
            info: personalInfo,
            isAdmin: false,
        },
        process.env.JWT_SECRET,
        {
            expiresIn: '2d',
        },
        (err, token) => {
            if (err) {
                return res.status(500).send(err);
            }
            res.status(200).json({ token });
        });

Making the complete signUpRoute.js file look like this :

import bcrypt from "bcrypt";
import jwt from "jsonwebtoken";
import { getDbConnection } from "../db";

export const signUpRoute = {
  path: "/api/signup",
  method: "post",
  handler: async (req, res) => {
    const { email, password } = req.body;
    // this is the name of the database which  
    // will be created by default
    const db = getDbConnection("jwt-demo-db");
    // checking to see if the user already exists
    const user = await db.collection("users").findOne({ email });
    if (user) {
      res.sendStatus(409);
    }
    //if no user exist in the database with such credentials,
    //we hash the password and save the user to the db
    const passwordHash = await bcrypt.hash(password, 10);
    const personalInfo = {
      hairColor: "brown",
      favoriteFood: "rice ",
      bio: "I am the father of all",
    };
    const result = await db.collection("users").insertOne({
      email,
      passwordHash,
      info: personalInfo,
      isVerified: false,
    });
    const { insertedId } = result;

    jwt.sign(
      {
        id: insertedId,
        email,
        info: personalInfo,
        isAdmin: false,
      },
      process.env.JWT_SECRET,
      {
        expiresIn: "2d",
      },
      (err, token) => {
        if (err) {
          return res.status(500).send(err);
        }
        res.status(200).json({ token });
      }
    );
  },
};

Great!!!, but we need to add the route to the index file to be able to make it work :

src -> routes -> index.js and add :

import { signUpRoute } from './signUpRoute';

Now add signUpRoute to the routes array :

import { testRoute } from './testRoute';
import { signUpRoute } from './signUpRoute';

export const routes = [
    testRoute,
    signUpRoute,
];

Don't worry too much about the structures of the routes unless you are curious 👀 It is also another efficient way of structuring our app

Now we can start our server and test our route with postman by sending a POST request to :

http://localhost:8080/api/signup

Firstly we need to make the server pay attention to the environment variable so let's add ( -r dotenv/config) by editting the package.json file scripts section to this:

  "scripts": {
    "start": "nodemon --exec babel-node -r dotenv/config ./src/server.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  },

So the package.json file should also look like this :

{
  "name": "back-end",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "start": "nodemon --exec babel-node -r dotenv/config ./src/server.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "@babel/core": "7.13.10",
    "@babel/node": "7.13.12",
    "@babel/preset-env": "7.13.12",
    "bcrypt": "^5.0.1",
    "dotenv": "^10.0.0",
    "express": "4.17.1",
    "jsonwebtoken": "^8.5.1",
    "mongodb": "3.6.5",
    "uuid": "^8.3.2"
  },
  "devDependencies": {
    "nodemon": "2.0.7"
  }
}

Now start the server and set the accept parameters in postman to be: raw - json

The data we are expecting will look like this, so add this credentials to the form data:

{
    "email":"someone@gmail.com",
    "password":"noonecanstopit323"
}

If configuration was successful and you click send, you should get a response like this :

{
"token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjYwZGNkMzI4MzQwMzQ3NzcxZWVhNmUxMyIsImVtYWlsIjoiZG90QGdtYWlsLmNvbSIsImluZm8iOnsiaGFpckNvbG9yIjoiIiwiZmF2b3JpdGVGb29kIjoiIiwiYmlvIjoiIn0sImlzVmVyaWZpZWQiOmZhbHNlLCJpYXQiOjE2MjUwODQ3MTMsImV4cCI6MTYyNTI1NzUxM30.Hadj4ReKFOj46-H7ua7a6yPAhvE8eenLQ9KNwgzfOcE"
}

What we get back is the token which contains all the data for the new user.

To verify this we can use the jwt.io website to parse the JWT token information. You can use jwt.io to experiment with JSON Web Tokens by decoding and encoding them.

So copy the token and paste it in the box and you should see the token decoded!! containing the exact information we signed with jwt.

This is how the information will be stored on the client side when the user signs in so they can access it and use it however.

We can even verify from the mongo shell that the newly created user was saved to the database.

SUMMARY

Authentication tokens and 2FA play a key role in establishing zero-trust network access control. For example a server could generate a token that has the claim "logged in as administrator" and provide that to a client. The client could then use that token to prove that it is logged in as admin.

Thanks a lot for coming through! I wish you a merry Christmas and a happy new year in advance! Happy coding.