How To Schedule Tasks At Different Intervals In Node.js?

Node-cron

Node-cron is a library for task scheduling in Node.js. It uses cron syntax to define job schedules, which is useful for developers who know Unix-style cron jobs.

Cron syntax has five or six fields for time units:

*    *    *    *    *    *
┬    ┬    ┬    ┬    ┬    ┬
│    │    │    │    │    │
│    │    │    │    │    └ day of week (0 - 7) (0 or 7 is Sun)
│    │    │    │    └───── month (1 - 12)
│    │    │    └────────── day of month (1 - 31)
│    │    └─────────────── hour (0 - 23)
│    └──────────────────── minute (0 - 59)
└───────────────────────── second (0 - 59, optional)

Examples of schedules using node-cron:

const cron = require('node-cron');

// Run every minute
cron.schedule('* * * * *', () => {
  console.log('This task runs every minute');
});

// Run every day at 2:30 PM
cron.schedule('30 14 * * *', () => {
  console.log('This task runs at 2:30 PM daily');
});

// Run every Monday at 1 AM
cron.schedule('0 1 * * 1', () => {
  console.log('This task runs every Monday at 1 AM');
});

cron.schedule('@daily', () => {
  console.log('This task runs once a day at midnight');
});

Node-schedule

Node-schedule is another library for scheduling tasks in Node.js. It offers more options than node-cron, allowing for precise date and time scheduling.

Features of node-schedule include:

• Scheduling jobs using specific dates and times
• Recurring job scheduling
• Timezone support

Example of using node-schedule:

const schedule = require('node-schedule');

// Schedule a job to run every 5 minutes
const job = schedule.scheduleJob('*/5 * * * *', function() {
  console.log('This job runs every 5 minutes');
});

// Schedule a one-time job
const date = new Date(2023, 5, 15, 12, 0, 0);
schedule.scheduleJob(date, function() {
  console.log('This job runs on June 15, 2023 at 12:00:00 PM');
});

// Schedule a recurring job (every Sunday at 2:30 PM)
const recurringJob = schedule.scheduleJob('30 14 * * 0', function() {
  console.log('This job runs every Sunday at 2:30 PM');
});

Agenda

Agenda is a job scheduling library for Node.js with database integration. It uses MongoDB to store job data, making it useful for applications that need persistent job scheduling.

Features of Agenda include:

• Database-backed job persistence
• Scheduling of jobs to run at specific dates
• Repeating job scheduling
• Priorities and concurrency control

Example of using Agenda:

const Agenda = require('agenda');

const agenda = new Agenda({db: {address: 'mongodb://127.0.0.1/agenda-example'}});

// Define a job
agenda.define('send email', (job, done) => {
  console.log('Sending email...');
  done();
});

// Schedule a job to run every 5 minutes
agenda.every('5 minutes', 'send email');

// Schedule a one-time job
agenda.schedule('in 20 minutes', 'send email');

// Start processing jobs
(async function() {
  await agenda.start();
})();

// Define jobs with different priorities
agenda.define('high-priority job', {priority: 'high'}, (job, done) => {
  console.log('This is a high priority job');
  done();
});

agenda.define('low-priority job', {priority: 'low'}, (job, done) => {
  console.log('This is a low priority job');
  done();
});

// Schedule the jobs
agenda.now('high-priority job');
agenda.now('low-priority job');

These libraries provide different ways to schedule tasks in Node.js, letting you choose the one that fits your project needs.

Setting Up the Environment

To start implementing task scheduling in Node.js, set up your project environment. Create a new directory for your project and initialize it with npm:

mkdir task-scheduler
cd task-scheduler
npm init -y

Install the dependencies. For this example, we'll use node-cron:

npm install node-cron

Create a basic project structure with a main file:

touch index.js

git init

Creating and Scheduling Tasks

Open index.js in your text editor and import node-cron:

const cron = require('node-cron');

Define your task functions. These are the operations you want to schedule:

function taskA() {
  console.log('Task A: Running every 30 seconds');
}

function taskB() {
  console.log('Task B: Running every 60 seconds');
}

function taskC() {
  console.log('Task C: Running every 7 days');
}

Schedule these tasks at different intervals:

const taskASchedule = cron.schedule('*/30 * * * * *', taskA);
const taskBSchedule = cron.schedule('*/60 * * * * *', taskB);
const taskCSchedule = cron.schedule('0 0 */7 * *', taskC);

To start and stop scheduled tasks:

// Start all tasks
taskASchedule.start();
taskBSchedule.start();
taskCSchedule.start();

// Stop a specific task
// taskASchedule.stop();

Managing Scheduled Tasks

To list active tasks, create an array of your scheduled tasks:

const scheduledTasks = [taskASchedule, taskBSchedule, taskCSchedule];

function listActiveTasks() {
  scheduledTasks.forEach((task, index) => {
    console.log(`Task ${index + 1}: ${task.running ? 'Active' : 'Inactive'}`);
  });
}

To modify existing schedules, stop the current schedule and create a new one:

function modifyTaskSchedule(taskIndex, newSchedule) {
  if (taskIndex >= 0 && taskIndex < scheduledTasks.length) {
    scheduledTasks[taskIndex].stop();
    scheduledTasks[taskIndex] = cron.schedule(newSchedule, () => {
      console.log(`Modified task ${taskIndex + 1} running`);
    });
    scheduledTasks[taskIndex].start();
  }
}

To cancel scheduled tasks:

function cancelTask(taskIndex) {
  if (taskIndex >= 0 && taskIndex < scheduledTasks.length) {
    scheduledTasks[taskIndex].stop();
    console.log(`Task ${taskIndex + 1} canceled`);
  }
}

This implementation provides a basic structure for creating, scheduling, and managing tasks in Node.js using node-cron. You can build on this foundation to create more complex task scheduling systems based on your needs.

function taskWithErrorHandling() {
  try {
    // Your task logic here
    console.log('Task executed successfully');
  } catch (error) {
    console.error('Error in scheduled task:', error);
    // Implement error reporting or recovery logic here
  }
}

const errorHandledTask = cron.schedule('*/5 * * * *', taskWithErrorHandling);