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

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

import { async, CallbackEmptyReplyError, createLogger, } from 'redis-smq-common';
import { InvalidNamespaceError, InvalidRedisKeyError, } from '../errors/index.js';
import { Configuration } from '../config-manager/configuration.js';
import { withSharedPoolConnection } from '../common/redis/redis-connection-pool/with-shared-pool-connection.js';
import { redisKeys } from '../common/redis/redis-keys/redis-keys.js';
import { _parseQueueParams } from '../queue-manager/_/_parse-queue-params.js';
import { validateRedisKey } from '../common/redis/redis-keys/validator.js';
export class Exchange {
    logger;
    constructor() {
        this.logger = createLogger(Configuration.getConfig().logger, this.constructor.name);
        this.logger.debug('Exchange initialized');
    }
    getAllExchanges(cb) {
        return async.withOptionalCallback(cb, (callback) => {
            const { keyExchanges } = redisKeys.getMainKeys();
            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 CallbackEmptyReplyError());
                    }
                    const exchanges = [];
                    for (const s of members) {
                        try {
                            const ex = JSON.parse(s);
                            if (ex && ex.ns && ex.name)
                                exchanges.push(ex);
                        }
                        catch {
                            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 async.withOptionalCallback(cb, (callback) => {
            const namespace = validateRedisKey(ns);
            if (namespace instanceof InvalidRedisKeyError) {
                this.logger.error('getNamespaceExchanges: invalid namespace');
                return callback(new InvalidNamespaceError());
            }
            const { keyNamespaceExchanges } = redisKeys.getNamespaceKeys(namespace);
            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 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 async.withOptionalCallback(cb, (callback) => {
            const queueParams = _parseQueueParams(queue);
            if (queueParams instanceof Error) {
                this.logger.error('getQueueBoundExchanges: invalid queue params');
                return callback(queueParams);
            }
            const { keyQueueExchangeBindings } = redisKeys.getQueueKeys(queueParams.ns, queueParams.name, null);
            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 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);
        });
    }
}
//# sourceMappingURL=exchange.js.map