redis-smq/dist/cjs/src/exchange/exchange.js

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

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Exchange = void 0;
const redis_smq_common_1 = require("redis-smq-common");
const index_js_1 = require("../errors/index.js");
const configuration_js_1 = require("../config-manager/configuration.js");
const with_shared_pool_connection_js_1 = require("../common/redis/redis-connection-pool/with-shared-pool-connection.js");
const redis_keys_js_1 = require("../common/redis/redis-keys/redis-keys.js");
const _parse_queue_params_js_1 = require("../queue-manager/_/_parse-queue-params.js");
const validator_js_1 = require("../common/redis/redis-keys/validator.js");
class Exchange {
    constructor() {
        this.logger = (0, redis_smq_common_1.createLogger)(configuration_js_1.Configuration.getConfig().logger, this.constructor.name);
        this.logger.debug('Exchange initialized');
    }
    getAllExchanges(cb) {
        return redis_smq_common_1.async.withOptionalCallback(cb, (callback) => {
            const { keyExchanges } = redis_keys_js_1.redisKeys.getMainKeys();
            (0, with_shared_pool_connection_js_1.withSharedPoolConnection)((client, done) => {
                client.smembers(keyExchanges, (err, members) => {
                    if (err) {
                        this.logger.error(`getAllExchanges: redis error err=${err.message}`);
                        return done(err);
                    }
                    if (!members) {
                        this.logger.error('getAllExchanges: empty reply');
                        return done(new redis_smq_common_1.CallbackEmptyReplyError());
                    }
                    const exchanges = [];
                    for (const s of members) {
                        try {
                            const ex = JSON.parse(s);
                            if (ex && ex.ns && ex.name)
                                exchanges.push(ex);
                        }
                        catch (_a) {
                            this.logger.warn('getAllExchanges: ignoring malformed exchange entry');
                        }
                    }
                    this.logger.debug(`getAllExchanges: found ${exchanges.length} exchange(s)`);
                    done(null, exchanges);
                });
            }, callback);
        });
    }
    getNamespaceExchanges(ns, cb) {
        return redis_smq_common_1.async.withOptionalCallback(cb, (callback) => {
            const namespace = (0, validator_js_1.validateRedisKey)(ns);
            if (namespace instanceof index_js_1.InvalidRedisKeyError) {
                this.logger.error('getNamespaceExchanges: invalid namespace');
                return callback(new index_js_1.InvalidNamespaceError());
            }
            const { keyNamespaceExchanges } = redis_keys_js_1.redisKeys.getNamespaceKeys(namespace);
            (0, with_shared_pool_connection_js_1.withSharedPoolConnection)((client, done) => {
                client.smembers(keyNamespaceExchanges, (err, members) => {
                    if (err) {
                        this.logger.error(`getNamespaceExchanges: redis error ns=${ns} err=${err.message}`);
                        return done(err);
                    }
                    if (!members) {
                        this.logger.error(`getNamespaceExchanges: empty reply ns=${ns}`);
                        return done(new redis_smq_common_1.CallbackEmptyReplyError());
                    }
                    const exchanges = members.map((i) => JSON.parse(i));
                    this.logger.debug(`getNamespaceExchanges: ns=${ns} count=${exchanges.length}`);
                    done(null, exchanges);
                });
            }, callback);
        });
    }
    getQueueExchanges(queue, cb) {
        return redis_smq_common_1.async.withOptionalCallback(cb, (callback) => {
            const queueParams = (0, _parse_queue_params_js_1._parseQueueParams)(queue);
            if (queueParams instanceof Error) {
                this.logger.error('getQueueBoundExchanges: invalid queue params');
                return callback(queueParams);
            }
            const { keyQueueExchangeBindings } = redis_keys_js_1.redisKeys.getQueueKeys(queueParams.ns, queueParams.name, null);
            (0, with_shared_pool_connection_js_1.withSharedPoolConnection)((client, done) => {
                client.smembers(keyQueueExchangeBindings, (err, members) => {
                    if (err) {
                        this.logger.error(`getQueueBoundExchanges: redis error ns=${queueParams.ns} q=${queueParams.name} err=${err.message}`);
                        return done(err);
                    }
                    if (!members) {
                        this.logger.error(`getQueueBoundExchanges: empty reply ns=${queueParams.ns} q=${queueParams.name}`);
                        return done(new redis_smq_common_1.CallbackEmptyReplyError());
                    }
                    const exchanges = members.map((i) => JSON.parse(i));
                    this.logger.debug(`getQueueBoundExchanges: ns=${queueParams.ns} q=${queueParams.name} count=${exchanges.length}`);
                    done(null, exchanges);
                });
            }, callback);
        });
    }
}
exports.Exchange = Exchange;
//# sourceMappingURL=exchange.js.map