@squareboat/nest-queue/dist/worker.js

The queue package for your NestJS Applications

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.QueueWorker = void 0;
const metadata_1 = require("./metadata");
const service_1 = require("./service");
const jobrunner_1 = require("./jobrunner");
const nest_console_1 = require("@squareboat/nest-console");
class QueueWorker {
    constructor(options) {
        const defaultOptions = metadata_1.QueueMetadata.getDefaultOptions();
        this.options = options || {};
        this.options = Object.assign(Object.assign(Object.assign({}, defaultOptions), { schedulerInterval: 10000, queue: undefined, logger: true }), this.options);
        if (!this.options.queue) {
            const data = metadata_1.QueueMetadata.getData();
            this.options["queue"] = data.connections[this.options.connection || defaultOptions.connection].queue;
        }
    }
    static init(options) {
        return new QueueWorker(options);
    }
    poll(connection) {
        return __awaiter(this, void 0, void 0, function* () {
            const job = yield connection.pull({ queue: this.options.queue });
            return job;
        });
    }
    listen() {
        return __awaiter(this, void 0, void 0, function* () {
            this.log("info", "LOG [QueueWorker] Queue Worker Initialised");
            const connection = service_1.QueueService.getConnection(this.options.connection);
            if (connection.scheduledTask)
                this.performScheduledTask(connection);
            const runner = new jobrunner_1.JobRunner(this.options, connection);
            while (1) {
                const job = yield this.poll(connection);
                if (job) {
                    yield runner.run(job);
                }
                else {
                    yield new Promise((resolve) => setTimeout(resolve, this.options.sleep));
                }
            }
        });
    }
    performScheduledTask(connection) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!connection || !connection.scheduledTask)
                return;
            setInterval(() => __awaiter(this, void 0, void 0, function* () {
                return connection.scheduledTask
                    ? yield connection.scheduledTask(this.options)
                    : null;
            }), this.options.schedulerInterval || 10000);
        });
    }
    purge() {
        return __awaiter(this, void 0, void 0, function* () {
            const connection = service_1.QueueService.getConnection(this.options.connection);
            yield connection.purge({ queue: this.options.queue });
            return;
        });
    }
    count() {
        return __awaiter(this, void 0, void 0, function* () {
            const connection = service_1.QueueService.getConnection(this.options.connection);
            return yield connection.count({ queue: this.options.queue });
        });
    }
    log(level, msg) {
        if (!this.options.logger)
            return;
        let logger = undefined;
        switch (level) {
            case "info":
                logger = nest_console_1.Logger.info;
                break;
            case "success":
                logger = nest_console_1.Logger.success;
                break;
            case "error":
                logger = nest_console_1.Logger.error;
                break;
            case "warn":
                logger = nest_console_1.Logger.warn;
                break;
        }
        logger && logger(msg);
    }
}
exports.QueueWorker = QueueWorker;