@autofleet/rabbit 3.2.25-beta.103 → 3.2.26-beta.0

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
-import { AmqpConnectionManager, ChannelWrapper } from 'amqp-connection-manager';
+import { AmqpConnectionManager, ChannelWrapper, CreateChannelOpts } from 'amqp-connection-manager';
 import { ConfirmChannel, ConsumeMessage, Options, Replies } from 'amqplib';
 import { RedisConfig } from './lib/redis';
-import { CallbackFunction, ConsumeMessageOrNull, ConsumeOptions, CustomMessageHeaders, QueuesCache, RedisLockType, ExchangesCache, QueueSetupPromisesDictionary, AssertExchangePromisesDictionary, assertChannelOpts, newChannelOpts, PublishOptions } from './lib/types';
+import { ConnectionPurpose } from './lib/consts';
+import { CallbackFunction, ConsumeMessageOrNull, ConsumeOptions, CustomMessageHeaders, QueuesCache, RedisLockType, ExchangesCache, QueueSetupPromisesDictionary, AssertExchangePromisesDictionary, ConnectionData } from './lib/types';
 export interface IAfRabbitMq {
     ack: any;
     nack: any;
@@ -33,6 +34,17 @@ export interface AfRabbitOptions {
     dontRetryAssert?: boolean;
     rabbitHost?: string;
 }
+type newChannelOpts = {
+    name?: string;
+    onClose?: null | ((args: any | null) => void);
+    options?: CreateChannelOpts | undefined;
+    connectionPurpose?: ConnectionPurpose;
+};
+type assertChannelOpts = {
+    channelName?: string;
+    force?: boolean;
+    connectionPurpose?: ConnectionPurpose;
+};
 declare class RabbitMq implements IAfRabbitMq {
     static parseMsg(msg: any): any;
     static validateName(type: string, name: string): void;
@@ -48,12 +60,14 @@ declare class RabbitMq implements IAfRabbitMq {
     };
     DISCONNECT_MSG: string;
     RECONNECT_MSG: string;
-    channel: ChannelWrapper | null;
+    publishChannel: ChannelWrapper | null;
     publishChannelSetupPromise: Promise<ChannelWrapper> | null;
     blockReconnect: boolean | null | undefined;
-    connection: AmqpConnectionManager | null | undefined;
+    connectionsMap: {
+        [ConnectionPurpose.Consume]: ConnectionData;
+        [ConnectionPurpose.Publish]: ConnectionData;
+    };
     em: EventEmitter;
-    creatingConnection: boolean;
     exchanges: ExchangesCache;
     queues: QueuesCache;
     queueSetupPromises: QueueSetupPromisesDictionary;
@@ -68,23 +82,23 @@ declare class RabbitMq implements IAfRabbitMq {
     private shouldConsumeMessageByTimestamp;
     ack: (channel: ConfirmChannel, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp?: boolean, releaseLock?: null) => (userMsg: ConsumeMessage) => Promise<any>;
     nack: (channel: ConfirmChannel, queue: string, options: any, deadQueueOptions: Options.AssertQueue, msg: ConsumeMessageOrNull, releaseLock: any) => (userMsg: ConsumeMessageOrNull, { skipRetry, }?: NackOptions) => Promise<any>;
-    getConnection(): Promise<AmqpConnectionManager>;
-    getNewChannel({ name, onClose, options }?: newChannelOpts): Promise<ChannelWrapper>;
-    assertChannel({ force, newChannelOptions }?: assertChannelOpts): Promise<ChannelWrapper>;
-    assertExchange(exchangeName: string): Promise<any>;
-    getQueueLength(queue: string): Promise<Replies.AssertQueue>;
+    getConnection(connectionPurpose: ConnectionPurpose): Promise<AmqpConnectionManager | null | undefined>;
+    getNewChannel({ name, onClose, options, connectionPurpose, }: newChannelOpts): Promise<ChannelWrapper>;
+    assertChannel({ force, connectionPurpose }: assertChannelOpts): Promise<ChannelWrapper>;
+    assertExchange(exchangeName: string, options?: any): Promise<any>;
+    getQueueLength(queue: string, connectionPurpose?: ConnectionPurpose): Promise<Replies.AssertQueue>;
     private deleteQueue;
-    bindQueue(queue: string, exchange: string): Promise<void>;
-    setupQueue(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
+    bindQueue(queue: string, exchange: string, connectionPurpose: ConnectionPurpose): Promise<void>;
+    setupQueue(queueName: string, connectionPurpose: ConnectionPurpose, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
     static shouldUseQuorum(queueName: string): boolean;
-    assertQueue(queueName: string, options?: Options.AssertQueue): Promise<any>;
+    assertQueue(queueName: string, connectionPurpose: ConnectionPurpose, options?: Options.AssertQueue): Promise<any>;
     private saveConsumer;
     consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any>;
     private lockRedisIfNeeded;
     private unlockRedisIfNeeded;
     private consumeFromRabbit;
     consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any>;
-    publish(exchange: string, content: any, customHeaders?: any, options?: PublishOptions): Promise<boolean>;
+    publish(exchange: string, content: any, customHeaders?: any): Promise<boolean>;
     sendToQueue(queue: string, content: any, options?: any, customHeaders?: any): Promise<boolean | undefined>;
     isConnected(): Promise<boolean>;
     gracefulShutdown(signal: string): Promise<void>;

package/dist/index.js

@@ -7,7 +7,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.sendCeleryTaskViaHttp = void 0;
 const events_1 = require("events");
 const util_1 = require("util");
-const lodash_1 = require("lodash");
 const moment_1 = __importDefault(require("moment"));
 const redis_lock_1 = __importDefault(require("redis-lock"));
 const amqp_connection_manager_1 = require("amqp-connection-manager");
@@ -118,10 +117,22 @@ class RabbitMq {
             }
         };
         this.em = new events_1.EventEmitter();
-        this.channel = null;
+        this.publishChannel = null;
         this.publishChannelSetupPromise = null;
-        this.connection = null;
-        this.creatingConnection = false;
+        this.connectionsMap = {
+            [consts_1.ConnectionPurpose.Consume]: {
+                connection: null,
+                creatingConnection: false,
+                connectionCreatedEventName: 'consumeConnectionCreated',
+                connectionFailedEventName: 'consumeConnectionFailed',
+            },
+            [consts_1.ConnectionPurpose.Publish]: {
+                connection: null,
+                creatingConnection: false,
+                connectionCreatedEventName: 'publishConnectionCreated',
+                connectionFailedEventName: 'publishConnectionFailed',
+            },
+        };
         this.exchanges = {};
         this.queues = {};
         this.queueSetupPromises = {};
@@ -143,30 +154,31 @@ class RabbitMq {
             });
         }
     }
-    async getConnection() {
+    async getConnection(connectionPurpose) {
         return new Promise(async (resolve, reject) => {
+            const { connection, creatingConnection, connectionCreatedEventName, connectionFailedEventName, } = 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);
+                this.em.once(connectionCreatedEventName, resolve);
+                this.em.once(connectionFailedEventName, reject);
                 return;
             }
-            this.creatingConnection = true;
+            this.connectionsMap[connectionPurpose].creatingConnection = true;
             let isResolved = false;
             // It is import to use it as a function and not as a variable
             // because of k8s changes the env variables
@@ -179,29 +191,29 @@ class RabbitMq {
                 return [`amqp://${userName}:${password}@${host}?heartbeat=${HEARTBEAT}`];
             };
             const defaultUrls = findServers();
-            const connection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
+            const newConnection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
                 findServers,
             });
-            this.connection = connection;
-            this.connection.on('error', (err) => {
+            this.connectionsMap[connectionPurpose].connection = newConnection;
+            logger_1.default.info(`rabbit: created new connection ${connectionPurpose}`);
+            newConnection.on('error', (err) => {
                 logger_1.default.error('rabbit: connection error', { err });
                 if (!isResolved) {
                     isResolved = true;
                     reject(err);
-                    this.em.emit(consts_1.CONNECTION_FAILED_CONST, err);
+                    this.em.emit(connectionFailedEventName, err);
                 }
             });
-            this.connection.on('connectFailed', (err) => {
+            newConnection.on('connectFailed', (err) => {
                 this.consumersTags = [];
                 logger_1.default.error('rabbit: connection connectFailed', { err });
                 if (!isResolved) {
                     isResolved = true;
                     reject(err);
-                    this.em.emit(consts_1.CONNECTION_FAILED_CONST, err);
+                    this.em.emit(connectionFailedEventName, err);
                 }
             });
-            this.connection.on('disconnect', ({ err }) => {
-                // this.channel = null;
+            newConnection.on('disconnect', ({ err }) => {
                 this.consumersTags = [];
                 debug('rabbit: connection closed');
                 if (this.options?.disableReconnect) {
@@ -212,25 +224,27 @@ class RabbitMq {
                     logger_1.default.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
                 }
             });
-            this.connection.once('connect', async () => {
-                debug('rabbit: connection established');
-                this.creatingConnection = false;
-                this.em.emit(consts_1.CONNECTION_CREATED_CONST, connection);
+            newConnection.once('connect', async () => {
+                this.connectionsMap[connectionPurpose].creatingConnection = false;
+                this.em.emit(connectionCreatedEventName, newConnection);
                 isResolved = true;
-                resolve(connection);
+                resolve(newConnection);
             });
         });
     }
-    async getNewChannel({ name = (0, utils_1.rand)().toString(), onClose = null, options = {} } = {}) {
+    async getNewChannel({ name = (0, utils_1.rand)().toString(), onClose = null, options = {}, connectionPurpose = consts_1.ConnectionPurpose.Consume, }) {
         let connection;
         try {
-            connection = await this.getConnection();
+            connection = await this.getConnection(connectionPurpose);
         }
         catch (e) {
             logger_1.default.error(`rabbit: error on get connection for new channel ${name} `, { e });
             throw e;
         }
-        const channel = connection.createChannel({ ...options, confirm: false });
+        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);
@@ -245,18 +259,20 @@ class RabbitMq {
             throw err;
         }
     }
-    async assertChannel({ force = false, newChannelOptions = {} } = {}) {
+    async assertChannel({ force = false, connectionPurpose = consts_1.ConnectionPurpose.Consume }) {
+        debug('rabbit: start assert channel', { connectionPurpose, publishPromise: this.publishChannelSetupPromise, channel: this.publishChannel });
         if (!this.publishChannelSetupPromise) {
             this.publishChannelSetupPromise = new Promise(async (resolve, reject) => {
-                if (this.channel && !force) {
-                    return resolve(this.channel);
+                if (this.publishChannel && !force) {
+                    return resolve(this.publishChannel);
                 }
                 try {
-                    const channel = await this.getNewChannel({ options: newChannelOptions });
+                    const channel = await this.getNewChannel({ connectionPurpose });
+                    debug('rabbit: new channel got', { connectionPurpose, channel: this.publishChannel });
                     channel.on('error', (err) => {
                         logger_1.default.error('rabbit: channel error', { err });
                     });
-                    this.channel = channel;
+                    this.publishChannel = channel;
                     resolve(channel);
                 }
                 catch (e) {
@@ -266,8 +282,8 @@ class RabbitMq {
         }
         return this.publishChannelSetupPromise;
     }
-    async assertExchange(exchangeName) {
-        const channel = await this.assertChannel();
+    async assertExchange(exchangeName, options = { connectionPurpose: consts_1.ConnectionPurpose.Consume }) {
+        const channel = await this.assertChannel({ connectionPurpose: options.connectionPurpose });
         if (this.exchanges[exchangeName]) {
             delete this.assertExchangePromises[exchangeName];
             return this.exchanges[exchangeName];
@@ -279,29 +295,30 @@ class RabbitMq {
         this.exchanges[exchangeName] = await this.assertExchangePromises[exchangeName];
         return this.exchanges[exchangeName];
     }
-    async getQueueLength(queue) {
+    async getQueueLength(queue, connectionPurpose = consts_1.ConnectionPurpose.Consume) {
         RabbitMq.validateName('queue', queue);
-        const { channel } = this;
-        if (!channel) {
+        const { connection } = this.connectionsMap[connectionPurpose];
+        const { publishChannel } = this;
+        if (!publishChannel) {
             throw new Error('channel is not defined');
         }
-        debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
-        return channel?.checkQueue(queue);
+        debug('rabbit: getting queue length', { queue, connected: connection?.isConnected() });
+        return publishChannel?.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 setupQueue(queueName, options) {
+    async setupQueue(queueName, connectionPurpose, options) {
         let queue;
         const shouldUseQuorum = RabbitMq.shouldUseQuorum(queueName);
         const localeOptions = {
@@ -314,7 +331,7 @@ class RabbitMq {
             },
         };
         try {
-            const channel = await this.assertChannel();
+            const channel = await this.assertChannel({ connectionPurpose });
             debug('assertQueue->channel.addSetup', { queueName });
             await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, localeOptions));
             debug('assertQueue->channel.assertQueue', { queueName });
@@ -324,8 +341,8 @@ 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);
+                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, localeOptions));
                 debug('retrying assertQueue->channel.assertQueue', { queueName });
@@ -349,7 +366,8 @@ class RabbitMq {
         }
         return false;
     }
-    async assertQueue(queueName, options) {
+    async assertQueue(queueName, connectionPurpose, options) {
+        debug('rabbit: start assert queue', { connectionPurpose, queueName });
         RabbitMq.validateName('queue', queueName);
         if (this.queues[queueName]) {
             delete this.queueSetupPromises[queueName];
@@ -358,7 +376,8 @@ class RabbitMq {
         if (this.queueSetupPromises[queueName]) {
             return this.queueSetupPromises[queueName];
         }
-        this.queueSetupPromises[queueName] = this.setupQueue(queueName, options);
+        this.queueSetupPromises[queueName] = this.setupQueue(queueName, connectionPurpose, options);
+        debug('rabbit: done assert queue', { connectionPurpose, queueName });
         return this.queueSetupPromises[queueName];
     }
     saveConsumer(queue, callback, options) {
@@ -401,13 +420,10 @@ class RabbitMq {
             }
             logger_1.default.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
         }
-        const channel = await this.getNewChannel({});
+        const channel = await this.getNewChannel({ connectionPurpose: consts_1.ConnectionPurpose.Consume });
         return channel.addSetup(async (confirmChannel) => {
-            const q = await this.assertQueue(queue, optionsWithDefaults);
+            const q = await this.assertQueue(queue, consts_1.ConnectionPurpose.Consume, optionsWithDefaults);
             await confirmChannel.prefetch(limit, false);
-            const channelConsumerOptions = optionsWithDefaults.channelConsumeOptions
-                ? (0, lodash_1.merge)(types_1.CONSUMER_DEFAULT_OPTIONS, optionsWithDefaults.channelConsumeOptions)
-                : types_1.CONSUMER_DEFAULT_OPTIONS;
             const { consumerTag } = await confirmChannel.consume(queue, async (msg) => {
                 if (!msg) {
                     return null;
@@ -472,7 +488,7 @@ class RabbitMq {
                 catch (e) {
                     await localNack(msg);
                 }
-            }, channelConsumerOptions);
+            }, types_1.CONSUMER_DEFAULT_OPTIONS);
             if (!consumerTag) {
                 logger_1.default.error(`rabbit: failed to consume from queue ${queue}`);
             }
@@ -488,29 +504,30 @@ class RabbitMq {
         RabbitMq.validateName('queue', queue);
         const { limit, deadMessageTtl } = optionsWithDefaults;
         await this.saveConsumer(queue, callback, options);
-        const channel = await this.getNewChannel({ name: `consume-exchange-${exchange}-queue-${queue}` });
+        const channel = await this.getNewChannel({ name: `consume - exchange - ${exchange} -queue - ${queue}` });
         return channel.addSetup(async (c) => {
             const assertExchange = await (0, utils_1.assertExchangeFanout)(c, exchange);
             await c.assertQueue(queue);
             this.exchanges[exchange] = assertExchange;
-            await c.prefetch(limit, false);
+            await c.prefetch(limit, true);
             return Promise.all([
                 c.bindQueue(queue, exchange, ''),
                 this.consume(queue, callback, options),
             ]);
         });
     }
-    async publish(exchange, content, customHeaders, options) {
+    async publish(exchange, content, customHeaders) {
+        debug('rabbit: start publish msg');
         return (0, utils_1.wrapSetImmediate)(async () => {
             RabbitMq.validateName('exchange', exchange);
-            const channel = await this.assertChannel({ newChannelOptions: options?.newChannelOptions });
-            await this.assertExchange(exchange);
+            const channel = await this.assertChannel({ connectionPurpose: consts_1.ConnectionPurpose.Publish });
+            await this.assertExchange(exchange, { connectionPurpose: consts_1.ConnectionPurpose.Publish });
             await channel.publish(exchange, '', Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
         });
     }
     async sendToQueue(queue, content, options, customHeaders) {
         try {
-            await this.assertChannel({ newChannelOptions: options?.newChannelOptions });
+            await this.assertChannel({ connectionPurpose: consts_1.ConnectionPurpose.Publish });
         }
         catch (e) {
             logger_1.default.error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });
@@ -518,43 +535,49 @@ class RabbitMq {
         }
         try {
             RabbitMq.validateName('queue', queue);
-            await this.assertQueue(queue, options);
+            await this.assertQueue(queue, consts_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));
+            const res = await this.publishChannel?.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();
-            logger_1.default.error(`rabbit sendToQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { e });
+            logger_1.default.error(`rabbit sendToQueue: failed to send to queue ${queue}`, { e });
             throw e;
         }
     }
     async isConnected() {
-        const connection = await this.getConnection();
-        const isConnected = connection.isConnected();
-        if (!isConnected) {
-            logger_1.default.error('rabbit: isConnected - false');
-            return false;
-        }
-        const channel = await this.assertChannel();
-        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;
+        debug('rabbit: start is connected');
+        const isEachConnectionConnected = await Promise.all(Object.entries(this.connectionsMap).map(async ([connectionPurpose, connectionData]) => {
+            const { connection } = connectionData;
+            debug('rabbit: is connected inside map', { connection, connectionPurpose });
+            const isConnected = connection?.isConnected();
+            if (!isConnected) {
+                logger_1.default.error('rabbit: isConnected - false', { connectionPurpose });
+                return false;
+            }
+            if (connectionPurpose === consts_1.ConnectionPurpose.Publish) {
+                const channel = await this.assertChannel({ connectionPurpose: 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;
+        }));
+        return isEachConnectionConnected.every((isConnected) => isConnected === true);
     }
     async gracefulShutdown(signal) {
         const tagsNumber = this.consumersTags.length;

package/dist/lib/consts.d.ts

@@ -6,8 +6,6 @@ export declare const USER_TRACING_HEADER = "x-af-user-id";
 export declare const AUTOMATION_ID_HEADER = "x-af-automation-id";
 export declare const USER_OBJECT = "userObject";
 export declare const DEFAULT_USE_CONSUME_WITH_LOCK = false;
-export declare const CONNECTION_CREATED_CONST = "connectionCreated";
-export declare const CONNECTION_FAILED_CONST = "connectionFailed";
 export declare const DEFAULT_OPTIONS: {
     limit: number;
     retries: number;
@@ -17,3 +15,7 @@ export declare const DEFAULT_OPTIONS: {
     auditContext: null;
     enableRabbitTrace: boolean;
 };
+export declare enum ConnectionPurpose {
+    Consume = "consume",
+    Publish = "publish"
+}

package/dist/lib/consts.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_OPTIONS = exports.CONNECTION_FAILED_CONST = exports.CONNECTION_CREATED_CONST = exports.DEFAULT_USE_CONSUME_WITH_LOCK = exports.USER_OBJECT = exports.AUTOMATION_ID_HEADER = exports.USER_TRACING_HEADER = exports.TRACING_HEADER = exports.RETRY_HEADER = exports.DEFAULT_LOCK_TIMEOUT = exports.DEFAULT_DEAD_TTL_TWO_DAYS = void 0;
+exports.ConnectionPurpose = exports.DEFAULT_OPTIONS = exports.DEFAULT_USE_CONSUME_WITH_LOCK = exports.USER_OBJECT = exports.AUTOMATION_ID_HEADER = exports.USER_TRACING_HEADER = exports.TRACING_HEADER = exports.RETRY_HEADER = exports.DEFAULT_LOCK_TIMEOUT = exports.DEFAULT_DEAD_TTL_TWO_DAYS = void 0;
 exports.DEFAULT_DEAD_TTL_TWO_DAYS = 60000 * 60 * 12;
 exports.DEFAULT_LOCK_TIMEOUT = 1000 * 5;
 exports.RETRY_HEADER = 'x-retry-count';
@@ -9,8 +9,6 @@ exports.USER_TRACING_HEADER = 'x-af-user-id';
 exports.AUTOMATION_ID_HEADER = 'x-af-automation-id';
 exports.USER_OBJECT = 'userObject';
 exports.DEFAULT_USE_CONSUME_WITH_LOCK = false;
-exports.CONNECTION_CREATED_CONST = 'connectionCreated';
-exports.CONNECTION_FAILED_CONST = 'connectionFailed';
 exports.DEFAULT_OPTIONS = {
     limit: 1,
     retries: 1,
@@ -20,3 +18,8 @@ exports.DEFAULT_OPTIONS = {
     auditContext: null,
     enableRabbitTrace: false,
 };
+var ConnectionPurpose;
+(function (ConnectionPurpose) {
+    ConnectionPurpose["Consume"] = "consume";
+    ConnectionPurpose["Publish"] = "publish";
+})(ConnectionPurpose = exports.ConnectionPurpose || (exports.ConnectionPurpose = {}));

package/dist/lib/types.d.ts

@@ -1,4 +1,4 @@
-import { CreateChannelOpts } from 'amqp-connection-manager';
+import { AmqpConnectionManager } from 'amqp-connection-manager';
 import { ConsumeMessage, Options, Replies } from 'amqplib';
 export interface ExchangesCache {
     [key: string]: any;
@@ -26,25 +26,25 @@ export interface ConsumeOptions {
     useConsumeWithLock?: boolean;
     auditContext?: any;
     enableRabbitTrace?: boolean;
-    channelConsumeOptions?: Options.Consume;
 }
 export type CallbackFunction = (msg: ConsumeMessage, ack: any, nack: any) => Promise<any>;
 export type newChannelOpts = {
     name?: string;
     onClose?: null | ((args: any | null) => void);
-    options?: CreateChannelOpts | undefined;
 };
 export type assertChannelOpts = {
     channelName?: string;
     force?: boolean;
-    newChannelOptions?: newChannelOpts;
 };
-export interface PublishOptions {
-    newChannelOptions?: newChannelOpts;
-}
 export type AfConsumer = {
     queue: string;
     callback: CallbackFunction;
     options: ConsumeOptions | undefined;
 };
 export declare const CONSUMER_DEFAULT_OPTIONS: Options.Consume;
+export type ConnectionData = {
+    connection: AmqpConnectionManager | null;
+    creatingConnection: boolean;
+    connectionCreatedEventName: string;
+    connectionFailedEventName: string;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "3.2.25-beta.103",
+  "version": "3.2.26-beta.0",
   "description": "",
   "main": "dist/index.js",
   "engines": {
@@ -22,7 +22,6 @@
     "amqp-connection-manager": "4.1.9",
     "amqplib": "0.10.3",
     "bluebird": "^3.7.2",
-    "lodash": "^4.17.21",
     "moment": "^2.29.1",
     "redis": "^3.1.2",
     "redis-lock": "^0.1.4"
@@ -34,7 +33,6 @@
     "@autofleet/logger": "4.0.6",
     "@types/amqplib": "0.8.2",
     "@types/jest": "^29.5.12",
-    "@types/lodash": "^4.17.12",
     "@types/node": "^20.14.11",
     "@typescript-eslint/eslint-plugin": "^4.8.1",
     "eslint": "^7.13.0",

package/src/index.ts

@@ -2,11 +2,10 @@
 
 import { EventEmitter, once } from 'events';
 import { promisify } from 'util';
-import { merge } from 'lodash';
 import moment from 'moment';
 import RedisLock from 'redis-lock';
 import {
-  AmqpConnectionManager, ChannelWrapper, connect,
+  AmqpConnectionManager, ChannelWrapper, connect, CreateChannelOpts,
 } from 'amqp-connection-manager';
 import {
   ConfirmChannel, ConsumeMessage, Options, Replies,
@@ -21,8 +20,7 @@ import getRedisInstance, { RedisConfig } from './lib/redis';
 import { assertExchangeFanout, rand, wrapSetImmediate } from './lib/utils';
 import {
   AUTOMATION_ID_HEADER,
-  CONNECTION_CREATED_CONST,
-  CONNECTION_FAILED_CONST,
+  ConnectionPurpose,
   DEFAULT_LOCK_TIMEOUT,
   DEFAULT_OPTIONS,
   RETRY_HEADER,
@@ -41,16 +39,13 @@ import {
   CONSUMER_DEFAULT_OPTIONS,
   QueueSetupPromisesDictionary,
   AssertExchangePromisesDictionary,
-  assertChannelOpts,
-  newChannelOpts,
-  PublishOptions,
+  ConnectionData,
 } from './lib/types';
 
 // const debug = nodeDebug('af-rabbitmq')
 const debug = logger.debug.bind(logger);
 
 const PUBLISH_TIMEOUT = 1000 * 10;
-
 export interface IAfRabbitMq {
   ack: any;
   nack: any;
@@ -86,6 +81,19 @@ export interface AfRabbitOptions {
   rabbitHost?: string;
 }
 
+type newChannelOpts = {
+  name?: string;
+  onClose?: null | ((args: any | null) => void);
+  options?: CreateChannelOpts | undefined;
+  connectionPurpose?: ConnectionPurpose,
+};
+
+type assertChannelOpts = {
+  channelName?: string;
+  force?: boolean;
+  connectionPurpose?: ConnectionPurpose;
+}
+
 type AfConsumer = {
   queue: string;
   callback: CallbackFunction;
@@ -95,7 +103,7 @@ type AfConsumer = {
 const HEARTBEAT = '60';
 
 class RabbitMq implements IAfRabbitMq {
-  static parseMsg(msg: any) : any {
+  static parseMsg(msg: any): any {
     let { content } = msg;
     content = content.toString();
 
@@ -136,18 +144,19 @@ class RabbitMq implements IAfRabbitMq {
 
   RECONNECT_MSG = 'rabbit: connection disconnect - reconnecting';
 
-  channel: ChannelWrapper | null;
+  publishChannel: ChannelWrapper | null;
 
   publishChannelSetupPromise: Promise<ChannelWrapper> | null;
 
-  blockReconnect: boolean | null | undefined
+  blockReconnect: boolean | null | undefined;
 
-  connection: AmqpConnectionManager | null | undefined
+  connectionsMap: {
+    [ConnectionPurpose.Consume]: ConnectionData;
+    [ConnectionPurpose.Publish]: ConnectionData;
+  };
 
   em: EventEmitter;
 
-  creatingConnection: boolean;
-
   exchanges: ExchangesCache;
 
   queues: QueuesCache;
@@ -169,10 +178,22 @@ class RabbitMq implements IAfRabbitMq {
 
   constructor(options?: AfRabbitOptions, redisConfig?: RedisConfig) {
     this.em = new EventEmitter();
-    this.channel = null;
+    this.publishChannel = null;
     this.publishChannelSetupPromise = null;
-    this.connection = null;
-    this.creatingConnection = false;
+    this.connectionsMap = {
+      [ConnectionPurpose.Consume]: {
+        connection: null,
+        creatingConnection: false,
+        connectionCreatedEventName: 'consumeConnectionCreated',
+        connectionFailedEventName: 'consumeConnectionFailed',
+      },
+      [ConnectionPurpose.Publish]: {
+        connection: null,
+        creatingConnection: false,
+        connectionCreatedEventName: 'publishConnectionCreated',
+        connectionFailedEventName: 'publishConnectionFailed',
+      },
+    };
     this.exchanges = {};
     this.queues = {};
     this.queueSetupPromises = {};
@@ -209,7 +230,7 @@ class RabbitMq implements IAfRabbitMq {
     return false;
   }
 
-  public ack = (channel: ConfirmChannel, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp = false, releaseLock = null) => async (userMsg: ConsumeMessage) : Promise<any> => {
+  public ack = (channel: ConfirmChannel, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp = false, releaseLock = null) => async (userMsg: ConsumeMessage): Promise<any> => {
     if (msg) {
       debug('rabbit acking message', { deliveryTag: msg.fields.deliveryTag });
       await channel.ack(msg);
@@ -235,8 +256,8 @@ class RabbitMq implements IAfRabbitMq {
     userMsg: ConsumeMessageOrNull,
     {
       skipRetry = false,
-    }: NackOptions = { },
-  ) : Promise<any> => {
+    }: NackOptions = {},
+  ): Promise<any> => {
     await this.unlockRedisIfNeeded(releaseLock);
     if (channel && msg) {
       if (
@@ -270,30 +291,36 @@ class RabbitMq implements IAfRabbitMq {
     }
   }
 
-  async getConnection() {
-    return new Promise<AmqpConnectionManager>(async (resolve, reject) => {
+  async getConnection(connectionPurpose: ConnectionPurpose) {
+    return new Promise<AmqpConnectionManager | undefined | null>(async (resolve, reject) => {
+      const {
+        connection,
+        creatingConnection,
+        connectionCreatedEventName,
+        connectionFailedEventName,
+      } = 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(CONNECTION_CREATED_CONST, resolve);
-        this.em.once(CONNECTION_FAILED_CONST, reject);
+        this.em.once(connectionCreatedEventName, resolve);
+        this.em.once(connectionFailedEventName, reject);
         return;
       }
-      this.creatingConnection = true;
+      this.connectionsMap[connectionPurpose].creatingConnection = true;
       let isResolved = false;
 
       // It is import to use it as a function and not as a variable
@@ -310,32 +337,33 @@ class RabbitMq implements IAfRabbitMq {
       };
 
       const defaultUrls = findServers();
-      const connection: AmqpConnectionManager = await connect(defaultUrls, {
+      const newConnection: AmqpConnectionManager = await connect(defaultUrls, {
         findServers,
       });
 
-      this.connection = connection;
-      this.connection.on('error', (err) => {
+      this.connectionsMap[connectionPurpose].connection = newConnection;
+      logger.info(`rabbit: created new connection ${connectionPurpose}`);
+
+      newConnection.on('error', (err) => {
         logger.error('rabbit: connection error', { err });
         if (!isResolved) {
           isResolved = true;
           reject(err);
-          this.em.emit(CONNECTION_FAILED_CONST, err);
+          this.em.emit(connectionFailedEventName, err);
         }
       });
 
-      this.connection.on('connectFailed', (err) => {
+      newConnection.on('connectFailed', (err) => {
         this.consumersTags = [];
         logger.error('rabbit: connection connectFailed', { err });
         if (!isResolved) {
           isResolved = true;
           reject(err);
-          this.em.emit(CONNECTION_FAILED_CONST, err);
+          this.em.emit(connectionFailedEventName, err);
         }
       });
 
-      this.connection.on('disconnect', ({ err }) => {
-        // this.channel = null;
+      newConnection.on('disconnect', ({ err }) => {
         this.consumersTags = [];
         debug('rabbit: connection closed');
         if (this.options?.disableReconnect) {
@@ -345,26 +373,29 @@ class RabbitMq implements IAfRabbitMq {
           logger.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
         }
       });
-
-      this.connection.once('connect', async () => {
-        debug('rabbit: connection established');
-        this.creatingConnection = false;
-        this.em.emit(CONNECTION_CREATED_CONST, connection);
+      newConnection.once('connect', async () => {
+        this.connectionsMap[connectionPurpose].creatingConnection = false;
+        this.em.emit(connectionCreatedEventName, newConnection);
         isResolved = true;
-        resolve(connection);
+        resolve(newConnection);
       });
     });
   }
 
-  async getNewChannel({ name = rand().toString(), onClose = null, options = {} }: newChannelOpts = {}) {
-    let connection!: AmqpConnectionManager;
+  async getNewChannel({
+    name = rand().toString(), onClose = null, options = {}, connectionPurpose = ConnectionPurpose.Consume,
+  }: newChannelOpts): Promise<ChannelWrapper> {
+    let connection!: AmqpConnectionManager | undefined | null;
     try {
-      connection = await this.getConnection();
+      connection = await this.getConnection(connectionPurpose);
     } catch (e) {
       logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
       throw e;
     }
-    const channel = connection.createChannel({ ...options, confirm: false });
+    if (!connection) {
+      throw new Error(`rabbit: couldnt get connection for new channel ${name}`);
+    }
+    const channel = connection.createChannel({ ...options });
     once(channel, 'close').then((args) => {
       logger.error(`rabbit: channel ${name} closed`);
       onClose?.(args);
@@ -379,19 +410,21 @@ class RabbitMq implements IAfRabbitMq {
     }
   }
 
-  async assertChannel({ force = false, newChannelOptions = {} }: assertChannelOpts = {}): Promise<ChannelWrapper> {
+  async assertChannel({ force = false, connectionPurpose = ConnectionPurpose.Consume }: assertChannelOpts): Promise<ChannelWrapper> {
+    debug('rabbit: start assert channel', { connectionPurpose, publishPromise: this.publishChannelSetupPromise, channel: this.publishChannel });
     if (!this.publishChannelSetupPromise) {
       this.publishChannelSetupPromise = new Promise<ChannelWrapper>(async (resolve, reject) => {
-        if (this.channel && !force) {
-          return resolve(this.channel);
+        if (this.publishChannel && !force) {
+          return resolve(this.publishChannel);
         }
 
         try {
-          const channel = await this.getNewChannel({ options: newChannelOptions });
+          const channel = await this.getNewChannel({ connectionPurpose });
+          debug('rabbit: new channel got', { connectionPurpose, channel: this.publishChannel });
           channel.on('error', (err) => {
             logger.error('rabbit: channel error', { err });
           });
-          this.channel = channel;
+          this.publishChannel = channel;
           resolve(channel);
         } catch (e) {
           reject(e);
@@ -401,9 +434,8 @@ class RabbitMq implements IAfRabbitMq {
     return this.publishChannelSetupPromise;
   }
 
-  async assertExchange(exchangeName: string) {
-    const channel: ChannelWrapper = await this.assertChannel();
-
+  async assertExchange(exchangeName: string, options: any = { connectionPurpose: ConnectionPurpose.Consume }) {
+    const channel: ChannelWrapper = await this.assertChannel({ connectionPurpose: options.connectionPurpose });
     if (this.exchanges[exchangeName]) {
       delete this.assertExchangePromises[exchangeName];
       return this.exchanges[exchangeName];
@@ -418,32 +450,33 @@ class RabbitMq implements IAfRabbitMq {
     return this.exchanges[exchangeName];
   }
 
-  async getQueueLength(queue: string) {
+  async getQueueLength(queue: string, connectionPurpose: ConnectionPurpose = ConnectionPurpose.Consume): Promise<Replies.AssertQueue> {
     RabbitMq.validateName('queue', queue);
-    const { channel } = this;
-    if (!channel) {
+    const { connection } = this.connectionsMap[connectionPurpose];
+    const { publishChannel } = this;
+    if (!publishChannel) {
       throw new Error('channel is not defined');
     }
-    debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
-    return channel?.checkQueue(queue);
+    debug('rabbit: getting queue length', { queue, connected: connection?.isConnected() });
+    return publishChannel?.checkQueue(queue);
   }
 
-  private async deleteQueue(queue: string) {
+  private async deleteQueue(queue: string, connectionPurpose: ConnectionPurpose) {
     RabbitMq.validateName('queue', queue);
-    const channel: ChannelWrapper = await this.assertChannel();
+    const channel: ChannelWrapper = await this.assertChannel({ connectionPurpose });
     logger.info('rabbit: deleting queue', { queue });
     const deleteQueueRes = await channel.deleteQueue(queue);
     debug('queue deleted', deleteQueueRes);
     return deleteQueueRes;
   }
 
-  async bindQueue(queue: string, exchange: string) {
-    const channel: ChannelWrapper = await this.assertChannel();
+  async bindQueue(queue: string, exchange: string, connectionPurpose: ConnectionPurpose) {
+    const channel: ChannelWrapper = await this.assertChannel({ connectionPurpose });
     await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.bindQueue(queue, exchange, ''));
     return channel.bindQueue(queue, exchange, '');
   }
 
-  async setupQueue(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue> {
+  async setupQueue(queueName: string, connectionPurpose: ConnectionPurpose, options?: Options.AssertQueue): Promise<Replies.AssertQueue> {
     let queue: Replies.AssertQueue;
     const shouldUseQuorum = RabbitMq.shouldUseQuorum(queueName);
     const localeOptions = {
@@ -456,7 +489,7 @@ class RabbitMq implements IAfRabbitMq {
       },
     };
     try {
-      const channel: ChannelWrapper = await this.assertChannel();
+      const channel: ChannelWrapper = await this.assertChannel({ connectionPurpose });
       debug('assertQueue->channel.addSetup', { queueName });
       await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, localeOptions));
       debug('assertQueue->channel.assertQueue', { queueName });
@@ -465,8 +498,8 @@ class RabbitMq implements IAfRabbitMq {
       logger.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);
+        const channel = await this.assertChannel({ force: true, connectionPurpose });
+        await this.deleteQueue(queueName, connectionPurpose);
 
         debug('retrying assertQueue->channel.addSetup', { queueName });
         await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, localeOptions));
@@ -496,7 +529,8 @@ class RabbitMq implements IAfRabbitMq {
     return false;
   }
 
-  async assertQueue(queueName: string, options?: Options.AssertQueue): Promise<any> {
+  async assertQueue(queueName: string, connectionPurpose: ConnectionPurpose, options?: Options.AssertQueue) {
+    debug('rabbit: start assert queue', { connectionPurpose, queueName });
     RabbitMq.validateName('queue', queueName);
     if (this.queues[queueName]) {
       delete this.queueSetupPromises[queueName];
@@ -507,12 +541,13 @@ class RabbitMq implements IAfRabbitMq {
       return this.queueSetupPromises[queueName];
     }
 
-    this.queueSetupPromises[queueName] = this.setupQueue(queueName, options);
+    this.queueSetupPromises[queueName] = this.setupQueue(queueName, connectionPurpose, options);
+    debug('rabbit: done assert queue', { connectionPurpose, queueName });
     return this.queueSetupPromises[queueName];
   }
 
   private saveConsumer(queue: string, callback: CallbackFunction, options: ConsumeOptions | undefined) {
-    const isConsumerExist :boolean = this.consumers.some((consumer) => consumer.queue === queue);
+    const isConsumerExist: boolean = this.consumers.some((consumer) => consumer.queue === queue);
     if (!isConsumerExist) {
       logger.info(`rabbit: consumer: ${queue} saved in consumer array`);
       this.consumers.push({
@@ -561,14 +596,10 @@ class RabbitMq implements IAfRabbitMq {
       }
       logger.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
     }
-    const channel = await this.getNewChannel({});
+    const channel = await this.getNewChannel({ connectionPurpose: ConnectionPurpose.Consume });
     return channel.addSetup(async (confirmChannel: ConfirmChannel) => {
-      const q = await this.assertQueue(queue, optionsWithDefaults);
+      const q = await this.assertQueue(queue, ConnectionPurpose.Consume, optionsWithDefaults);
       await confirmChannel.prefetch(limit, false);
-      const channelConsumerOptions = optionsWithDefaults.channelConsumeOptions
-        ? merge(CONSUMER_DEFAULT_OPTIONS, optionsWithDefaults.channelConsumeOptions)
-        : CONSUMER_DEFAULT_OPTIONS;
-
       const { consumerTag } = await confirmChannel.consume(
         queue,
         async (msg: ConsumeMessageOrNull) => {
@@ -644,8 +675,7 @@ class RabbitMq implements IAfRabbitMq {
           } catch (e) {
             await localNack(msg);
           }
-        },
-        channelConsumerOptions,
+        }, CONSUMER_DEFAULT_OPTIONS,
       );
       if (!consumerTag) {
         logger.error(`rabbit: failed to consume from queue ${queue}`);
@@ -656,19 +686,19 @@ class RabbitMq implements IAfRabbitMq {
     });
   }
 
-  async consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions) : Promise<any> {
+  async consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
     const optionsWithDefaults = { ...DEFAULT_OPTIONS, ...options };
     RabbitMq.validateName('exchange', exchange);
     RabbitMq.validateName('queue', queue);
     const { limit, deadMessageTtl } = optionsWithDefaults;
     await this.saveConsumer(queue, callback, options);
-    const channel: ChannelWrapper = await this.getNewChannel({ name: `consume-exchange-${exchange}-queue-${queue}` });
+    const channel: ChannelWrapper = await this.getNewChannel({ name: `consume - exchange - ${exchange} -queue - ${queue}` });
 
     return channel.addSetup(async (c: ConfirmChannel) => {
       const assertExchange = await assertExchangeFanout(c, exchange);
       await c.assertQueue(queue);
       this.exchanges[exchange] = assertExchange;
-      await c.prefetch(limit, false);
+      await c.prefetch(limit, true);
       return Promise.all([
         c.bindQueue(queue, exchange, ''),
         this.consume(
@@ -680,11 +710,12 @@ class RabbitMq implements IAfRabbitMq {
     });
   }
 
-  async publish(exchange: string, content: any, customHeaders?: any, options?: PublishOptions): Promise<boolean> {
+  async publish(exchange: string, content: any, customHeaders?: any): Promise<boolean> {
+    debug('rabbit: start publish msg');
     return wrapSetImmediate(async () => {
       RabbitMq.validateName('exchange', exchange);
-      const channel: ChannelWrapper = await this.assertChannel({ newChannelOptions: options?.newChannelOptions });
-      await this.assertExchange(exchange);
+      const channel: ChannelWrapper = await this.assertChannel({ connectionPurpose: ConnectionPurpose.Publish });
+      await this.assertExchange(exchange, { connectionPurpose: ConnectionPurpose.Publish });
       await channel.publish(exchange, '',
         Buffer.from(JSON.stringify(content)),
         RabbitMq.getPublishOptions(customHeaders));
@@ -698,7 +729,7 @@ class RabbitMq implements IAfRabbitMq {
     customHeaders?: any,
   ): Promise<boolean | undefined> {
     try {
-      await this.assertChannel({ newChannelOptions: options?.newChannelOptions });
+      await this.assertChannel({ connectionPurpose: ConnectionPurpose.Publish });
     } catch (e) {
       logger.error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });
       throw e;
@@ -706,47 +737,55 @@ class RabbitMq implements IAfRabbitMq {
 
     try {
       RabbitMq.validateName('queue', queue);
-      await this.assertQueue(queue, options);
+      await this.assertQueue(queue, ConnectionPurpose.Publish, options);
     } catch (e) {
       logger.error(`rabbit sendToQueue: failed to assert queue ${queue}`, { e });
       throw e;
     }
 
     try {
-      const res = await this.channel?.sendToQueue(queue,
+      const res = await this.publishChannel?.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();
-      logger.error(`rabbit sendToQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { e });
+      logger.error(`rabbit sendToQueue: failed to send to queue ${queue}`, { e });
       throw e;
     }
   }
 
-  async isConnected() : Promise<boolean> {
-    const connection = await this.getConnection();
-    const isConnected = connection.isConnected();
-    if (!isConnected) {
-      logger.error('rabbit: isConnected - false');
-      return false;
-    }
-    const channel: any = await this.assertChannel();
-    try {
-      await Promise.all([
-        channel.waitForConnect(),
-        ...this.consumers.map((c: AfConsumer) => channel.checkQueue(c.queue)),
-      ]);
-    } catch (e) {
-      logger.error('rabbit: isConnected - false');
-      return false;
-    }
-    logger.info('rabbit: isConnected - true');
-    return true;
+  async isConnected(): Promise<boolean> {
+    debug('rabbit: start is connected');
+    const isEachConnectionConnected = await Promise.all(
+      Object.entries(this.connectionsMap).map(async ([connectionPurpose, connectionData]) => {
+        const { connection } = connectionData;
+        debug('rabbit: is connected inside map', { connection, connectionPurpose });
+        const isConnected = connection?.isConnected();
+        if (!isConnected) {
+          logger.error('rabbit: isConnected - false', { connectionPurpose });
+          return false;
+        }
+        if (connectionPurpose === ConnectionPurpose.Publish) {
+          const channel: any = await this.assertChannel({ connectionPurpose: connectionPurpose as ConnectionPurpose });
+          try {
+            await Promise.all([
+              channel.waitForConnect(),
+              ...this.consumers.map((c: AfConsumer) => channel.checkQueue(c.queue)),
+            ]);
+          } catch (e) {
+            logger.error('rabbit: isConnected - false');
+            return false;
+          }
+        }
+        logger.info('rabbit: isConnected - true');
+        return true;
+      }),
+    );
+    return isEachConnectionConnected.every((isConnected) => isConnected === true);
   }
 
-  async gracefulShutdown(signal: string) : Promise<void> {
+  async gracefulShutdown(signal: string): Promise<void> {
     const tagsNumber = this.consumersTags.length;
     logger.info(`rabbit: [gracefully-shutdown] received ${signal}! canceling #${tagsNumber} tags...`);
     const cancelTagPromises = this.consumersTags.map(([channel, tag]) => channel.cancel(tag));

package/src/lib/consts.ts

@@ -6,8 +6,6 @@ export const USER_TRACING_HEADER = 'x-af-user-id';
 export const AUTOMATION_ID_HEADER = 'x-af-automation-id';
 export const USER_OBJECT = 'userObject';
 export const DEFAULT_USE_CONSUME_WITH_LOCK = false;
-export const CONNECTION_CREATED_CONST = 'connectionCreated';
-export const CONNECTION_FAILED_CONST = 'connectionFailed';
 export const DEFAULT_OPTIONS = {
   limit: 1,
   retries: 1,
@@ -17,3 +15,8 @@ export const DEFAULT_OPTIONS = {
   auditContext: null,
   enableRabbitTrace: false,
 };
+
+export enum ConnectionPurpose {
+  Consume = 'consume',
+  Publish = 'publish',
+}

package/src/lib/types.ts

@@ -1,4 +1,4 @@
-import { CreateChannelOpts } from 'amqp-connection-manager';
+import { AmqpConnectionManager } from 'amqp-connection-manager';
 import { ConsumeMessage, Options, Replies } from 'amqplib';
 
 export interface ExchangesCache {
@@ -32,7 +32,6 @@ export interface ConsumeOptions {
   useConsumeWithLock?: boolean;
   auditContext?: any;
   enableRabbitTrace?: boolean;
-  channelConsumeOptions?: Options.Consume;
 }
 
 export type CallbackFunction = (msg: ConsumeMessage, ack: any, nack: any) => Promise<any>
@@ -40,18 +39,11 @@ export type CallbackFunction = (msg: ConsumeMessage, ack: any, nack: any) => Pro
 export type newChannelOpts = {
   name?: string;
   onClose?: null | ((args: any | null) => void);
-  options?: CreateChannelOpts | undefined;
 };
 export type assertChannelOpts = {
   channelName?: string;
   force?: boolean;
-  newChannelOptions?: newChannelOpts;
 }
-
-export interface PublishOptions {
-  newChannelOptions?: newChannelOpts;
-}
-
 export type AfConsumer = {
   queue: string;
   callback: CallbackFunction;
@@ -68,3 +60,10 @@ export const CONSUMER_DEFAULT_OPTIONS: Options.Consume = {
     [HA_PROMOTE_ON_SHUTDOWN]: 'always',
   },
 };
+
+export type ConnectionData = {
+  connection: AmqpConnectionManager | null;
+  creatingConnection: boolean;
+  connectionCreatedEventName: string;
+  connectionFailedEventName: string;
+};