redis-smq
Version:
A high-performance, reliable, and scalable message queue for Node.js.
240 lines • 7.52 kB
JavaScript
import { CronExpressionParser } from 'cron-parser';
import { _parseExchangeParams } from '../exchange/_/_parse-exchange-params.js';
import { EExchangeType, } from '../exchange/index.js';
import { _parseQueueParams } from '../queue-manager/_/_parse-queue-params.js';
import { ExchangeRequiredError, InvalidCronExpressionError, MessagePropertyInvalidValueError, } from '../errors/index.js';
export class ProducibleMessage {
static defaultConsumeOptions = {
ttl: 0,
retryThreshold: 3,
retryDelay: 60000,
consumeTimeout: 0,
};
createdAt;
ttl = 0;
retryThreshold = 3;
retryDelay = 60000;
consumeTimeout = 0;
body = null;
priority = null;
scheduledCron = null;
scheduledDelay = null;
scheduledRepeatPeriod = null;
scheduledRepeat = 0;
exchange = null;
exchangeRoutingKey = null;
queue = null;
constructor() {
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 MessagePropertyInvalidValueError({
metadata: { property: 'retryDelay', value },
});
}
return value;
}
static validateTTL(ttl) {
const value = Number(ttl);
if (isNaN(value) || value < 0) {
throw new MessagePropertyInvalidValueError({
metadata: { property: 'ttl', value },
});
}
return value;
}
static validateConsumeTimeout(timeout) {
const value = Number(timeout);
if (isNaN(value) || value < 0) {
throw new MessagePropertyInvalidValueError({
metadata: { property: 'consumeTimeout', value },
});
}
return value;
}
static validateRetryThreshold(threshold) {
const value = Number(threshold);
if (isNaN(value) || value < 0) {
throw new MessagePropertyInvalidValueError({
metadata: { property: 'retryThreshold', value },
});
}
return value;
}
setExchange(exchange, type) {
const exchangeParams = _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 MessagePropertyInvalidValueError({
metadata: { property: 'scheduledRepeatPeriod', value },
});
}
this.scheduledRepeatPeriod = value;
return this;
}
setScheduledDelay(delay) {
const value = Number(delay);
if (isNaN(value) || value < 0) {
throw new MessagePropertyInvalidValueError({
metadata: { property: 'scheduledDelay', value },
});
}
this.scheduledDelay = value;
return this;
}
getScheduledDelay() {
return this.scheduledDelay;
}
setScheduledCRON(cron) {
try {
CronExpressionParser.parse(cron);
}
catch {
throw new InvalidCronExpressionError({ metadata: { expression: cron } });
}
this.scheduledCron = cron;
return this;
}
setScheduledRepeat(repeat) {
const value = Number(repeat);
if (isNaN(value) || value < 0) {
throw new 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, EExchangeType.FANOUT);
}
setTopicExchange(exchange) {
return this.setExchange(exchange, EExchangeType.TOPIC);
}
setDirectExchange(exchange) {
return this.setExchange(exchange, EExchangeType.DIRECT);
}
setExchangeRoutingKey(routingKey) {
if (!this.exchange)
throw new ExchangeRequiredError();
this.exchangeRoutingKey = routingKey;
return this;
}
getExchangeRoutingKey() {
return this.exchangeRoutingKey;
}
setQueue(queue) {
const queueParams = _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;
}
}
//# sourceMappingURL=producible-message.js.map