redis-smq/dist/cjs/src/message/producible-message.js

A high-performance, reliable, and scalable message queue for Node.js.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ProducibleMessage = void 0;
const cron_parser_1 = require("cron-parser");
const _parse_exchange_params_js_1 = require("../exchange/_/_parse-exchange-params.js");
const index_js_1 = require("../exchange/index.js");
const _parse_queue_params_js_1 = require("../queue-manager/_/_parse-queue-params.js");
const index_js_2 = require("../errors/index.js");
class ProducibleMessage {
    constructor() {
        this.ttl = 0;
        this.retryThreshold = 3;
        this.retryDelay = 60000;
        this.consumeTimeout = 0;
        this.body = null;
        this.priority = null;
        this.scheduledCron = null;
        this.scheduledDelay = null;
        this.scheduledRepeatPeriod = null;
        this.scheduledRepeat = 0;
        this.exchange = null;
        this.exchangeRoutingKey = null;
        this.queue = null;
        this.createdAt = Date.now();
        const { consumeTimeout, retryDelay, ttl, retryThreshold } = ProducibleMessage.defaultConsumeOptions;
        this.setConsumeTimeout(consumeTimeout);
        this.setRetryDelay(retryDelay);
        this.setTTL(ttl);
        this.setRetryThreshold(retryThreshold);
    }
    static validateRetryDelay(delay) {
        const value = Number(delay);
        if (isNaN(value) || value < 0) {
            throw new index_js_2.MessagePropertyInvalidValueError({
                metadata: { property: 'retryDelay', value },
            });
        }
        return value;
    }
    static validateTTL(ttl) {
        const value = Number(ttl);
        if (isNaN(value) || value < 0) {
            throw new index_js_2.MessagePropertyInvalidValueError({
                metadata: { property: 'ttl', value },
            });
        }
        return value;
    }
    static validateConsumeTimeout(timeout) {
        const value = Number(timeout);
        if (isNaN(value) || value < 0) {
            throw new index_js_2.MessagePropertyInvalidValueError({
                metadata: { property: 'consumeTimeout', value },
            });
        }
        return value;
    }
    static validateRetryThreshold(threshold) {
        const value = Number(threshold);
        if (isNaN(value) || value < 0) {
            throw new index_js_2.MessagePropertyInvalidValueError({
                metadata: { property: 'retryThreshold', value },
            });
        }
        return value;
    }
    setExchange(exchange, type) {
        const exchangeParams = (0, _parse_exchange_params_js_1._parseExchangeParams)(exchange, type);
        if (exchangeParams instanceof Error)
            throw exchangeParams;
        this.exchange = exchangeParams;
        this.queue = null;
        this.exchangeRoutingKey = null;
        return this;
    }
    static setDefaultConsumeOptions(consumeOptions) {
        const { ttl = null, retryThreshold = null, retryDelay = null, consumeTimeout = null, } = consumeOptions;
        if (ttl !== null)
            ProducibleMessage.defaultConsumeOptions.ttl =
                ProducibleMessage.validateTTL(ttl);
        if (retryDelay !== null)
            ProducibleMessage.defaultConsumeOptions.retryDelay =
                ProducibleMessage.validateRetryDelay(retryDelay);
        if (retryThreshold !== null)
            ProducibleMessage.defaultConsumeOptions.retryThreshold =
                ProducibleMessage.validateRetryThreshold(retryThreshold);
        if (consumeTimeout !== null)
            ProducibleMessage.defaultConsumeOptions.consumeTimeout =
                ProducibleMessage.validateConsumeTimeout(consumeTimeout);
    }
    getCreatedAt() {
        return this.createdAt;
    }
    setScheduledRepeatPeriod(period) {
        const value = Number(period);
        if (isNaN(value) || value < 0) {
            throw new index_js_2.MessagePropertyInvalidValueError({
                metadata: { property: 'scheduledRepeatPeriod', value },
            });
        }
        this.scheduledRepeatPeriod = value;
        return this;
    }
    setScheduledDelay(delay) {
        const value = Number(delay);
        if (isNaN(value) || value < 0) {
            throw new index_js_2.MessagePropertyInvalidValueError({
                metadata: { property: 'scheduledDelay', value },
            });
        }
        this.scheduledDelay = value;
        return this;
    }
    getScheduledDelay() {
        return this.scheduledDelay;
    }
    setScheduledCRON(cron) {
        try {
            cron_parser_1.CronExpressionParser.parse(cron);
        }
        catch (_a) {
            throw new index_js_2.InvalidCronExpressionError({ metadata: { expression: cron } });
        }
        this.scheduledCron = cron;
        return this;
    }
    setScheduledRepeat(repeat) {
        const value = Number(repeat);
        if (isNaN(value) || value < 0) {
            throw new index_js_2.MessagePropertyInvalidValueError({
                metadata: { property: 'scheduledRepeat', value },
            });
        }
        this.scheduledRepeat = value;
        return this;
    }
    resetScheduledParams() {
        this.scheduledCron = null;
        this.scheduledDelay = null;
        this.scheduledRepeatPeriod = null;
        this.scheduledRepeat = 0;
        return this;
    }
    setTTL(ttl) {
        this.ttl = ProducibleMessage.validateTTL(ttl);
        return this;
    }
    setConsumeTimeout(timeout) {
        this.consumeTimeout = ProducibleMessage.validateConsumeTimeout(timeout);
        return this;
    }
    setRetryThreshold(threshold) {
        this.retryThreshold = ProducibleMessage.validateRetryThreshold(threshold);
        return this;
    }
    setRetryDelay(delay) {
        this.retryDelay = ProducibleMessage.validateRetryDelay(delay);
        return this;
    }
    setBody(body) {
        this.body = body;
        return this;
    }
    setPriority(priority) {
        this.priority = priority;
        return this;
    }
    hasPriority() {
        return this.priority !== null;
    }
    disablePriority() {
        this.priority = null;
        return this;
    }
    setFanoutExchange(exchange) {
        return this.setExchange(exchange, index_js_1.EExchangeType.FANOUT);
    }
    setTopicExchange(exchange) {
        return this.setExchange(exchange, index_js_1.EExchangeType.TOPIC);
    }
    setDirectExchange(exchange) {
        return this.setExchange(exchange, index_js_1.EExchangeType.DIRECT);
    }
    setExchangeRoutingKey(routingKey) {
        if (!this.exchange)
            throw new index_js_2.ExchangeRequiredError();
        this.exchangeRoutingKey = routingKey;
        return this;
    }
    getExchangeRoutingKey() {
        return this.exchangeRoutingKey;
    }
    setQueue(queue) {
        const queueParams = (0, _parse_queue_params_js_1._parseQueueParams)(queue);
        if (queueParams instanceof Error)
            throw queueParams;
        this.queue = queueParams;
        this.exchange = null;
        this.exchangeRoutingKey = null;
        return this;
    }
    getQueue() {
        return this.queue;
    }
    getExchange() {
        return this.exchange;
    }
    getScheduledRepeatPeriod() {
        return this.scheduledRepeatPeriod;
    }
    getScheduledCRON() {
        return this.scheduledCron;
    }
    getScheduledRepeat() {
        return this.scheduledRepeat;
    }
    getTTL() {
        return this.ttl;
    }
    getRetryThreshold() {
        return this.retryThreshold;
    }
    getRetryDelay() {
        return this.retryDelay;
    }
    getConsumeTimeout() {
        return this.consumeTimeout;
    }
    getPriority() {
        return this.priority;
    }
    getBody() {
        return this.body;
    }
}
exports.ProducibleMessage = ProducibleMessage;
ProducibleMessage.defaultConsumeOptions = {
    ttl: 0,
    retryThreshold: 3,
    retryDelay: 60000,
    consumeTimeout: 0,
};
//# sourceMappingURL=producible-message.js.map