@autofleet/rabbit 3.2.0 → 3.2.2-2.beta-0

package/dist/index.js

@@ -10,6 +10,7 @@ const moment_1 = __importDefault(require("moment"));
 const redis_lock_1 = __importDefault(require("redis-lock"));
 const amqp_connection_manager_1 = require("amqp-connection-manager");
 const zehut_1 = require("@autofleet/zehut");
+const node_crypto_1 = require("node:crypto");
 const logger_1 = __importDefault(require("./logger"));
 const rabbitError_1 = __importDefault(require("./lib/rabbitError"));
 const redis_1 = __importDefault(require("./lib/redis"));
@@ -17,10 +18,43 @@ const utils_1 = require("./lib/utils");
 const consts_1 = require("./lib/consts");
 const types_1 = require("./lib/types");
 // const debug = nodeDebug('af-rabbitmq')
-const debug = logger_1.default.info;
+const debug = logger_1.default.debug.bind(logger_1.default);
 const PUBLISH_TIMEOUT = 1000 * 10;
 const HEARTBEAT = '60';
 class RabbitMq {
+    static parseMsg(msg) {
+        let { content } = msg;
+        content = content.toString();
+        try {
+            content = JSON.parse(content);
+        }
+        catch (e) { }
+        return {
+            ...msg,
+            content,
+        };
+    }
+    static validateName(type, name) {
+        if (!name || name === '') {
+            throw new rabbitError_1.default(`error while using ${type} with no name`);
+        }
+    }
+    static getPublishOptions(customHeaders = {}) {
+        const trace = (0, zehut_1.getCurrentPayload)();
+        const user = trace?.context?.get(consts_1.USER_OBJECT);
+        const traceId = trace?.context?.get(consts_1.TRACING_HEADER);
+        const outbreakTrace = zehut_1.outbreak.getCurrentContext();
+        return {
+            timestamp: (0, moment_1.default)().unix(),
+            timeout: PUBLISH_TIMEOUT,
+            headers: {
+                creationTimestamp: (0, moment_1.default)().valueOf(),
+                ...customHeaders,
+                [consts_1.USER_TRACING_HEADER]: user?.id,
+                [consts_1.TRACING_HEADER]: traceId || outbreakTrace?.context?.get(consts_1.TRACING_HEADER),
+            },
+        };
+    }
     constructor(options, redisConfig) {
         this.DISCONNECT_MSG = 'rabbit: connection disconnect';
         this.RECONNECT_MSG = 'rabbit: connection disconnect - reconnecting';
@@ -39,6 +73,7 @@ class RabbitMq {
         };
         this.ack = (channel, msg, shouldUpdateRedisTimestamp = false, releaseLock = null) => async (userMsg) => {
             if (msg) {
+                debug('rabbit acking message', { deliveryTag: msg.fields.deliveryTag });
                 await channel.ack(msg);
                 const { properties: { headers } } = msg;
                 const timestamp = headers?.creationTimestamp;
@@ -71,28 +106,30 @@ class RabbitMq {
                             : 1,
                     });
                 }
+                debug('rabbit nacking message', { deliveryTag: msg.fields.deliveryTag });
                 await channel.ack(msg);
             }
             else {
                 logger_1.default.error('no channel or msg', {
-                    channel: channel ? channel.name : '',
                     msg,
                 });
             }
         };
-        this.userName = process.env.RABBITMQ_USERNAME || 'guest';
-        this.password = process.env.RABBITMQ_PASSWORD || 'guest';
-        this.host = options?.rabbitHost || process.env.RABBITMQ_SERVICE_HOST || 'localhost';
         this.em = new events_1.EventEmitter();
         this.channel = null;
-        this.connection = null;
-        this.creatingConnection = false;
+        this.publishChannelSetupPromise = null;
+        this.connectionsMap = {
+            [types_1.ConnectionPurpose.Consume]: { connection: null, creatingConnection: false },
+            [types_1.ConnectionPurpose.Publish]: { connection: null, creatingConnection: false },
+        };
         this.exchanges = {};
         this.queues = {};
+        this.queueSetupPromises = {};
+        this.consumers = [];
         this.options = options;
-        this.redisClient = redisConfig && redis_1.default(redisConfig);
+        this.redisClient = redisConfig && (0, redis_1.default)(redisConfig);
         if (this.redisClient) {
-            this.redisLock = util_1.promisify(redis_lock_1.default(this.redisClient));
+            this.redisLock = (0, util_1.promisify)((0, redis_lock_1.default)(this.redisClient));
         }
         this.consumersTags = [];
         logger_1.default.info(`rabbit: [gracefully-shutdown] adding gracefully shutdown for process.pid ${process.pid}`);
@@ -105,68 +142,52 @@ class RabbitMq {
             });
         }
     }
-    static parseMsg(msg) {
-        let { content } = msg;
-        content = content.toString();
-        try {
-            content = JSON.parse(content);
-        }
-        catch (e) { }
-        return {
-            ...msg,
-            content,
-        };
-    }
-    static validateName(type, name) {
-        if (!name || name === '') {
-            throw new rabbitError_1.default(`error while using ${type} with no name`);
-        }
-    }
-    static getPublishOptions(customHeaders = {}) {
-        const trace = zehut_1.getCurrentPayload();
-        const user = trace?.context?.get(consts_1.USER_OBJECT);
-        const traceId = trace?.context?.get(consts_1.TRACING_HEADER);
-        const outbreakTrace = zehut_1.outbreak.getCurrentContext();
-        return {
-            timestamp: moment_1.default().unix(),
-            timeout: PUBLISH_TIMEOUT,
-            headers: {
-                creationTimestamp: moment_1.default().valueOf(),
-                ...customHeaders,
-                [consts_1.USER_TRACING_HEADER]: user?.id,
-                [consts_1.TRACING_HEADER]: traceId || outbreakTrace?.context?.get(consts_1.TRACING_HEADER),
-            },
-        };
-    }
-    async getConnection() {
+    async getConnection(connectionPurpose) {
         return new Promise(async (resolve, reject) => {
+            let { connection, creatingConnection } = this.connectionsMap[connectionPurpose];
             if (this.blockReconnect) {
                 debug('rabbit: block reconnect');
                 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                 // @ts-ignore
                 return resolve();
             }
-            if (this.connection !== null) {
-                if (this.options?.disableReconnect || this.connection?.isConnected()) {
+            if (connection !== null) {
+                if (this.options?.disableReconnect || connection?.isConnected()) {
                     debug('rabbit: connection - is connected');
                     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                     // @ts-ignore
-                    return resolve(this.connection);
+                    return resolve(connection);
                 }
                 debug('rabbit: connection - reconnecting');
             }
-            if (this.creatingConnection) {
+            if (creatingConnection) {
                 debug('rabbit: creating connection emi');
                 this.em.once(consts_1.CONNECTION_CREATED_CONST, resolve);
                 this.em.once(consts_1.CONNECTION_FAILED_CONST, reject);
                 return;
             }
-            this.creatingConnection = true;
+            this.connectionsMap[connectionPurpose].creatingConnection = true;
             let isResolved = false;
-            debug('rabbit: creating connection', { host: this.host, userName: this.userName, HEARTBEAT });
-            const connection = await amqp_connection_manager_1.connect([`amqp://${this.userName}:${this.password}@${this.host}?heartbeat=${HEARTBEAT}}`]);
-            this.connection = connection;
-            this.connection.on('error', (err) => {
+            // It is import to use it as a function and not as a variable
+            // because of k8s changes the env variables
+            // and we want to use the new values
+            const findServers = () => {
+                const userName = process.env.RABBITMQ_USERNAME || 'guest';
+                const password = process.env.RABBITMQ_PASSWORD || 'guest';
+                const host = this.options?.rabbitHost || process.env.RABBITMQ_SERVICE_HOST || 'localhost';
+                debug('rabbit: creating connection', { host, userName, HEARTBEAT });
+                return [`amqp://${userName}:${password}@${host}?heartbeat=${HEARTBEAT}`];
+            };
+            const defaultUrls = findServers();
+            const newConnection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
+                findServers,
+            });
+            if (!newConnection) {
+                logger_1.default.error('rabbit: couldnt create a connection');
+                return resolve(connection);
+            }
+            this.connectionsMap[connectionPurpose].connection = newConnection;
+            newConnection.on('error', (err) => {
                 logger_1.default.error('rabbit: connection error', { err });
                 if (!isResolved) {
                     isResolved = true;
@@ -174,7 +195,8 @@ class RabbitMq {
                     this.em.emit(consts_1.CONNECTION_FAILED_CONST, err);
                 }
             });
-            this.connection.on('connectFailed', (err) => {
+            newConnection.on('connectFailed', (err) => {
+                this.consumersTags = [];
                 logger_1.default.error('rabbit: connection connectFailed', { err });
                 if (!isResolved) {
                     isResolved = true;
@@ -182,10 +204,9 @@ class RabbitMq {
                     this.em.emit(consts_1.CONNECTION_FAILED_CONST, err);
                 }
             });
-            this.connection.on('disconnect', ({ err }) => {
+            newConnection.on('disconnect', ({ err }) => {
+                this.consumersTags = [];
                 debug('rabbit: connection closed');
-                this.exchanges = {};
-                this.queues = {};
                 if (this.options?.disableReconnect) {
                     logger_1.default.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
                     this.blockReconnect = true;
@@ -194,95 +215,99 @@ class RabbitMq {
                     logger_1.default.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
                 }
             });
-            this.connection.once('connect', async () => {
+            newConnection.once('connect', async () => {
                 debug('rabbit: connection established');
-                await this.loadConsumers();
-                this.creatingConnection = false;
-                this.em.emit(consts_1.CONNECTION_CREATED_CONST, connection);
+                this.connectionsMap[connectionPurpose].creatingConnection = false;
+                this.em.emit(consts_1.CONNECTION_CREATED_CONST, newConnection);
                 isResolved = true;
-                resolve(connection);
+                resolve(newConnection);
             });
         });
     }
-    async getNewChannel({ name = utils_1.rand().toString(), onClose = null } = {}) {
-        return new Promise(async (resolve, reject) => {
-            const connection = await this.getConnection();
-            const channel = connection.createChannel({});
-            let isResolved = false;
-            channel.on('error', (err) => {
-                logger_1.default.error(`rabbit: channel ${name} error`, { err });
-                if (!isResolved) {
-                    isResolved = true;
-                    reject(err);
+    async getNewChannel({ name = (0, utils_1.rand)().toString(), onClose = null, options = {}, connectionPurpose = types_1.ConnectionPurpose.Consume, }) {
+        let connection;
+        try {
+            connection = await this.getConnection(connectionPurpose);
+        }
+        catch (e) {
+            logger_1.default.error(`rabbit: error on get connection for new channel ${name} `, { e });
+            throw e;
+        }
+        if (!connection) {
+            throw new Error(`rabbit: couldnt get connection for new channel ${name}`);
+        }
+        const channel = connection.createChannel({ ...options });
+        (0, events_1.once)(channel, 'close').then((args) => {
+            logger_1.default.error(`rabbit: channel ${name} closed`);
+            onClose?.(args);
+        });
+        try {
+            await (0, events_1.once)(channel, 'connect');
+            debug(`rabbit: channel ${name} CONNECTED`);
+            return channel;
+        }
+        catch (err) {
+            logger_1.default.error(`rabbit: channel error ${name} error`, { err });
+            throw err;
+        }
+    }
+    async assertChannel({ force = false, connectionPurpose = types_1.ConnectionPurpose.Consume }) {
+        if (!this.publishChannelSetupPromise) {
+            this.publishChannelSetupPromise = new Promise(async (resolve, reject) => {
+                if (this.channel && !force) {
+                    return resolve(this.channel);
                 }
-            });
-            channel.on('close', (...args) => {
-                logger_1.default.error(`rabbit: channel ${name} closed`, { args });
-                if (onClose) {
-                    onClose(args);
+                try {
+                    const channel = await this.getNewChannel({ connectionPurpose });
+                    channel.on('error', (err) => {
+                        logger_1.default.error('rabbit: channel error', { err });
+                    });
+                    this.channel = channel;
+                    resolve(channel);
+                }
+                catch (e) {
+                    reject(e);
                 }
             });
-            channel.once('connect', () => {
-                debug(`rabbit: channel ${name} CONNECTED`);
-                isResolved = true;
-                resolve(channel);
-            });
-        });
-    }
-    async assertChannel({ force = false } = {}) {
-        return new Promise(async (resolve, reject) => {
-            if (this.channel && !force) {
-                return resolve(this.channel);
-            }
-            try {
-                const channel = await this.getNewChannel({});
-                channel.on('error', (err) => {
-                    logger_1.default.error('rabbit: channel error', { err });
-                });
-                this.channel = channel;
-                resolve(channel);
-            }
-            catch (e) {
-                reject(e);
-            }
-        });
+        }
+        return this.publishChannelSetupPromise;
     }
     async assertExchange(exchangeName, options) {
-        const channel = await this.assertChannel();
+        const channel = await this.assertChannel({ connectionPurpose: options.connectionPurpose });
         if (this.exchanges[exchangeName]) {
             return this.exchanges[exchangeName];
         }
-        const exchange = await utils_1.assertExchangeFanout(channel, exchangeName);
+        const exchange = await (0, utils_1.assertExchangeFanout)(channel, exchangeName);
         this.exchanges[exchangeName] = exchange;
         return exchange;
     }
-    async getQueueLength(queue) {
+    async getQueueLength(queue, connectionPurpose = types_1.ConnectionPurpose.Consume) {
         RabbitMq.validateName('queue', queue);
-        const channel = await this.assertChannel();
-        debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
-        return channel.checkQueue(queue);
+        let { connection } = this.connectionsMap[connectionPurpose];
+        const { channel } = this;
+        if (!channel) {
+            throw new Error('channel is not defined');
+        }
+        debug('rabbit: getting queue length', { queue, connected: connection?.isConnected() });
+        return channel?.checkQueue(queue);
     }
-    async deleteQueue(queue) {
+    async deleteQueue(queue, connectionPurpose) {
         RabbitMq.validateName('queue', queue);
-        const channel = await this.assertChannel();
+        const channel = await this.assertChannel({ connectionPurpose });
         logger_1.default.info('rabbit: deleting queue', { queue });
         const deleteQueueRes = await channel.deleteQueue(queue);
         debug('queue deleted', deleteQueueRes);
         return deleteQueueRes;
     }
-    async bindQueue(queue, exchange) {
-        const channel = await this.assertChannel();
+    async bindQueue(queue, exchange, connectionPurpose) {
+        const channel = await this.assertChannel({ connectionPurpose });
         await channel.addSetup((setupChannel) => setupChannel.bindQueue(queue, exchange, ''));
         return channel.bindQueue(queue, exchange, '');
     }
-    async assertQueue(queueName, options) {
-        let queue = null;
-        RabbitMq.validateName('queue', queueName);
-        if (this.queues[queueName]) {
-            return this.queues[queueName];
-        }
+    async setupQueue(queueName, connectionPurpose, options) {
+        let queue;
         try {
-            const channel = await this.assertChannel();
+            const channel = await this.assertChannel({ connectionPurpose });
             debug('assertQueue->channel.addSetup', { queueName });
             await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, options));
             debug('assertQueue->channel.assertQueue', { queueName });
@@ -292,11 +317,11 @@ class RabbitMq {
             logger_1.default.error('rabbit: assertQueue error', { queueName, options, error: e });
             if (!this.options?.dontRetryAssert) {
                 debug('retrying assertQueue', { queueName });
-                const channel = await this.assertChannel({ force: true });
-                await this.deleteQueue(queueName);
-                debug('1assertQueue->channel.addSetup', { queueName });
+                const channel = await this.assertChannel({ force: true, connectionPurpose });
+                await this.deleteQueue(queueName, connectionPurpose);
+                debug('retrying assertQueue->channel.addSetup', { queueName });
                 await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, options));
-                debug('1assertQueue->channel.assertQueue', { queueName });
+                debug('retrying assertQueue->channel.assertQueue', { queueName });
                 queue = await channel.assertQueue(queueName, options);
             }
             else {
@@ -306,25 +331,31 @@ class RabbitMq {
         this.queues[queueName] = queueName;
         return queue;
     }
-    saveConsumer(queue, callback, options) {
-        this.consumers.push({
-            queue,
-            callback,
-            options,
-        });
+    async assertQueue(queueName, connectionPurpose, options) {
+        RabbitMq.validateName('queue', queueName);
+        if (this.queues[queueName]) {
+            delete this.queueSetupPromises[queueName];
+            return this.queues[queueName];
+        }
+        if (this.queueSetupPromises[queueName]) {
+            return this.queueSetupPromises[queueName];
+        }
+        this.queueSetupPromises[queueName] = this.setupQueue(queueName, connectionPurpose, options);
+        return this.queueSetupPromises[queueName];
     }
-    async loadConsumers() {
-        debug('rabbit: loading consumers', { consumers: this.consumers.length });
-        if (this.consumers.length > 0) {
-            await Promise.all(this.consumers.map((consumer) => this
-                .consumeFromRabbit(consumer.queue, consumer.callback, consumer.options)));
+    saveConsumer(queue, callback, options) {
+        const isConsumerExist = this.consumers.some((consumer) => consumer.queue === queue);
+        if (!isConsumerExist) {
+            logger_1.default.info(`rabbit: consumer: ${queue} saved in consumer array`);
+            this.consumers.push({
+                queue,
+                callback,
+                options,
+            });
         }
     }
     async consume(queue, callback, options) {
-        if (this.connection && !this.creatingConnection) {
-            this.consumeFromRabbit(queue, callback, options);
-        }
-        return this.saveConsumer(queue, callback, options);
+        await this.consumeFromRabbit(queue, callback, options);
     }
     async lockRedisIfNeeded(msg, options) {
         const { properties: { headers } } = msg;
@@ -343,6 +374,8 @@ class RabbitMq {
     async consumeFromRabbit(queue, callback, options) {
         const optionsWithDefaults = { ...consts_1.DEFAULT_OPTIONS, ...options };
         RabbitMq.validateName('queue', queue);
+        this.saveConsumer(queue, callback, options);
+        const uniqueId = (0, node_crypto_1.randomUUID)();
         const { limit, deadMessageTtl, useConsumeWithLock, lockTimeout, auditContext, enableRabbitTrace, } = optionsWithDefaults;
         if (useConsumeWithLock) {
             if (!this.redisLock) {
@@ -350,11 +383,11 @@ class RabbitMq {
             }
             logger_1.default.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
         }
-        const channel = await this.getNewChannel({ name: `consume-queue-${queue}` });
-        return channel.addSetup(async (c) => {
-            await c.assertQueue(queue, options ? { messageTtl: options.messageTtl } : undefined);
-            await c.prefetch(limit, true);
-            const { consumerTag } = await c.consume(queue, async (msg) => {
+        const channel = await this.getNewChannel({ connectionPurpose: types_1.ConnectionPurpose.Consume });
+        return channel.addSetup(async (confirmChannel) => {
+            await confirmChannel.assertQueue(queue, options ? { messageTtl: options.messageTtl } : undefined);
+            await confirmChannel.prefetch(limit, true);
+            const { consumerTag } = await confirmChannel.consume(queue, async (msg) => {
                 if (!msg) {
                     return null;
                 }
@@ -362,7 +395,7 @@ class RabbitMq {
                 const userId = msg.properties.headers[consts_1.USER_TRACING_HEADER];
                 const parsedMessage = RabbitMq.parseMsg(msg);
                 const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
-                const trace = zehut_1.newTrace(zehut_1.traceTypes.RABBIT);
+                const trace = (0, zehut_1.newTrace)(zehut_1.traceTypes.RABBIT);
                 // setting also outbreak trace as part of legacy code
                 const outbreakTrace = zehut_1.outbreak.newTrace(zehut_1.traceTypes.RABBIT);
                 // enableRabbitTrace is a flag to protect from different flows that doesn't work with permission
@@ -370,13 +403,13 @@ class RabbitMq {
                 if (userId && enableRabbitTrace) {
                     try {
                         await Promise.all([
-                            zehut_1.createOrSetRabbitTrace(trace, userId),
-                            zehut_1.createOrSetRabbitTrace(outbreakTrace, userId),
+                            (0, zehut_1.createOrSetRabbitTrace)(trace, userId),
+                            (0, zehut_1.createOrSetRabbitTrace)(outbreakTrace, userId),
                         ]);
                     }
                     catch (e) {
                         logger_1.default.error('rabbit: failed to setRabbitTrace', { userId, e });
-                        await this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
+                        return this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
                     }
                 }
                 if (traceId) {
@@ -389,13 +422,30 @@ class RabbitMq {
                 const shouldConsume = await this.shouldConsumeMessageByTimestamp(parsedMessage);
                 if (!shouldConsume) {
                     await this.unlockRedisIfNeeded(releaseLock);
-                    return this.ack(channel, msg)(msg);
+                    return this.ack(confirmChannel, msg)(msg);
                 }
+                let messageAcked = false;
+                // setting the localAck function to be used in the callback
+                const localAck = async () => {
+                    if (messageAcked) {
+                        return;
+                    }
+                    messageAcked = true;
+                    return this.ack(confirmChannel, msg, true, releaseLock)(msg);
+                };
+                const localNack = async (_, nackOptions = {}) => {
+                    if (messageAcked) {
+                        return;
+                    }
+                    debug('rabbit localNack', { messageAcked, uniqueId, deliveryTag: msg.fields.deliveryTag });
+                    messageAcked = true;
+                    return this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg, nackOptions);
+                };
                 try {
-                    await callback(parsedMessage, this.ack(channel, msg, true, releaseLock), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock));
+                    await callback(parsedMessage, localAck, localNack);
                 }
                 catch (e) {
-                    await this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
+                    await localNack(msg);
                 }
             }, types_1.CONSUMER_DEFAULT_OPTIONS);
             if (!consumerTag) {
@@ -403,7 +453,7 @@ class RabbitMq {
             }
             else {
                 logger_1.default.info(`rabbit: adding tag ${consumerTag} to the array.`);
-                this.consumersTags.push([c, consumerTag]);
+                this.consumersTags.push([confirmChannel, consumerTag]);
             }
         });
     }
@@ -412,9 +462,10 @@ class RabbitMq {
         RabbitMq.validateName('exchange', exchange);
         RabbitMq.validateName('queue', queue);
         const { limit, deadMessageTtl } = optionsWithDefaults;
-        const channel = await this.getNewChannel({ name: `consume-exchange-${exchange}-queue-${queue}` });
+        await this.saveConsumer(queue, callback, options);
+        const channel = await this.getNewChannel({ name: `consume - exchange - ${exchange} -queue - ${queue}`, connectionPurpose: types_1.ConnectionPurpose.Consume });
         return channel.addSetup(async (c) => {
-            const assertExchange = await utils_1.assertExchangeFanout(c, exchange);
+            const assertExchange = await (0, utils_1.assertExchangeFanout)(c, exchange);
             await c.assertQueue(queue);
             this.exchanges[exchange] = assertExchange;
             await c.prefetch(limit, true);
@@ -425,36 +476,64 @@ class RabbitMq {
         });
     }
     async publish(exchange, content, customHeaders) {
-        return utils_1.wrapSetImmediate(async () => {
+        return (0, utils_1.wrapSetImmediate)(async () => {
             RabbitMq.validateName('exchange', exchange);
-            const channel = await this.assertChannel();
-            await this.assertExchange(exchange);
+            const channel = await this.assertChannel({ connectionPurpose: types_1.ConnectionPurpose.Publish });
+            await this.assertExchange(exchange, { connectionPurpose: types_1.ConnectionPurpose.Publish });
             await channel.publish(exchange, '', Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
         });
     }
-    async sendToQueue(queue, content, options, customHeaders, isBlocking) {
-        const callback = async () => {
-            try {
-                RabbitMq.validateName('queue', queue);
-                await this.assertChannel();
-                await this.assertQueue(queue, options);
-                const res = await this.channel?.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
-                debug(`rabbit: sending to queue ${queue}`, { res });
-                return res;
-            }
-            catch (e) {
-                logger_1.default.error(`rabbit: failed to send to queue ${queue}`, { e });
-                throw e;
-            }
-        };
-        if (isBlocking) {
-            return callback();
+    async sendToQueue(queue, content, options, customHeaders) {
+        try {
+            await this.assertChannel({ connectionPurpose: types_1.ConnectionPurpose.Publish });
+        }
+        catch (e) {
+            logger_1.default.error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });
+            throw e;
+        }
+        try {
+            RabbitMq.validateName('queue', queue);
+            await this.assertQueue(queue, types_1.ConnectionPurpose.Publish, options);
+        }
+        catch (e) {
+            logger_1.default.error(`rabbit sendToQueue: failed to assert queue ${queue}`, { e });
+            throw e;
+        }
+        try {
+            const res = await this.channel?.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
+            debug(`rabbit: sending to queue ${queue}`, { res });
+            return res;
+        }
+        catch (e) {
+            const isConnected = await this.isConnected(types_1.ConnectionPurpose.Publish);
+            logger_1.default.error(`rabbit sendToQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { e });
+            throw e;
         }
-        return utils_1.wrapSetImmediate(callback);
     }
-    async isConnected() {
-        const connection = await this.getConnection();
-        return connection.isConnected();
+    async isConnected(connectionPurpose) {
+        const connection = await this.getConnection(connectionPurpose);
+        if (!connection) {
+            logger_1.default.error('rabbit: isConnected - false');
+            return false;
+        }
+        const isConnected = connection.isConnected();
+        if (!isConnected) {
+            logger_1.default.error('rabbit: isConnected - false');
+            return false;
+        }
+        const channel = await this.assertChannel({ connectionPurpose });
+        try {
+            await Promise.all([
+                channel.waitForConnect(),
+                ...this.consumers.map((c) => channel.checkQueue(c.queue)),
+            ]);
+        }
+        catch (e) {
+            logger_1.default.error('rabbit: isConnected - false');
+            return false;
+        }
+        logger_1.default.info('rabbit: isConnected - true');
+        return true;
     }
     async gracefulShutdown(signal) {
         const tagsNumber = this.consumersTags.length;

package/dist/lib/redis.d.ts

@@ -1,4 +1,4 @@
-export declare type RedisConfig = {
+export type RedisConfig = {
     host: string;
     port: number | undefined;
     prefix?: string;