Introduction
The email service is one of the services common to every software application. Emails are used to communicate pieces of information mostly about downtime, updates and verification of activities by the user in a software application.
In this tutorial, we will be demonstrating how to set up an email server in a Node.js application using Nodemailer and Mailtrap. First of all, let us learn the basics!
Nodemailer
Nodemailer is a module for Node.js applications that allows easy-as-cake email sending. The project started back in 2010 when there was no better option for sending email messages, today it is still the solution most Node.js users turn to by default. Underneath the hood, Nodemailer uses the Node.js core module net
to create a connection to the SMTP server specified in the transport object. Once a connection is established, Nodemailer uses the SMTP protocol to send email messages by sending various commands and responses over the connection.
Here's a simplified example of how Nodemailer sends an email message:
- Create a transport object that defines the SMTP server, authentication credentials, and other options.
- Create a message object that defines the email message, including the sender, recipient, subject, and body.
- Use the
transporter.sendMail()
method to send the message, passing in the message object and a callback function to handle any errors or responses. - Nodemailer uses the transport object to establish a connection to the SMTP server and send the message using the SMTP protocol. If the message is sent successfully, Nodemailer returns a response object containing information about the message, like the message ID and the response from the SMTP server.
Overall, Nodemailer provides a simple and powerful interface for sending email messages in Node.js, taking away the complexities of the SMTP protocol and allowing developers to focus on the content and delivery of their messages.
Mailtrap
Mailtrap is a service that provides a mock SMTP server for testing and development purposes. It allows developers to test their email-sending functionality without actually sending emails to real recipients. Mailtrap works by creating a temporary SMTP server that is accessible through a unique hostname and port number. When an email is sent to the Mailtrap server, it is intercepted and stored in your Mailtrap inbox instead of being sent to the intended recipient. Mailtrap also provides a web interface that allows you to view and manage your test email messages, as well as features like email forwarding and spam testing.
Here are the following steps to enable Mailtrap to work with Nodemailer:
- Sign up for a Mailtrap account and create a new inbox.
- Retrieve your SMTP credentials from the Mailtrap inbox settings.
- Configure Nodemailer to use the Mailtrap SMTP server by creating a transport object with the SMTP settings from Mailtrap.
- Use the
transporter.sendMail()
method to send email messages, just like you would with any other SMTP server. - Check your Mailtrap inbox to see the test email message. The message will be displayed in the inbox with its headers and content, allowing you to verify that it was sent correctly.
Overall, Mailtrap is a useful tool for testing and debugging email functionality in a safe and controlled environment. By using Mailtrap with Nodemailer, developers can test their email-sending functionality without the risk of accidentally sending test emails to real recipients or getting blocked by spam filters.
Setting up the Email Server
Now that we’ve had the basics out of the way, let us delve into a more interesting part: we will be setting up the email server using Node.js. The process follows this form;
Creating Mailtrap Account
Go to the Mailtrap website and sign up. When the sign up is completed, you will see a screen like the one below.
Click on Email Testing to get your secret credentials. Select Nodemailer as an integration option and you will get a screen like the one below.
-
At this point, you’d have to save the keys, it would be needed to set up the application later.
Setup Node.js Project
To set up our Node.js server, we need to create a project folder that will contain our application. For this tutorial, we will call the folder node-email-server
.
- To begin, we will run the following commands from our terminal.
cd desktop && mkdir node-email-server
cd node-email-server
code . /** this is to open the folder in our code editor (VSCode) */
- In the root folder, run the following command to install the packages we will be using
npm install nodemon nodemailer dotenv cors express mailgen
Nodemon—automatically restarts the node application when file changes in the directory are detected.
Cors—for providing an Express middleware that can be used to enable CORS with various options.
Express—Node.js web application framework that provides a robust set of features for web and mobile applications.
Mailgen—Node.js package that generates clean, responsive HTML e-mails for sending transactional mail.
- Create a
.env
file in the root folder—this is where we will store the Mailtrap keys we generated earlier.
EMAIL=<sender's email address>
USER=<mailtrap user key>
PASSWORD=<mailtrap password>
- We will proceed to create the server file, in our case, it is the
index.js
file. Add the following code to the server file
import express from 'express';
import cors from 'cors';
import dotenv from 'dotenv';
import nodemailer from 'nodemailer';
import Mailgen from 'mailgen';
dotenv.config() // configure our app to use env variables
const app = express();
/** middlewares */
app.use(express.json());
app.use(cors());
app.disable('x-powered-by'); // less hackers know about our stack
const port = process.env.PORT || 8080;
/** HTTP GET Request */
app.get('/', (req, res) => {
res.status(201).json("Health Check PASS");
});
// create reusable transporter object using the default SMTP transport
const transporter = nodemailer.createTransport({
host: 'smtp.mailtrap.io',
port: 2525,
auth: {
user: process.env.USER, // generated mailtrap user
pass: process.env.PASSWORD, // generated mailtrap password
}
});
// generate email body using Mailgen
const MailGenerator = new Mailgen({
theme: "default",
product : {
name: "Test Email",
link: 'https://mailgen.js/'
}
})
// define a route for sending emails
app.post('/send-email', (req, res) => {
// get the recipient's email address, name and message from the request body
const { to, name, message } = req.body;
// body of the email
const email = {
body : {
name: name,
intro : message || 'Welcome to Test Mail! We\'re very excited to have you on board.',
outro: 'Need help, or have questions? Just reply to this email, we\'d love to help.'
}
}
const emailBody = MailGenerator.generate(email);
// send mail with defined transport object
const mailOptions = {
from: process.env.EMAIL,
to: to,
subject: 'Test Email',
html: emailBody
};
transporter.sendMail(mailOptions, (error, info) => {
if (error) {
console.log(error);
res.status(500).send('Error sending email');
} else {
console.log('Email sent: ' + info.response);
res.send('Email sent successfully');
}
});
});
// start the server
app.listen(port, () => {
console.log(`Server started on port ${port}`);
});
Firstly, we imported the packages we will be needing and created an app instance using express
. We defined our middleware and port. The interesting parts are:
- The email transport instance was created with
nodemailer
and using the SMTP details thatmailtrap
provided us - The function
MailGenerator
which we used to generate clean, responsive HTML e-mails. - The route which houses those logics we need for sending email requests to the server whenever the
send-email
endpoint is called. - Finally, we started the server and let the app listen to the defined port which we will use to access and test our email API.
Testing our Email Server
This is my favourite part of the whole process, testing our endpoint to see if our application actually works. For this tutorial, we will be using Postman a HTTP client used to test, debug or document API. You can set up Postman as a desktop application or use it as a web app without installing it on your local machine. Check here for more details on how to set it up with any option you want.
Making a request
Our app is running on http://localhost:8080
so our endpoint is exposed to this url: http://localhost:8080/send-email
We will send a POST
request to the endpoint with three parameters in the body of the request which are: to
, the email address of the recipient of the mail, name
, the name of the recipient and message
, which is optional if we do not want to overwrite the default message in our application. Here is what our Postman request and response will look like.
If we check our Mailtrap account, we will see the mail we just sent and viola! our app works as expected. Here is what mine looks like.
Conclusion
We have learnt how to use Nodemailer and Mailtrap to set up a Node.js email server and also how these technologies work behind the scene. The code repository for this project can be found here.
Note that Nodemailer works with other SMTP providers like Gmail, Hotmail, MailGun, SendGrid, SendinBlue, etc. The list of supported services can be found here too.
If you enjoyed the article, feel free to leave a comment, give it a shout-out and share it with others. Bueno!
Top comments (7)
Thanks for this insightful article. Thanks for also introducing me to this line of code I never knew about.
app.disable(x-powered-by)
You're welcome
Nice article, chief.
Thanks 🙏. Glad you like it
Great piece 🥂
Thanks I appreciate
Please support my microblogging site noteleo.com/
thank you