Job Scheduling Using node-cron.
Published: 2023-08-29 17:42:01


## Introduction.
In the fast-paced landscape of modern software development, automation has become a cornerstone of efficiency and productivity. Repetitive tasks, whether they involve data processing, system maintenance, or regular updates, can quickly consume valuable time and resources. Enter node-cron, a versatile and robust library that empowers developers to streamline their workflows by automating these recurring tasks within Node.js applications.
In this article, we delve into the world of task scheduling and automation using node-cron. We will uncover the inner workings of the library, explore its key features, and demonstrate how it can be seamlessly integrated into various projects to save time, reduce human error, and ensure timely execution of important processes. Whether you are a seasoned Node.js developer or just stepping into the realm of task automation, this article will provide you with the insights and knowledge needed to harness the power of node-cron effectively.

## What you will learn in this article.
Upon concluding this article, you will have acquired the capability to:

- Understand the cron syntax.

- Schedule jobs using node-cron.

## Prerequisites
Prior to moving forward, ensure that you have fulfilled the outlined prerequisites:

- It is essential to have the Node.js JavaScript runtime environment installed on your system.

- You should have at least a basic understanding of JavaScript and Node.

## How to Use node-cron to Schedule a Job
[node-cron](https://www.npmjs.com/package/node-cron) was developed for Node.js and is distributed through npm. Following its installation using the command npm i node-cron, it needs to be imported into the project just like any other Node.js package:

```
const nodeCron = require("node-cron");

```
For task scheduling, it's necessary to call the nodeCron.schedule function with two parameters. Additionally, a third optional argument can be provided to the function for extra configuration, if needed.
Presented below is the function signature of the nodeCron.schedule method:

```
nodeCron.schedule(expression, function, options);

```

Below is a code snippet exemplifying how the schedule method can be invoked.




```
const job = nodeCron.schedule("* * * * * *", function jobToExecute() {
  // Perform desired tasks here.
  console.log(new Date().toLocaleString());
});

```

## Deciphering Cron Expressions: A Guide

Decoding Cron Expressions: Unraveling the Puzzle

The cron expression, positioned as the initial argument for scheduling, adopts the format "* * * * * ". This string is used to define the execution time for the job. The expression comprises individual fields, each represented by an asterisk (), as illustrated below.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/8agx088dgvvw1iovlyxl.png)


Cron expressions offer multiple methodologies for populating their constituent fields. Within a Node expression, each field can be filled using solitary integer values, a defined range of values, a series of values separated by commas, incremental step values, or even through the utilization of names.

## Utilizing Individual Integer Values for Cron Expression Configuration

In this scenario, you can replace each asterisk in the expression with a solitary integer value that falls within the permissible range of values.

For instance, by inputting "20 10 * * * ", node-cron will execute your designated task at the twentieth second of the tenth minute during every hour. In cases where a value isn't provided for the hour field, node-cron interprets the asterisk () to denote every hour. This principle holds true for the day of the month field and subsequent fields as well.

```
const job = nodeCron.schedule("20 10 * * * *", () => {
  console.log(new Date().toLocaleString());
});
```

## Applying Value Ranges to Populate Cron Expressions.
Number ranges can also be employed to populate your cron expressions. A range involves two numbers separated by the hyphen (-) character, with both end values being encompassed within the range.

```
const job = nodeCron.schedule("* 1-2 8 * *", () => {
  console.log(new Date().toLocaleString());
});

```
In the provided code snippet, the optional second field has been omitted. Consequently, the job will be executed every minute between 1 am and 2 am on the eighth day of each month, as indicated by the value assigned to the day of the month field (which is 8).

## Utilizing Multiple Values for Cron Expression Configuration.
Another approach involves passing multiple values, either separated by commas or as a range separated by commas.




As an illustration, setting the value of the minute field to "10, 30, 40" will result in the execution of your job at minutes 10, 30, and 40.

```
const job = nodeCron.schedule("10,30,40 * * * *", () => {
  console.log(new Date().toLocaleString());
});
```

## Employing Names for Configuring Cron Expressions.
In the month and day of the week fields, it is possible to employ names, both in their abbreviated or full forms. For instance, "September" or "Sep" can be used.

```
const job = nodeCron.schedule("* * * May,December Thursday", () => {
  console.log(new Date().toLocaleString());
});
```
A convenient tool known as [crontab guru](https://crontab.guru/) is available, designed to decipher crontab expressions. Upon entering an expression, the tool validates it and provides information about the execution time of the job. This tool proves valuable when uncertainty exists regarding the expression's correctness.


## How to Schedule a Job using node-cron
In this segment, you will put into action the concepts you've grasped from the preceding sections. You'll construct a basic application that sends an email.

Installing dependencies:

```
npm i node-cron
npm i node-mailer
```

Configuring node-mailer with Gmail necessitates the creation of an app password to permit third-party access. Follow the outlined steps to establish your Gmail app password:

1. Open your Gmail Account.
2. Click on the profile image situated on the right.
3. Navigate to "Manage your Google Account" and then select "Security."
4. Under the "Signing in to Google" section, opt for the "App password" feature.
5. If the "App password" option isn't available, set up 2-Step Verification for your account.
6. Choose the app (in this case, "mail") and the specific device for which you wish to generate the app password.
7. Click "Generate."
8. Copy the 16-character code generated from the yellow bar on your device.
 
To create your email scheduling application, insert the provided code into the "index.js" file:

```
const cron = require("node-cron");
const nodemailer = require("nodemailer");
const express = require("express");

const app = express();

// Schedule email sending after 2 minutes
cron.schedule("2 * * * *", function () {
  sendScheduledEmail();
});

function sendScheduledEmail() {
  const mailTransporter = nodemailer.createTransport({
    service: "gmail",
    auth: {
      user: "your-email@gmail.com",
      pass: "your-app-password",
    },
  });

  const mailDetails = {
    from: "your-email@gmail.com",
    to: "user-email@gmail.com",
    subject: "Scheduled Email from My App",
    text: "This is a scheduled email sent from my Node.js app.",
  };

  mailTransporter.sendMail(mailDetails, function (err, data) {
    if (err) {
      console.log("An error occurred:", err.message);
    } else {
      console.log("---------------------");
      console.log("Email sent successfully");
    }
  });
}

app.listen(3000, () => {
  console.log("Application is now running...");
});

```

## Conclussion.
In conclusion, node-cron emerges as a vital tool in the arsenal of any Node.js developer seeking to streamline task automation and enhance overall productivity. With its intuitive syntax and flexible scheduling capabilities, the library empowers developers to effortlessly orchestrate the execution of recurring tasks, ranging from routine data processing to complex system maintenance.

Throughout this journey, we've explored the intricacies of node-cron, diving into its various aspects such as configuring cron expressions, utilizing different value types, and integrating third-party services like nodemailer for advanced functionality. By comprehending the syntax and various techniques, you are now equipped to wield the power of task automation, ultimately freeing up time and resources for more creative and strategic endeavors.

As you venture forth, keep in mind that node-cron is not only a tool but a gateway to efficiency. Experiment with its diverse features, adapt them to your project's needs, and continue to explore the vast landscape of possibilities it offers. From sending timely emails to performing intricate data manipulations, the possibilities are limited only by your imagination. So, embrace the automation revolution, harness the capabilities of node-cron, and unlock new dimensions of productivity in your Node.js applications.