## Introduction

In this blog post, we'll be discussing a Node.js & Express.js nodemailer module that allows sending emails using different hosts, such as Gmail and Yahoo, and supports different attachment options such as HTML, Text, and PDF.

We'll go through each function in the code to be provided and explain what it does. Let's get started.


## What is Nodemailer?

Nodemailer is an easy-to-use library that allows sending email using Node.js. It provides a simple and powerful API for sending email using different transport methods, such as SMTP, Sendmail, and Amazon SES.

It supports multiple email services including Gmail, Yahoo, Outlook, and more. It offers a user-friendly interface and provides a flexible set of APIs that can be used to configure email messages.

<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-9252990233452858"
     data-ad-slot="6187628078"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

Let's dive into the code

## Importing The Nodemailer Package

This line imports the nodemailer library into your existing Node.js application, providing an effortless way to send emails using Node.js.

```bash
const nodemailer = require("nodemailer");
```

## Define the SMTP Hosts for Different Email Providers

This object stores the SMTP hosts for different email providers. The keys of the object represent the provider name, and the values represent the corresponding SMTP host.

```js
const HOSTS = {
  gmail: "smtp.gmail.com",
  yahoo: "smtp.mail.yahoo.com",
  outlook: "smtp.office365.com",
};
```


## Create A Transporter

Transporter object in nodemailer proviede reusable coponent for sending a email. 

The following function creates a transporter object that will be used to send email. It takes an object with three parameters: the SMTP host, the username, and the password. It then creates a nodemailer transporter object using the provided parameters.

```js
function createTransporter({ host, user, pass }) {
  return nodemailer.createTransport({
    host: HOSTS[host] || HOSTS.gmail, // Default is gmail
    port: 465, // Port for secure connection
    secure: true,
    auth: {
      user,
      pass,
    },
  });
}
```

<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-9252990233452858"
     data-ad-slot="6344386266"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
     
     
## Create The Mail Options

The following function creates the mail options that will be used to send the email. It takes an object with six parameters: 

- the sender email address, 
- the recipient email address, t
- the email subject, 
- the email type (text or html), 
- the email content, 
- an array of attachments.


```js
function createMailOptions({ from, to, subject, type, content, attachments }) {
  let mailOptions = {
    from,
    to,
    subject,
  };

  switch (type) {
    case "text":
      mailOptions.text = content;
      break;

    case "html":
      mailOptions.html = content;
      break;
    default:
      mailOptions.text = content;
  }

  if (attachments && attachments.length > 0) {
    mailOptions.attachments = attachments.map((attachment, index) => ({
      filename: `${attachment.filename}.${attachment.file}`,
      path: attachment.path,
      cid: `file_${index}`,
    }));
  }

  return mailOptions;
}
```

It first creates an empty mailOptions object and sets the from, to, and subject properties. Then, depending on the email type, it sets either the text or html property of the mailOptions object.

If there are any attachments, it maps through the array and creates an object for each attachment. It sets the filename, path, and cid properties of each attachment object and adds them to the mailOptions object.

Finally, it returns the mailOptions object.

<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-9252990233452858"
     data-ad-slot="1214437105"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

## Send Email

The sendMail function takes in an options object containing the email details. It first checks that all required fields are present in the input object. It then calls the createTransporter function. 

It then calls the createMailOptions function with the remaining fields to create a mail options object. Finally, it calls the transporter.sendMail() method with the mailOptions object to send the email.

If the email is sent successfully, the sendMail function logs a message containing the message ID of the sent email to the console.

```js
async function sendMail(options) {
  const { host, user, pass, from, to, subject, type, content, attachments } =
    options;

  if (!host || !user || !pass || !from || !to || !subject) {
    throw new Error("Missing required parameters");
  }

  const transporter = createTransporter({ host, user, pass });
  const mailOptions = createMailOptions({
    from,
    to,
    subject,
    type,
    content,
    attachments,
  });

  const info = await transporter.sendMail(mailOptions);

  console.log("Message sent: %s", info.messageId);
}
```

## Call The Send Email Function To Send Email In A NodeJs Application

That's all now we can call the sendMail function to send an email by providing required email informations. Let's send an email using gmail host:

```js
// Example usage:
sendMail({
  host: "gmail",
  user: "your-emaill",
  pass: "your-pass",
  from: "sender",
  to: "receiver",
  subject: "Test email",
  content: "Hello",
  attachments: [
    {
      file: "png",
      filename: "myimage",
      path: "path/to/image",
    },
  ],
});
```

Note that, using gmail host is needed a app password, which can be generated your user google account. After generating an app password you can replace it with the password field.

After sending email content and attachments, you will see the console message on you terminal.

<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-9252990233452858"
     data-ad-slot="9959831409"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

## Conclusion

Overall, this guide provides a straightforward and flexible way to send emails using Node.js with the nodemailer package, with support for different email providers, authentication, and attachment options.

Thank you for reading.





Send an email in your nodejs and expressjs application using the nodemailer package which allows sending different types of email content such as text and HTML and supporting different email providers such as Gmail, yahoo and outlook.

Send Email in Nodejs With Nodemailer

it's essential to validate user credentials when registering a new user in your system. This validation must be done on the backend side, according to the specific requirements of your application.

In this article, we will show you how to validate an email and password in nodejs with express-validator package, which provides middlewares to easily validate email and password. 

<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-9252990233452858"
     data-ad-slot="8120921533"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

## Create A Node Server With Expressjs

We'll build a straightforward server using Expressjs, featuring a route to handle registration requests from users.

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

// Parse the body
app.use(express.json());

// SignUp route
app.post("/signup", validateEmail(), validatePassword(), signup);

function validateEmail() {
  // Code here to validate email
  // It Will return a middleware
}

function validatePassword() {
  // Code here to validate password
  // It Will return middleware
}

function signup(req, res, next) {
  // Signup controller
}

const PORT = process.env.PORT || 3002;

app.listen(PORT, () => {
  console.log(`Server is running on PORT ${PORT}`);
});
```
<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-9252990233452858"
     data-ad-slot="6187628078"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
## Validate Email And Password With Express-Validator

Firstly, install the package express-validator using npm or yarn 


```bash
npm install express-validator
```

<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-9252990233452858"
     data-ad-slot="6187628078"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

### Validate Email

Next, let's create the first middleware function, **validateEmail**, which will perform the following steps:

- Check if it is an email
-  Check its characters length
- Normalize the email according to the email provider (gmail, outlook)


```js

const { body } = require("express-validator")
function validateEmail() {
// code here to validate email

  return body("email")
    .isEmail()
    .withMessage("Please Enter A Valid Email")
    .isLength({ max: 320 })
    .withMessage("Password must contain up to 320 characters")
    .normalizeEmail();
    
}
```

<ins class="adsbygoogle"
     style="display:block; text-align:center;"
     data-ad-layout="in-article"
     data-ad-format="fluid"
     data-ad-client="ca-pub-9252990233452858"
     data-ad-slot="8072638585"></ins>
### Validate Password

Validating passwords is essential as it enhances the security of the system by enforcing strong password policies and protecting user accounts from unauthorized access. Let's see what **validatePassword** function do in order.

-  Check if the password is empty
-  Check the password characters length
-  Check if the password contain at least an upper case letter
-  Check if the password contain at least an lower case letter
-  Check if the password contain at least a number
-  Check if the password contain space characters
-  Check if the password confirmation match password


```js
// not() negates the result of the next validator.
function validatePassword() {
  return body("password")
    .notEmpty()
    .withMessage("Please Enter A Valid Password")
    .isLength({ min: 6 })
    .withMessage("Password must be at least 6 characters")
    .isLength({ max: 128 })
    .withMessage("Password must contain up to 128 characters")
    .matches(/[A-Z]/g)
    .withMessage("Password must contain an upper case letter")
    .matches(/[a-z]/g)
    .withMessage("Password must contain a lower case letter")
    .matches(/[0-9]/g)
    .withMessage("Password must contain a number")
    .not()
    .matches(/\s/g)
    .withMessage("Please do not use space characters")
    .custom((value, { req }) => {
      if (value !== req.body.passwordAgain) {
        throw new Error("Password confirmation does not match password");
      }
      return true;
    });
}
```
<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-9252990233452858"
     data-ad-slot="6344386266"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
## Sign Up Controller

After performing the credentials validation, in case of any errors, we can return the error to the user by utilizing the validationResult method, as shown below.


```js
const { validationResult } = require("express-validator");

function signup(req, res, next) {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json({ errors: errors.array() });
  }
  res.send("Eveything is ok");
}
```

<ins class="adsbygoogle"
     style="display:block; text-align:center;"
     data-ad-layout="in-article"
     data-ad-format="fluid"
     data-ad-client="ca-pub-9252990233452858"
     data-ad-slot="8072638585"></ins>

## Validation Response

After all is done, here is a test scenario that show how error response looks.

![Validate email and password in nodejs using express validator package | An Error Response Example ](https://api.onjsdev.com/uploads/response_output_c33458c05e.png)

<ins class="adsbygoogle"
     style="display:block; text-align:center;"
     data-ad-layout="in-article"
     data-ad-format="fluid"
     data-ad-client="ca-pub-9252990233452858"
     data-ad-slot="9309141789"></ins>

## Conclusion

In conclusion, this article demonstrated how to use a middleware provided by the express-validator package to validate an email and password in Nodejs application to protect both users and our server.

Thank you for reading.



Example of Validating email and password in Nodejs application using the middleware provided by Express Validator package to protect users and your server

Validate Email And Password In Nodejs With Express-Validator

Redis is an in-memory store used as a database, cache, streaming engine, and message broker. It supports various data structures such as strings, hashes, lists, and sets. In this article we will integrate redis into an API built with nodejs, expressjs and postgresql to cache  the responses to the requests made.


## Integrating Redis with Node And PostgreSQL

Before you start, make sure you have redis server running your local machine. if you don't have it you can find installation guide for your operating system in the redis website.


```
npm install redis express pg
```

## Configure PostgreSQL Database

We will use the PostgreSQL database to store the data. You can use a different database or an external API to test purposes. Make sure your database server is running on your local machine.

<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-9252990233452858"
     data-ad-slot="6344386266"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
```js
const { Pool } = require('pg');
// Db Connection
const pool = new Pool({
  user: 'postgres',
  host: 'localhost',
  port: 5432,
  password: 'secret',
  database: 'myblog',
});
```

## Creating Expressjs Server


We have a simple server running on 3001 to respond to requests made for getting a post and deleting a post.


```js
const express = require('express');
const app = express();

// Codes Here

app.listen(3001, () => {
  console.log('Server Started');
});
```

## Setting API Routes

Our goal is caching responses sent before so we  have two routes for getting and deleting a post. Realize that, we add a cache middleware to route for getting post so that we will be able to cache responses.


```js
app.get('/posts/:id', cache, getPost);
app.delete('/posts/:id', delPost);
```

## Integrate Redis Into Nodejs API

You can connect to a Redis server using the **createClient** method and specify a host and port for remote server.



```js
const redis = require('redis');

const redisClient = redis.createClient({
  host: 'http://127.0.0.1',
  port: 6379,
});

redisClient.connect().catch((err) => {
  console.log(err);
});
```

## Creating Controllers

### getPost

The first controller is getPost getting the requested data from the database and storing it in the Redis store for serving the data in the next request without getting the data from the database, which will reduce the response time.

<ins class="adsbygoogle"
     style="display:block; text-align:center;"
     data-ad-layout="in-article"
     data-ad-format="fluid"
     data-ad-client="ca-pub-9252990233452858"
     data-ad-slot="2451954009"></ins>
```js
async function getPost(req, res, next) {
  try {
    const id = req.params.id;
    const result = await pool.query('SELECT * FROM posts WHERE id = $1', [id]);
    if (result.rows.length > 0) {
  
      // Store in Redis
      // Expiry time is 10 minutes

      await redisClient.setEx(
        `post:${id}`,
        60 * 10,
        JSON.stringify(result.rows[0])
      );

      res.status(200).json({
        posts: result.rows[0],
      });

    }
  } catch (error) {
    res.status(500).json({ error: 'Something Went Wrong' });
  }
}
```

### delPost

The second controller is delPost removing the data from both the database and Redis store.


```js
async function delPost(req, res, next) {
  try {
    // get id of the post from request params
    const id = req.params.id;
    // delete the data from database
    await pool.query('DELETE FROM posts WHERE id = $1', [id]);
    // delete the data from redis
    await redisClient.del(`post:${id}`);
    res.status(200).json({ msg: 'Post was deleted' });
  } catch (error) {
    res.status(500).json({ error: 'Something Went Wrong' });
  }
}
```

 ## Cache Middleware
 
 What the cache middleware does is check if the requested data is in the Redis store, send the response if it does, otherwise run the next callback to run the getPost controller.
 
 
```js
async function cache(req, res, next) {
  try {
    const id = req.params.id;
    const post = await redisClient.get(`post:${id}`);

    if (!post) {
      return next();
    }

    res.status(200).json({ post: JSON.parse(post) });

  } catch (error) {
    next(error)
  }
}
```

Results Before And After Caching With Redis

![before-cache.png](https://api.onjsdev.com/uploads/before_cache_8e3b76323b.png)
![after-cache.png](https://api.onjsdev.com/uploads/after_cache_ab9ae822fd.png)


## Conclusion

In this article, we have covered how to cache the responses to the requests in nodejs with Redis using a cache middleware to reduce the response time.

Thank you for reading

Integrate redis to your nodejs API built with expressjs and postgresql to reduce response time to the requests made in specific time range

Send Email in Nodejs With Nodemailer

Validate Email And Password In Nodejs With Express-Validator

Caching in Nodejs With Redis and Postgresql