@autofleet/rabbit 3.2.26-beta.202 → 3.2.26-beta.4

package/dist/index.d.ts

@@ -1,10 +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 { ConnectionPurpose } from './lib/consts';
-import { CallbackFunction, ConsumeMessageOrNull, ConsumeOptions, CustomMessageHeaders, QueuesCache, RedisLockType, ExchangesCache, QueueSetupPromisesDictionary, AssertExchangePromisesDictionary, ConnectionData, assertChannelOpts, newChannelOpts, PublishOptions } from './lib/types';
+import { CallbackFunction, ConsumeMessageOrNull, ConsumeOptions, CustomMessageHeaders, QueuesCache, RedisLockType, ExchangesCache, QueueSetupPromisesDictionary, AssertExchangePromisesDictionary, ConnectionData } from './lib/types';
 export interface IAfRabbitMq {
     ack: any;
     nack: any;
@@ -34,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;
@@ -73,21 +84,21 @@ declare class RabbitMq implements IAfRabbitMq {
     nack: (channel: ConfirmChannel, queue: string, options: any, deadQueueOptions: Options.AssertQueue, msg: ConsumeMessageOrNull, releaseLock: any) => (userMsg: ConsumeMessageOrNull, { skipRetry, }?: NackOptions) => Promise<any>;
     getConnection(connectionPurpose: ConnectionPurpose): Promise<AmqpConnectionManager | null | undefined>;
     getNewChannel({ name, onClose, options, connectionPurpose, }: newChannelOpts): Promise<ChannelWrapper>;
-    assertChannel({ force, connectionPurpose, newChannelOptions }: assertChannelOpts): 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, connectionPurpose: ConnectionPurpose, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
+    setupQueue(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
     static shouldUseQuorum(queueName: string): boolean;
-    assertQueue(queueName: string, connectionPurpose: ConnectionPurpose, options?: Options.AssertQueue): Promise<any>;
+    assertQueue(queueName: string, 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");
@@ -132,7 +131,6 @@ class RabbitMq {
                 creatingConnection: false,
                 connectionCreatedEventName: 'publishConnectionCreated',
                 connectionFailedEventName: 'publishConnectionFailed',
-                doesChannelInitialize: false,
             },
         };
         this.exchanges = {};
@@ -246,7 +244,7 @@ class RabbitMq {
         if (!connection) {
             throw new Error(`rabbit: couldnt get connection for new channel ${name}`);
         }
-        const channel = connection.createChannel({ ...options, confirm: false });
+        const channel = connection.createChannel({ ...options });
         (0, events_1.once)(channel, 'close').then((args) => {
             logger_1.default.error(`rabbit: channel ${name} closed`);
             onClose?.(args);
@@ -261,22 +259,21 @@ class RabbitMq {
             throw err;
         }
     }
-    async assertChannel({ force = false, connectionPurpose = consts_1.ConnectionPurpose.Consume, 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.publishChannel && connectionPurpose === consts_1.ConnectionPurpose.Publish)) {
+        if (!this.publishChannelSetupPromise) {
             this.publishChannelSetupPromise = new Promise(async (resolve, reject) => {
                 if (this.publishChannel && !force) {
                     return resolve(this.publishChannel);
                 }
                 try {
-                    const channel = await this.getNewChannel({ connectionPurpose, 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 });
                     });
                     if (connectionPurpose === consts_1.ConnectionPurpose.Publish) {
                         this.publishChannel = channel;
-                        this.connectionsMap[connectionPurpose].doesChannelInitialize = true;
                     }
                     resolve(channel);
                 }
@@ -323,8 +320,9 @@ class RabbitMq {
         await channel.addSetup((setupChannel) => setupChannel.bindQueue(queue, exchange, ''));
         return channel.bindQueue(queue, exchange, '');
     }
-    async setupQueue(queueName, connectionPurpose, options) {
+    async setupQueue(queueName, options) {
         let queue;
+        const connectionPurpose = consts_1.ConnectionPurpose.Publish;
         const shouldUseQuorum = RabbitMq.shouldUseQuorum(queueName);
         const localeOptions = {
             ...options,
@@ -371,8 +369,8 @@ class RabbitMq {
         }
         return false;
     }
-    async assertQueue(queueName, connectionPurpose, options) {
-        debug('rabbit: start assert queue', { connectionPurpose, queueName });
+    async assertQueue(queueName, options) {
+        debug('rabbit: start assert queue', { queueName });
         RabbitMq.validateName('queue', queueName);
         if (this.queues[queueName]) {
             delete this.queueSetupPromises[queueName];
@@ -381,8 +379,8 @@ class RabbitMq {
         if (this.queueSetupPromises[queueName]) {
             return this.queueSetupPromises[queueName];
         }
-        this.queueSetupPromises[queueName] = this.setupQueue(queueName, connectionPurpose, options);
-        debug('rabbit: done assert queue', { connectionPurpose, queueName });
+        this.queueSetupPromises[queueName] = this.setupQueue(queueName, options);
+        debug('rabbit: done assert queue', { queueName });
         return this.queueSetupPromises[queueName];
     }
     saveConsumer(queue, callback, options) {
@@ -427,11 +425,8 @@ class RabbitMq {
         }
         const channel = await this.getNewChannel({ connectionPurpose: consts_1.ConnectionPurpose.Consume });
         return channel.addSetup(async (confirmChannel) => {
-            const q = await this.assertQueue(queue, consts_1.ConnectionPurpose.Consume, optionsWithDefaults);
+            const q = await this.assertQueue(queue, 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;
@@ -496,7 +491,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}`);
             }
@@ -524,24 +519,18 @@ class RabbitMq {
             ]);
         });
     }
-    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({
-                connectionPurpose: consts_1.ConnectionPurpose.Publish,
-                newChannelOptions: options?.newChannelOptions,
-            });
+            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({
-                connectionPurpose: consts_1.ConnectionPurpose.Publish,
-                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 });
@@ -549,7 +538,7 @@ class RabbitMq {
         }
         try {
             RabbitMq.validateName('queue', queue);
-            await this.assertQueue(queue, consts_1.ConnectionPurpose.Publish, options);
+            await this.assertQueue(queue, options);
         }
         catch (e) {
             logger_1.default.error(`rabbit sendToQueue: failed to assert queue ${queue}`, { e });
@@ -565,19 +554,29 @@ class RabbitMq {
             throw e;
         }
     }
+    //  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() {
         debug('rabbit: start is connected');
         const isEachConnectionConnected = await Promise.all(Object.entries(this.connectionsMap).map(async ([connectionPurpose, connectionData]) => {
-            const { connection, doesChannelInitialize } = connectionData;
-            if (connectionPurpose === consts_1.ConnectionPurpose.Consume
-                || (connectionPurpose === consts_1.ConnectionPurpose.Publish
-                    && doesChannelInitialize)) {
-                debug('rabbit: is connected inside map', { connection, connectionPurpose });
-                const isConnected = connection?.isConnected();
-                if (!isConnected) {
-                    logger_1.default.error('rabbit: isConnected - false', { connectionPurpose });
-                    return false;
-                }
+            const { connection } = connectionData;
+            if (connectionPurpose === consts_1.ConnectionPurpose.Publish && connection) {
                 const channel = await this.assertChannel({ connectionPurpose: connectionPurpose });
                 try {
                     await Promise.all([
@@ -590,7 +589,14 @@ class RabbitMq {
                     return false;
                 }
             }
-            logger_1.default.info('rabbit: isConnected - true');
+            if (connection) {
+                const isConnected = connection?.isConnected();
+                if (!isConnected) {
+                    logger_1.default.error('rabbit: isConnected - false', { connectionPurpose });
+                    return false;
+                }
+                logger_1.default.info('rabbit: isConnected - true', { connectionPurpose });
+            }
             return true;
         }));
         return isEachConnectionConnected.every((isConnected) => isConnected === true);

package/dist/lib/types.d.ts

@@ -1,6 +1,5 @@
-import { AmqpConnectionManager, CreateChannelOpts } from 'amqp-connection-manager';
+import { AmqpConnectionManager } from 'amqp-connection-manager';
 import { ConsumeMessage, Options, Replies } from 'amqplib';
-import { ConnectionPurpose } from './consts';
 export interface ExchangesCache {
     [key: string]: any;
 }
@@ -27,34 +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;
-    connectionPurpose?: ConnectionPurpose;
 };
 export type assertChannelOpts = {
     channelName?: string;
     force?: boolean;
-    newChannelOptions?: newChannelOpts;
-    connectionPurpose?: ConnectionPurpose;
 };
 export type AfConsumer = {
     queue: string;
     callback: CallbackFunction;
     options: ConsumeOptions | undefined;
 };
-export interface PublishOptions {
-    newChannelOptions?: newChannelOpts;
-}
 export declare const CONSUMER_DEFAULT_OPTIONS: Options.Consume;
 export type ConnectionData = {
     connection: AmqpConnectionManager | null;
     creatingConnection: boolean;
     connectionCreatedEventName: string;
     connectionFailedEventName: string;
-    doesChannelInitialize?: boolean;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "3.2.26-beta.202",
+  "version": "3.2.26-beta.4",
   "description": "",
   "main": "dist/index.js",
   "engines": {
@@ -19,11 +19,9 @@
   },
   "dependencies": {
     "@autofleet/zehut": "^3.1.2",
-    "@types/lodash": "^4.17.16",
     "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"

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,
@@ -41,9 +40,6 @@ import {
   QueueSetupPromisesDictionary,
   AssertExchangePromisesDictionary,
   ConnectionData,
-  assertChannelOpts,
-  newChannelOpts,
-  PublishOptions,
 } from './lib/types';
 
 // const debug = nodeDebug('af-rabbitmq')
@@ -85,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;
@@ -183,7 +192,6 @@ class RabbitMq implements IAfRabbitMq {
         creatingConnection: false,
         connectionCreatedEventName: 'publishConnectionCreated',
         connectionFailedEventName: 'publishConnectionFailed',
-        doesChannelInitialize: false,
       },
     };
     this.exchanges = {};
@@ -387,7 +395,7 @@ class RabbitMq implements IAfRabbitMq {
     if (!connection) {
       throw new Error(`rabbit: couldnt get connection for new channel ${name}`);
     }
-    const channel = connection.createChannel({ ...options, confirm: false });
+    const channel = connection.createChannel({ ...options });
     once(channel, 'close').then((args) => {
       logger.error(`rabbit: channel ${name} closed`);
       onClose?.(args);
@@ -402,23 +410,22 @@ class RabbitMq implements IAfRabbitMq {
     }
   }
 
-  async assertChannel({ force = false, connectionPurpose = ConnectionPurpose.Consume, 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.publishChannel && connectionPurpose === ConnectionPurpose.Publish)) {
+    if (!this.publishChannelSetupPromise) {
       this.publishChannelSetupPromise = new Promise<ChannelWrapper>(async (resolve, reject) => {
         if (this.publishChannel && !force) {
           return resolve(this.publishChannel);
         }
 
         try {
-          const channel = await this.getNewChannel({ connectionPurpose, 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 });
           });
           if (connectionPurpose === ConnectionPurpose.Publish) {
             this.publishChannel = channel;
-            this.connectionsMap[connectionPurpose].doesChannelInitialize = true;
           }
           resolve(channel);
         } catch (e) {
@@ -471,8 +478,9 @@ class RabbitMq implements IAfRabbitMq {
     return channel.bindQueue(queue, exchange, '');
   }
 
-  async setupQueue(queueName: string, connectionPurpose: ConnectionPurpose, options?: Options.AssertQueue): Promise<Replies.AssertQueue> {
+  async setupQueue(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue> {
     let queue: Replies.AssertQueue;
+    const connectionPurpose = ConnectionPurpose.Publish;
     const shouldUseQuorum = RabbitMq.shouldUseQuorum(queueName);
     const localeOptions = {
       ...options,
@@ -524,8 +532,8 @@ class RabbitMq implements IAfRabbitMq {
     return false;
   }
 
-  async assertQueue(queueName: string, connectionPurpose: ConnectionPurpose, options?: Options.AssertQueue) {
-    debug('rabbit: start assert queue', { connectionPurpose, queueName });
+  async assertQueue(queueName: string, options?: Options.AssertQueue) {
+    debug('rabbit: start assert queue', { queueName });
     RabbitMq.validateName('queue', queueName);
     if (this.queues[queueName]) {
       delete this.queueSetupPromises[queueName];
@@ -536,8 +544,8 @@ class RabbitMq implements IAfRabbitMq {
       return this.queueSetupPromises[queueName];
     }
 
-    this.queueSetupPromises[queueName] = this.setupQueue(queueName, connectionPurpose, options);
-    debug('rabbit: done assert queue', { connectionPurpose, queueName });
+    this.queueSetupPromises[queueName] = this.setupQueue(queueName, options);
+    debug('rabbit: done assert queue', { queueName });
     return this.queueSetupPromises[queueName];
   }
 
@@ -593,11 +601,8 @@ class RabbitMq implements IAfRabbitMq {
     }
     const channel = await this.getNewChannel({ connectionPurpose: ConnectionPurpose.Consume });
     return channel.addSetup(async (confirmChannel: ConfirmChannel) => {
-      const q = await this.assertQueue(queue, ConnectionPurpose.Consume, optionsWithDefaults);
+      const q = await this.assertQueue(queue, 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) => {
@@ -673,7 +678,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}`);
@@ -708,14 +713,11 @@ 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({
-        connectionPurpose: ConnectionPurpose.Publish,
-        newChannelOptions: options?.newChannelOptions,
-      });
+      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)),
@@ -730,10 +732,7 @@ class RabbitMq implements IAfRabbitMq {
     customHeaders?: any,
   ): Promise<boolean | undefined> {
     try {
-      await this.assertChannel({
-        connectionPurpose: ConnectionPurpose.Publish,
-        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;
@@ -741,7 +740,7 @@ class RabbitMq implements IAfRabbitMq {
 
     try {
       RabbitMq.validateName('queue', queue);
-      await this.assertQueue(queue, ConnectionPurpose.Publish, options);
+      await this.assertQueue(queue, options);
     } catch (e) {
       logger.error(`rabbit sendToQueue: failed to assert queue ${queue}`, { e });
       throw e;
@@ -759,22 +758,31 @@ class RabbitMq implements IAfRabbitMq {
     }
   }
 
+  //  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, doesChannelInitialize } = connectionData;
-        if (
-          connectionPurpose === ConnectionPurpose.Consume
-          || (connectionPurpose === ConnectionPurpose.Publish
-            && doesChannelInitialize
-          )) {
-          debug('rabbit: is connected inside map', { connection, connectionPurpose });
-          const isConnected = connection?.isConnected();
-          if (!isConnected) {
-            logger.error('rabbit: isConnected - false', { connectionPurpose });
-            return false;
-          }
+        const { connection } = connectionData;
+        if (connectionPurpose === ConnectionPurpose.Publish && connection) {
           const channel: any = await this.assertChannel({ connectionPurpose: connectionPurpose as ConnectionPurpose });
           try {
             await Promise.all([
@@ -786,7 +794,15 @@ class RabbitMq implements IAfRabbitMq {
             return false;
           }
         }
-        logger.info('rabbit: isConnected - true');
+
+        if (connection) {
+          const isConnected = connection?.isConnected();
+          if (!isConnected) {
+            logger.error('rabbit: isConnected - false', { connectionPurpose });
+            return false;
+          }
+          logger.info('rabbit: isConnected - true', { connectionPurpose });
+        }
         return true;
       }),
     );

package/src/lib/types.ts

@@ -1,6 +1,5 @@
-import { AmqpConnectionManager, CreateChannelOpts } from 'amqp-connection-manager';
+import { AmqpConnectionManager } from 'amqp-connection-manager';
 import { ConsumeMessage, Options, Replies } from 'amqplib';
-import { ConnectionPurpose } from './consts';
 
 export interface ExchangesCache {
   [key: string]: any
@@ -33,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>
@@ -41,14 +39,10 @@ export type CallbackFunction = (msg: ConsumeMessage, ack: any, nack: any) => Pro
 export type newChannelOpts = {
   name?: string;
   onClose?: null | ((args: any | null) => void);
-  options?: CreateChannelOpts | undefined;
-  connectionPurpose?: ConnectionPurpose;
 };
 export type assertChannelOpts = {
   channelName?: string;
   force?: boolean;
-  newChannelOptions?: newChannelOpts;
-  connectionPurpose?: ConnectionPurpose;
 }
 export type AfConsumer = {
   queue: string;
@@ -56,10 +50,6 @@ export type AfConsumer = {
   options: ConsumeOptions | undefined;
 }
 
-export interface PublishOptions {
-  newChannelOptions?: newChannelOpts;
-}
-
 const HA_PROMOTE_ON_FAILURE = 'ha-promote-on-failure';
 
 const HA_PROMOTE_ON_SHUTDOWN = 'ha-promote-on-shutdown';
@@ -76,5 +66,4 @@ export type ConnectionData = {
   creatingConnection: boolean;
   connectionCreatedEventName: string;
   connectionFailedEventName: string;
-  doesChannelInitialize?: boolean;
 };