redis-smq 7.0.7 → 7.1.0

package/dist/src/lib/exchange/fan-out-exchange-manager.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FanOutExchangeManager = void 0;
+const types_1 = require("../../../types");
+const redis_smq_common_1 = require("redis-smq-common");
+const fan_out_exchange_1 = require("./fan-out-exchange");
+const queue_1 = require("../queue-manager/queue");
+const redis_keys_1 = require("../../common/redis-keys/redis-keys");
+const configuration_1 = require("../../config/configuration");
+const exchange_error_1 = require("./errors/exchange.error");
+class FanOutExchangeManager {
+    constructor(config, redisClient, logger) {
+        this.redisClient = redisClient;
+        this.logger = logger;
+        this.config = config;
+    }
+    createExchange(exchange, cb) {
+        const { keyExchanges } = redis_keys_1.redisKeys.getMainKeys();
+        this.redisClient.sadd(keyExchanges, exchange.getBindingParams(), (err) => cb(err));
+    }
+    deleteExchange(exchange, cb) {
+        const { keyExchanges, keyExchangeBindings } = redis_keys_1.redisKeys.getFanOutExchangeKeys(exchange.getBindingParams());
+        this.redisClient.watch([keyExchanges, keyExchangeBindings], (err) => {
+            if (err)
+                cb(err);
+            else {
+                this.getExchangeQueues(exchange, (err, reply = []) => {
+                    if (err)
+                        cb(err);
+                    else if (reply.length)
+                        cb(new exchange_error_1.ExchangeError(`Exchange has ${reply.length} bound queue(s). Unbind all queues before deleting the exchange.`));
+                    else {
+                        const multi = this.redisClient.multi();
+                        multi.srem(keyExchanges, exchange.getBindingParams());
+                        multi.del(keyExchangeBindings);
+                        multi.exec((err) => cb(err));
+                    }
+                });
+            }
+        });
+    }
+    bindQueue(queue, exchange, cb) {
+        redis_smq_common_1.async.waterfall([
+            (cb) => queue_1.Queue.getSettings(this.config, this.redisClient, queue, cb),
+            (queueSettings, cb) => {
+                const exchangeParams = exchange.getBindingParams();
+                const currentExchangeParams = queueSettings.exchange;
+                if (currentExchangeParams === exchangeParams)
+                    cb();
+                else {
+                    const { keyExchanges, keyExchangeBindings } = redis_keys_1.redisKeys.getFanOutExchangeKeys(exchangeParams);
+                    const queueParams = queue_1.Queue.getParams(this.config, queue);
+                    const { keyQueues, keyQueueSettings } = redis_keys_1.redisKeys.getQueueKeys(queueParams);
+                    this.redisClient.watch([keyQueues, keyQueueSettings, keyExchangeBindings], (err) => {
+                        if (err)
+                            cb(err);
+                        else {
+                            const multi = this.redisClient.multi();
+                            const queueParamsStr = JSON.stringify(queueParams);
+                            multi.sadd(keyExchanges, exchangeParams);
+                            multi.sadd(keyExchangeBindings, queueParamsStr);
+                            multi.hset(keyQueueSettings, types_1.EQueueSettingType.EXCHANGE, exchangeParams);
+                            if (currentExchangeParams) {
+                                const { keyExchangeBindings } = redis_keys_1.redisKeys.getFanOutExchangeKeys(currentExchangeParams);
+                                multi.srem(keyExchangeBindings, queueParamsStr);
+                            }
+                            multi.exec((err) => cb(err));
+                        }
+                    });
+                }
+            },
+        ], (err) => {
+            if (err)
+                this.redisClient.unwatch(() => cb(err));
+            else
+                cb();
+        });
+    }
+    unbindQueue(queue, exchange, cb) {
+        redis_smq_common_1.async.waterfall([
+            (cb) => queue_1.Queue.getSettings(this.config, this.redisClient, queue, cb),
+            (queueSettings, cb) => {
+                const queueParams = queue_1.Queue.getParams(this.config, queue);
+                const exchangeName = exchange.getBindingParams();
+                if (queueSettings.exchange !== exchangeName)
+                    cb(new exchange_error_1.ExchangeError(`Queue ${queueParams.name}@${queueParams.ns} is not bound to [${exchangeName}] exchange.`));
+                else {
+                    const { keyExchangeBindings } = redis_keys_1.redisKeys.getFanOutExchangeKeys(queueSettings.exchange);
+                    const { keyQueues, keyQueueSettings } = redis_keys_1.redisKeys.getQueueKeys(queueParams);
+                    this.redisClient.watch([keyQueues, keyQueueSettings, keyExchangeBindings], (err) => {
+                        if (err)
+                            cb(err);
+                        else {
+                            const multi = this.redisClient.multi();
+                            const queueParamsStr = JSON.stringify(queueParams);
+                            multi.srem(keyExchangeBindings, queueParamsStr);
+                            multi.hdel(keyQueueSettings, types_1.EQueueSettingType.EXCHANGE);
+                            multi.exec((err) => cb(err));
+                        }
+                    });
+                }
+            },
+        ], (err) => {
+            if (err)
+                this.redisClient.unwatch(() => cb(err));
+            else
+                cb();
+        });
+    }
+    getExchanges(cb) {
+        const { keyExchanges } = redis_keys_1.redisKeys.getMainKeys();
+        this.redisClient.sscanFallback(keyExchanges, cb);
+    }
+    getExchangeQueues(exchange, cb) {
+        FanOutExchangeManager.getExchangeQueues(this.redisClient, exchange, cb);
+    }
+    getQueueExchange(queue, cb) {
+        FanOutExchangeManager.getQueueExchange(this.config, this.redisClient, queue, cb);
+    }
+    quit(cb) {
+        this.redisClient.halt(cb);
+    }
+    static getExchangeQueues(redisClient, exchange, cb) {
+        const { keyExchangeBindings } = redis_keys_1.redisKeys.getFanOutExchangeKeys(exchange.getBindingParams());
+        redisClient.sscanFallback(keyExchangeBindings, (err, reply) => {
+            if (err)
+                cb(err);
+            else {
+                const queues = (reply !== null && reply !== void 0 ? reply : []).map((i) => JSON.parse(i));
+                cb(null, queues);
+            }
+        });
+    }
+    static getQueueExchange(config, redisClient, queue, cb) {
+        queue_1.Queue.getSettings(config, redisClient, queue, (err, reply) => {
+            if (err)
+                cb(err);
+            else
+                cb(null, (reply === null || reply === void 0 ? void 0 : reply.exchange) ? new fan_out_exchange_1.FanOutExchange(reply.exchange) : null);
+        });
+    }
+    static createInstance(config = {}, cb) {
+        const cfg = (0, configuration_1.getConfiguration)(config);
+        const redis = cfg.redis;
+        (0, redis_smq_common_1.createClientInstance)(redis, (err, client) => {
+            if (err)
+                cb(err);
+            else if (!client)
+                cb(new redis_smq_common_1.errors.EmptyCallbackReplyError());
+            else {
+                const loggerCfg = cfg.logger;
+                const nsLogger = redis_smq_common_1.logger.getNamespacedLogger(loggerCfg, 'queue-manager');
+                const fanOutExchangeManager = new FanOutExchangeManager(cfg, client, nsLogger);
+                cb(null, fanOutExchangeManager);
+            }
+        });
+    }
+}
+exports.FanOutExchangeManager = FanOutExchangeManager;
+//# sourceMappingURL=fan-out-exchange-manager.js.map

package/dist/src/lib/exchange/fan-out-exchange.d.ts

@@ -0,0 +1,10 @@
+import { Exchange } from './exchange';
+import { EExchangeType, IFanOutExchangeParams, IRequiredConfig, TQueueParams } from '../../../types';
+import { RedisClient } from 'redis-smq-common';
+import { ICallback } from 'redis-smq-common/dist/types';
+export declare class FanOutExchange extends Exchange<string, EExchangeType.FANOUT> {
+    constructor(fanOutName: string);
+    protected validateBindingParams(bindingParams: string): string;
+    getQueues(redisClient: RedisClient, config: IRequiredConfig, cb: ICallback<TQueueParams[]>): void;
+    static fromJSON(json: Partial<IFanOutExchangeParams>): FanOutExchange;
+}

package/dist/src/lib/exchange/fan-out-exchange.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FanOutExchange = void 0;
+const exchange_1 = require("./exchange");
+const types_1 = require("../../../types");
+const invalid_exchange_data_error_1 = require("./errors/invalid-exchange-data.error");
+const fan_out_exchange_manager_1 = require("./fan-out-exchange-manager");
+const redis_keys_1 = require("../../common/redis-keys/redis-keys");
+class FanOutExchange extends exchange_1.Exchange {
+    constructor(fanOutName) {
+        super(fanOutName, types_1.EExchangeType.FANOUT);
+    }
+    validateBindingParams(bindingParams) {
+        return redis_keys_1.redisKeys.validateRedisKey(bindingParams);
+    }
+    getQueues(redisClient, config, cb) {
+        fan_out_exchange_manager_1.FanOutExchangeManager.getExchangeQueues(redisClient, this, cb);
+    }
+    static fromJSON(json) {
+        if (!json.bindingParams || json.type !== types_1.EExchangeType.FANOUT)
+            throw new invalid_exchange_data_error_1.InvalidExchangeDataError();
+        const e = new FanOutExchange(json.bindingParams);
+        e.fromJSON(json);
+        return e;
+    }
+}
+exports.FanOutExchange = FanOutExchange;
+//# sourceMappingURL=fan-out-exchange.js.map

package/dist/src/lib/exchange/topic-exchange.d.ts

@@ -0,0 +1,12 @@
+import { Exchange } from './exchange';
+import { EExchangeType, IRequiredConfig, ITopicExchangeParams, TQueueParams, TTopicParams } from '../../../types';
+import { RedisClient } from 'redis-smq-common';
+import { ICallback } from 'redis-smq-common/dist/types';
+export declare class TopicExchange extends Exchange<TTopicParams | string, EExchangeType.TOPIC> {
+    constructor(topic: TTopicParams | string);
+    protected validateBindingParams(topicParams: TTopicParams | string): TTopicParams | string;
+    protected getTopicParams(config: IRequiredConfig): TTopicParams;
+    matchQueues(config: IRequiredConfig, queues: TQueueParams[], cb: ICallback<TQueueParams[]>): void;
+    getQueues(redisClient: RedisClient, config: IRequiredConfig, cb: ICallback<TQueueParams[]>): void;
+    static fromJSON(json: Partial<ITopicExchangeParams>): TopicExchange;
+}

package/dist/src/lib/exchange/topic-exchange.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopicExchange = void 0;
+const exchange_1 = require("./exchange");
+const types_1 = require("../../../types");
+const redis_smq_common_1 = require("redis-smq-common");
+const queue_1 = require("../queue-manager/queue");
+const redis_keys_1 = require("../../common/redis-keys/redis-keys");
+const invalid_exchange_data_error_1 = require("./errors/invalid-exchange-data.error");
+class TopicExchange extends exchange_1.Exchange {
+    constructor(topic) {
+        super(topic, types_1.EExchangeType.TOPIC);
+    }
+    validateBindingParams(topicParams) {
+        return typeof topicParams === 'string'
+            ? redis_keys_1.redisKeys.validateRedisKey(topicParams)
+            : {
+                topic: redis_keys_1.redisKeys.validateRedisKey(topicParams.topic),
+                ns: redis_keys_1.redisKeys.validateNamespace(topicParams.ns),
+            };
+    }
+    getTopicParams(config) {
+        if (typeof this.bindingParams === 'string') {
+            return {
+                topic: this.bindingParams,
+                ns: config.namespace,
+            };
+        }
+        return this.bindingParams;
+    }
+    matchQueues(config, queues, cb) {
+        const topicParams = this.getTopicParams(config);
+        const matched = [];
+        const regExp = new RegExp(topicParams.topic);
+        redis_smq_common_1.async.eachOf(queues, (queue, index, done) => {
+            if (queue.ns === topicParams.ns && regExp.test(queue.name))
+                matched.push(queue);
+            done();
+        }, (err) => cb(err, matched));
+    }
+    getQueues(redisClient, config, cb) {
+        queue_1.Queue.list(redisClient, (err, reply) => {
+            if (err)
+                cb(err);
+            else
+                this.matchQueues(config, reply !== null && reply !== void 0 ? reply : [], cb);
+        });
+    }
+    static fromJSON(json) {
+        if (!json.bindingParams || json.type !== types_1.EExchangeType.TOPIC)
+            throw new invalid_exchange_data_error_1.InvalidExchangeDataError();
+        const e = new TopicExchange(json.bindingParams);
+        e.fromJSON(json);
+        return e;
+    }
+}
+exports.TopicExchange = TopicExchange;
+//# sourceMappingURL=topic-exchange.js.map

package/dist/src/lib/message/errors/message-exchange-required.error.d.ts

@@ -0,0 +1,4 @@
+import { MessageError } from './message.error';
+export declare class MessageExchangeRequiredError extends MessageError {
+    constructor();
+}

package/dist/src/lib/message/errors/message-exchange-required.error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageExchangeRequiredError = void 0;
+const message_error_1 = require("./message.error");
+class MessageExchangeRequiredError extends message_error_1.MessageError {
+    constructor() {
+        super(`A message exchange is required`);
+    }
+}
+exports.MessageExchangeRequiredError = MessageExchangeRequiredError;
+//# sourceMappingURL=message-exchange-required.error.js.map

package/dist/src/lib/message/errors/message.error.d.ts

@@ -0,0 +1,3 @@
+import { RedisSMQError } from 'redis-smq-common/dist/src/errors/redis-smq.error';
+export declare class MessageError extends RedisSMQError {
+}

package/dist/src/lib/message/errors/message.error.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageError = void 0;
+const redis_smq_error_1 = require("redis-smq-common/dist/src/errors/redis-smq.error");
+class MessageError extends redis_smq_error_1.RedisSMQError {
+}
+exports.MessageError = MessageError;
+//# sourceMappingURL=message.error.js.map

package/dist/src/lib/message/{message-metadata.d.ts → message-state.d.ts}

@@ -1,5 +1,5 @@
-import { TMessageMetadataJSON } from '../../../types';
-export declare class MessageMetadata {
+import { TMessageState } from '../../../types';
+export declare class MessageState {
     protected readonly uuid: string;
     protected publishedAt: number | null;
     protected scheduledAt: number | null;
@@ -10,20 +10,20 @@ export declare class MessageMetadata {
     protected nextScheduledDelay: number;
     protected nextRetryDelay: number;
     constructor();
-    setPublishedAt(timestamp: number): MessageMetadata;
-    setScheduledAt(timestamp: number): MessageMetadata;
-    setNextScheduledDelay(delay: number): MessageMetadata;
+    setPublishedAt(timestamp: number): MessageState;
+    setScheduledAt(timestamp: number): MessageState;
+    setNextScheduledDelay(delay: number): MessageState;
     getSetNextScheduledDelay(): number;
-    setNextRetryDelay(delay: number): MessageMetadata;
+    setNextRetryDelay(delay: number): MessageState;
     getSetNextRetryDelay(): number;
     hasDelay(): boolean;
-    resetMessageScheduledRepeatCount(): MessageMetadata;
+    resetMessageScheduledRepeatCount(): MessageState;
     incrAttempts(): number;
-    setAttempts(attempts: number): MessageMetadata;
-    setMessageScheduledCronFired(fired: boolean): MessageMetadata;
+    setAttempts(attempts: number): MessageState;
+    setMessageScheduledCronFired(fired: boolean): MessageState;
     incrMessageScheduledRepeatCount(): number;
-    setExpired(expired: boolean): MessageMetadata;
-    reset(): MessageMetadata;
+    setExpired(expired: boolean): MessageState;
+    reset(): MessageState;
     getPublishedAt(): number | null;
     getScheduledAt(): number | null;
     getAttempts(): number;
@@ -33,5 +33,5 @@ export declare class MessageMetadata {
     hasExpired(): boolean;
     getSetExpired(ttl: number, createdAt: number): boolean;
     getSetNextDelay(): number;
-    toJSON(): TMessageMetadataJSON;
+    toJSON(): TMessageState;
 }

package/dist/src/lib/message/{message-metadata.js → message-state.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageMetadata = void 0;
+exports.MessageState = void 0;
 const uuid_1 = require("uuid");
-class MessageMetadata {
+class MessageState {
     constructor() {
         this.publishedAt = null;
         this.scheduledAt = null;
@@ -142,5 +142,5 @@ class MessageMetadata {
         };
     }
 }
-exports.MessageMetadata = MessageMetadata;
-//# sourceMappingURL=message-metadata.js.map
+exports.MessageState = MessageState;
+//# sourceMappingURL=message-state.js.map

package/dist/src/lib/message/message.d.ts

@@ -1,5 +1,5 @@
-import { TMessageConsumeOptions, TMessageJSON, TQueueParams } from '../../../types';
-import { MessageMetadata } from './message-metadata';
+import { TMessageConsumeOptions, TExchange, TMessageJSON, TQueueParams, TTopicParams } from '../../../types';
+import { MessageState } from './message-state';
 export declare class Message {
     static readonly MessagePriority: {
         LOWEST: number;
@@ -13,7 +13,6 @@ export declare class Message {
     };
     protected static defaultConsumeOptions: TMessageConsumeOptions;
     protected readonly createdAt: number;
-    protected queue: string | TQueueParams | null;
     protected ttl: number;
     protected retryThreshold: number;
     protected retryDelay: number;
@@ -24,16 +23,19 @@ export declare class Message {
     protected scheduledDelay: number | null;
     protected scheduledRepeatPeriod: number | null;
     protected scheduledRepeat: number;
-    protected metadata: MessageMetadata | null;
+    protected messageState: MessageState | null;
+    protected exchange: TExchange | null;
     constructor();
-    getMetadata(): MessageMetadata | null;
-    getRequiredMetadata(): MessageMetadata;
-    getSetMetadata(): MessageMetadata;
+    getMessageState(): MessageState | null;
+    getRequiredMessageState(): MessageState;
+    setMessageState(m: MessageState): Message;
+    getSetMessageState(): MessageState;
     getPublishedAt(): number | null;
     getScheduledAt(): number | null;
     getId(): string | null;
     getRequiredId(): string;
     getSetExpired(): boolean;
+    setExchange(exchange: TExchange): Message;
     setScheduledRepeatPeriod(period: number): Message;
     setScheduledDelay(delay: number): Message;
     setScheduledCRON(cron: string): Message;
@@ -44,11 +46,16 @@ export declare class Message {
     setRetryDelay(delay: number): Message;
     setBody(body: unknown): Message;
     setPriority(priority: number): Message;
-    setQueue(queue: string | TQueueParams): Message;
+    setFanOut(bindingKey: string): Message;
+    setTopic(topicParams: string | TTopicParams): Message;
+    setQueue(queueParams: string | TQueueParams): Message;
+    setDestinationQueue(queue: TQueueParams): Message;
     disablePriority(): Message;
     hasPriority(): boolean;
     getQueue(): TQueueParams | string | null;
-    getRequiredQueue(): TQueueParams;
+    getTopic(): TTopicParams | string | null;
+    getFanOutParams(): string | null;
+    getDestinationQueue(): TQueueParams;
     getPriority(): number | null;
     getBody(): unknown;
     getTTL(): number;
@@ -62,6 +69,8 @@ export declare class Message {
     getMessageScheduledDelay(): number | null;
     hasNextDelay(): boolean;
     getNextScheduledTimestamp(): number;
+    getExchange(): TExchange | null;
+    getRequiredExchange(): TExchange;
     toString(): string;
     toJSON(): TMessageJSON;
     hasRetryThresholdExceeded(): boolean;
@@ -71,6 +80,6 @@ export declare class Message {
     protected static validateTTL(ttl: unknown): number;
     protected static validateConsumeTimeout(timeout: unknown): number;
     protected static validateRetryThreshold(threshold: unknown): number;
-    static createFromMessage(message: string | Message, reset?: boolean): Message;
+    static createFromMessage(message: string | Message, hardReset?: boolean): Message;
     static setDefaultConsumeOptions(consumeOptions: Partial<TMessageConsumeOptions>): void;
 }