@fabrix/spool-crons/dist/Cron.js

Spool - Cron Jobs for Fabrix

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const common_1 = require("@fabrix/fabrix/dist/common");
const CronProxyHandler = {
    get(target, key, args) {
        const allowedMethods = target.methods ? target.methods : [];
        const unallowedMethods = [
            'cancel',
            'cancelNext',
            'freeze',
            'findJobByName',
            'nextInvocation',
            'reschedule',
            'unfreeze',
            ...target.unallowedMethods
        ];
        if (target.immutable === true
            && target.timeTilStart > 0
            && allowedMethods.indexOf(key) > -1
            && unallowedMethods.indexOf(key) === -1) {
            target.app.log.debug(`Cron ${target.name}.${key} start delayed by ${target.timeTilStart / 1000} seconds`);
            return function () {
                return setTimeout(function () {
                    target.app.log.debug(`Cron ${target.name}.${key} started`);
                    return target[key](args);
                }, target.timeTilStart);
            };
        }
        else {
            return target[key];
        }
    }
};
class Cron extends common_1.FabrixGeneric {
    constructor(app) {
        super(app);
        this.unallowedMethods = [];
        Object.defineProperties(this, {
            scheduler: {
                enumerable: false,
                value: app.scheduler
            },
            _uptime: {
                enumerable: false,
                value: process.uptime(),
                writable: false
            },
            _uptime_delay: {
                enumerable: false,
                value: app.config.get('crons.uptime_delay') || 0,
                writable: false
            },
            cancel: {
                enumerable: false,
                value: function (job) {
                    if (typeof job === 'string') {
                        job = this.findJobByName(job);
                        return job.cancel();
                    }
                    else {
                        return job.cancel();
                    }
                },
                writable: true
            },
            cancelNext: {
                enumerable: false,
                value: function (job, reschedule) {
                    if (typeof job === 'string') {
                        job = this.findJobByName(job);
                        return job.cancelNext(reschedule);
                    }
                    else {
                        return job.cancelNext(reschedule);
                    }
                },
                writable: true
            },
            reschedule: {
                enumerable: false,
                value: function (job, spec) {
                    if (typeof job === 'string') {
                        job = this.findJobByName(job);
                        return job.reschedule(spec);
                    }
                    else {
                        return job.reschedule(spec);
                    }
                },
                writable: true
            },
            nextInvocation: {
                enumerable: false,
                value: function (job) {
                    if (typeof job === 'string') {
                        job = this.findJobByName(job);
                        return job.nextInvocation();
                    }
                    else {
                        return job.nextInvocation();
                    }
                },
                writable: true
            },
            immutable: {
                enumerable: false,
                value: false,
                writable: true
            },
            freeze: {
                enumerable: false,
                value: function () {
                    this.immutable = true;
                },
                writable: true
            },
            unfreeze: {
                enumerable: false,
                value: function () {
                    this.immutable = false;
                },
                writable: true
            },
            findJobByName: {
                enumerable: false,
                value: function (name) {
                    return this.scheduledJobs.find(job => job.name === name);
                },
                writable: true
            }
        });
        return new Proxy(this, CronProxyHandler);
    }
    get id() {
        return this.constructor.name.replace(/(\w+)Cron/, '$1').toLowerCase();
    }
    get name() {
        return this.constructor.name;
    }
    get scheduledJobs() {
        const jobs = [];
        if (this.scheduler) {
            for (const j in this.scheduler.scheduledJobs) {
                if (this.scheduler.scheduledJobs.hasOwnProperty(j)) {
                    const job = this.scheduler.scheduledJobs[j];
                    if (job.name && job.name.includes(this.name)) {
                        jobs.push(job);
                    }
                }
            }
        }
        return jobs;
    }
    get timeTilStart() {
        return Math.max(0, (this._uptime_delay * 1000) - (this._uptime * 1000));
    }
}
exports.Cron = Cron;
//# sourceMappingURL=Cron.js.map