peanar/dist/registry.js

A job queue for Node.js based on RabbitMQ

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const exceptions_1 = require("./exceptions");
class Registry {
    _jobs = new Map();
    _workerQueues = new Set();
    _queues = new Map();
    _exchanges = new Map();
    _bindings = new Set();
    _prepareJobDefinition(def) {
        return {
            routingKey: def.queue,
            exchange: '',
            ...def,
            name: def.name && def.name.length ? def.name : def.handler.name
        };
    }
    registerQueue(queue, args, worker = false) {
        this._queues.set(queue, {
            name: queue,
            arguments: args,
            auto_delete: false,
            durable: true,
            exclusive: false
        });
        if (worker) {
            this._workerQueues.add(queue);
        }
    }
    registerExchange(exchange, type = 'direct') {
        if (!this._exchanges.has(exchange))
            this._exchanges.set(exchange, {
                name: exchange,
                type,
                durable: true
            });
    }
    registerBinding(exchange, routingKey, queue) {
        this._bindings.add(`${exchange}:${routingKey}:${queue}`);
    }
    extractAmqStructure(def) {
        const main_queue_args = {};
        if (def.retry_exchange && def.retry_exchange.length > 0) {
            this.registerExchange(def.retry_exchange, 'topic');
            main_queue_args.deadLetterExchange = def.retry_exchange;
            main_queue_args.deadLetterRoutingKey = '#';
        }
        if (def.max_priority) {
            main_queue_args.maxPriority = def.max_priority;
        }
        this.registerQueue(def.queue, main_queue_args, true);
        this.registerExchange(`${def.queue}.retry-requeue`, 'topic');
        this.registerBinding(`${def.queue}.retry-requeue`, '#', def.queue);
        if (Number(def.delayed_run_wait) > 0) {
            this.registerQueue(`${def.queue}.delayed`, {
                messageTtl: def.delayed_run_wait,
                deadLetterExchange: `${def.queue}.retry-requeue`,
                deadLetterRoutingKey: '#'
            }, true);
        }
        if (def.exchange && def.exchange.length > 0) {
            this.registerExchange(def.exchange);
            this.registerBinding(def.exchange, def.routingKey, def.queue);
        }
        if (def.error_exchange && def.error_exchange.length > 0) {
            this.registerExchange(def.error_exchange, 'topic');
            this.registerQueue(`${def.queue}.error`, {}, false);
            this.registerBinding(def.error_exchange, '#', `${def.queue}.error`);
        }
    }
    registerJob(def) {
        const job_def = this._prepareJobDefinition(def);
        if (!job_def.name || job_def.name.length < 1)
            throw new exceptions_1.PeanarInternalError('Invalid job name.');
        this._jobs.set(job_def.name, job_def);
        this.extractAmqStructure(job_def);
        return job_def;
    }
    get workerQueues() {
        return this._workerQueues;
    }
    get queues() {
        return Array.from(this._queues.values());
    }
    get exchanges() {
        return Array.from(this._exchanges.values());
    }
    get bindings() {
        return [...this._bindings.values()].map(b => {
            const [exchange, routing_key, queue] = b.split(':');
            return {
                exchange,
                routing_key,
                queue
            };
        });
    }
    getJobDefinition(name) {
        const def = this._jobs.get(name);
        if (!def) {
            throw new exceptions_1.PeanarInternalError(`Job definition for ${name} not found.`);
        }
        return def;
    }
}
exports.default = Registry;