loading...

Implementing Job Schedulers in Node.js

ganeshmani profile image GaneshMani Updated on ・4 min read

In this article, we will see what are job schedulers and how to implement the job schedulers in nodejs. Implementing Job Schedulers in Node.js

A Recent article on Nodejs,

PM2 for Node.js developers

Building P2P Video Chat Application using webRTC and Node.js

Understanding EventEmitter in Node.js With a UseCase

Ever wondered how the application server back up the files periodically without any physical interruption. This is where Cron jobs come in.

Cron Jobs schedules a job periodically to do the actions that are configured to do.

there are few use cases where cron jobs play a vital role. they are,

  • Deleting Log files - Application generates a lot of logs.clearing old logs will save lots of space in the server. it can be done using cron jobs.
  • DB Backup - Database backup saves the application from disasters. Cron job will be helpful to do that.
  • Application Logic - we can use cron jobs to do some application logic on a time basis.

How cron job works

we will write a cron job to archive the old records in the database in a production application.

Firstly, create a project and install the following dependencies,

npm init --yes
npm install express node-cron mongoose faker
  • express - web server library in nodejs
  • node-cron - cron job scheduler library in nodejs
  • mongoose - ORM for MongoDB

After that, create a file called Model.js and add the following code

const mongoose = require('mongoose');

const weatherSchema = new mongoose.Schema({
    minTemp : {
        type: Number
    },
    maxTemp : {
        type : Number
    },
    recordedDate : {
        type : Date
    },
    isArchived : {
        type : Boolean,
        default : false
    }
});

class Weather {

    static getRec(date) {
        return this.find({
            recordedDate : {
                '$lte' :new Date(date)
            }
        }).exec();
    }

    static insertBulkData(data){
        return this.insertMany(data);
    }

    static archiveData(date){
        
        return this.updateMany({
            recordedDate : {
                '$lte' :new Date(date)
            }
        },{
            $set : {
                isArchived : true
            }
        }).exec();
    }

    static getArchivedData(){
        return this.find({
            isArchived : true
        }).exec();
    }
}

weatherSchema.loadClass(Weather);

module.exports = mongoose.model('Weather',weatherSchema)

Mainly, Model.js creates a mongoose schema for a DB table which stores the weather data in the database.

After that, create a file called scheduler.js and add the code for job scheduler.

cron.schedule("* * * * * *",() => {
    console.log("Running every minute");
})

cron schedule schedules the job for time format that is mentioned.

To learn more about cron job format, there is a great site crontab-guru which explains in detail

Connect the mongoose with the Express to insert some dummy data to database.

const cron = require('node-cron');
const express = require('express');
const mongoose = require('mongoose');
const app = express();
const faker = require('faker');
const model = require('./Model');


mongoose.connect('mongodb://localhost:27017/nodescheduler').then((res) => {

    console.log('mongoose connected successfully');

    app.get("/insertdata",async (req,res) => {
        let data = [];
        for(let i=0;i < 100;i++){
            let record = {
                minTemp: faker.random.number(),
                maxTemp : faker.random.number(),
                recordedDate : faker.date.past()
            }
            data.push(record);
        }

        await model.insertBulkData(data);

        res.send("Data is inserted");
    })

    app.listen(4000,() => {
        console.log("Server is running port 4000");
    })
    

})
.catch((err) => {
    console.error(err);
})

To insert some dummy data using fakerjs. run the script with the command, and visit the URL http://localhost:4000/insertdata

node scheduler.js

it will create some bulk dummy data to test the job scheduler. Now it is time to add the job scheduler.

cron.schedule("* * * * */3 *",async() => {

    var d = new Date();
    d.setMonth(d.getMonth() - 2); //1 month ago
    
    await model.archiveData(d);

    console.log("scheduler => archived");  
})

Above cron job will run every 3 months, to mark the data as archived in the database.

Likewise, we can use cron jobs to schedule a job for our application logics.

Summary

Above all, cron jobs play a vital role in some application development use cases. it is always good to know how cron jobs work in application development.

If you want to implement job scheduler in a production level standard with minimal effort, I recommend you to check out bree

Reference : https://crontab.guru

Posted on by:

ganeshmani profile

GaneshMani

@ganeshmani

Full Stack Engineer. Currently focusing on Javascript, React, GraphQL, and Nodejs.

Discussion

pic
Editor guide