@cemusta/nestjs-pulse/dist/providers/pulse.orchestrator.js

The modern MongoDB-powered scheduling library pulse for NestJS

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.PulseOrchestrator = void 0;
const tslib_1 = require("tslib");
const common_1 = require("@nestjs/common");
const core_1 = require("@nestjs/core");
const pulse_messages_1 = require("../pulse.messages");
const enums_1 = require("../enums");
const database_service_1 = require("./database.service");
let PulseOrchestrator = class PulseOrchestrator {
    moduleRef;
    database;
    logger = new common_1.Logger('Pulse');
    queues = new Map();
    constructor(moduleRef, database) {
        this.moduleRef = moduleRef;
        this.database = database;
    }
    async onApplicationBootstrap() {
        await this.database.connect();
        for await (const queue_ of this.queues) {
            const [queueToken, registry] = queue_;
            const { config, queue } = registry;
            this.attachEventListeners(queue, registry);
            queue.mongo(this.database.getConnection(), config.collection || queueToken);
            if (config.autoStart) {
                await queue.start();
            }
            this.defineJobProcessors(queue, registry);
            await this.scheduleJobs(queue, registry);
        }
    }
    async beforeApplicationShutdown() {
        for await (const queue of this.queues) {
            const [, config] = queue;
            await config.queue.stop();
        }
        await this.database.disconnect();
    }
    addQueue(queueName, queueToken, queueConfigToken) {
        const queue = this.getQueue(queueName, queueToken);
        const config = this.getQueueConfig(queueConfigToken);
        this.queues.set(queueToken, {
            queue,
            config,
            processors: new Map(),
            listeners: new Map(),
        });
    }
    addJobProcessor(queueToken, processor, options, type, useCallback) {
        const jobName = options.name || processor._name;
        this.queues.get(queueToken)?.processors.set(jobName, {
            handler: processor,
            useCallback,
            type,
            options,
        });
    }
    addEventListener(queueToken, listener, eventName, jobName) {
        const key = jobName ? `${eventName}:${jobName}` : eventName;
        this.queues.get(queueToken)?.listeners.set(key, listener);
    }
    attachEventListeners(pulse, registry) {
        registry.listeners.forEach((listener, eventName) => {
            pulse.on(eventName, listener);
        });
    }
    defineJobProcessors(pulse, registry) {
        registry.processors.forEach((jobConfig, jobName) => {
            const { options, handler, useCallback } = jobConfig;
            if (useCallback) {
                pulse.define(jobName, (job, done = () => { }) => handler(job, done), options);
            }
            else {
                pulse.define(jobName, handler, options);
            }
        });
    }
    async scheduleJobs(pulse, registry) {
        for await (const processor of registry.processors) {
            const [jobName, jobConfig] = processor;
            const { type, options } = jobConfig;
            if (type === enums_1.JobProcessorType.EVERY) {
                await pulse.every(options.interval, jobName, {}, options);
            }
            else if (type === enums_1.JobProcessorType.SCHEDULE) {
                await pulse.schedule(options.when, jobName, {});
            }
            else if (type === enums_1.JobProcessorType.NOW) {
                await pulse.now(jobName, {});
            }
        }
    }
    getQueue(queueName, queueToken) {
        try {
            return this.moduleRef.get(queueToken, { strict: false });
        }
        catch (error) {
            this.logger.error((0, pulse_messages_1.NO_QUEUE_FOUND)(queueName));
            throw error;
        }
    }
    getQueueConfig(queueConfigToken) {
        return this.moduleRef.get(queueConfigToken, {
            strict: false,
        });
    }
};
exports.PulseOrchestrator = PulseOrchestrator;
exports.PulseOrchestrator = PulseOrchestrator = tslib_1.__decorate([
    (0, common_1.Injectable)(),
    tslib_1.__metadata("design:paramtypes", [core_1.ModuleRef, database_service_1.DatabaseService])
], PulseOrchestrator);
//# sourceMappingURL=pulse.orchestrator.js.map