@autofleet/rabbit 3.2.13-beta → 3.2.13-beta.10

package/dist/index.js

@@ -25,6 +25,7 @@ class RabbitMq {
     constructor(options, redisConfig) {
         this.DISCONNECT_MSG = 'rabbit: connection disconnect';
         this.RECONNECT_MSG = 'rabbit: connection disconnect - reconnecting';
+        this.consumers = [];
         this.shouldConsumeMessageByTimestamp = async (msg) => {
             if (msg) {
                 const { properties: { headers } } = msg;
@@ -87,7 +88,7 @@ class RabbitMq {
         this.creatingConnection = false;
         this.exchanges = {};
         this.queues = {};
-        this.consumers = new Set();
+        this.consumers = [];
         this.options = options;
         this.redisClient = redisConfig && redis_1.default(redisConfig);
         if (this.redisClient) {
@@ -224,28 +225,33 @@ class RabbitMq {
                 logger_1.default.error(`rabbit: error on get connection for new channel ${name} `, { e });
                 reject(e);
             }
-            const channel = connection.createChannel({
+            const channel = connection?.createChannel({
                 ...options,
             });
             let isResolved = false;
-            channel.on('error', (err) => {
-                logger_1.default.error(`rabbit: channel error ${name} error`, { err });
-                if (!isResolved) {
+            if (channel) {
+                channel.on('error', (err) => {
+                    logger_1.default.error(`rabbit: channel error ${name} error`, { err });
+                    if (!isResolved) {
+                        isResolved = true;
+                        reject(err);
+                    }
+                });
+                channel.on('close', (...args) => {
+                    logger_1.default.error(`rabbit: channel ${name} closed`, { args });
+                    if (onClose) {
+                        onClose(args);
+                    }
+                });
+                channel.once('connect', () => {
+                    debug(`rabbit: channel ${name} CONNECTED`);
                     isResolved = true;
-                    reject(err);
-                }
-            });
-            channel.on('close', (...args) => {
-                logger_1.default.error(`rabbit: channel ${name} closed`, { args });
-                if (onClose) {
-                    onClose(args);
-                }
-            });
-            channel.once('connect', () => {
-                debug(`rabbit: channel ${name} CONNECTED`);
-                isResolved = true;
-                resolve(channel);
-            });
+                    resolve(channel);
+                });
+            }
+            else {
+                debug(`rabbit: channel ${name} not connected and therefore no listener was registered`);
+            }
         });
     }
     async assertChannel({ force = false } = {}) {
@@ -329,15 +335,18 @@ class RabbitMq {
         return queue;
     }
     saveConsumer(queue, callback, options) {
-        this.consumers.add({
-            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) {
         await this.consumeFromRabbit(queue, callback, options);
-        return this.saveConsumer(queue, callback, options);
     }
     async lockRedisIfNeeded(msg, options) {
         const { properties: { headers } } = msg;
@@ -356,6 +365,7 @@ 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 = uuid_1.v4();
         const { limit, deadMessageTtl, useConsumeWithLock, lockTimeout, auditContext, enableRabbitTrace, } = optionsWithDefaults;
         if (useConsumeWithLock) {
@@ -496,7 +506,7 @@ class RabbitMq {
         try {
             await Promise.all([
                 channel.waitForConnect(),
-                ...Array.from(this.consumers, (c) => channel.checkQueue(c.queue)),
+                ...this.consumers.map((c) => channel.checkQueue(c.queue)),
             ]);
         }
         catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "3.2.13-beta",
+  "version": "3.2.13-beta.10",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -16,7 +16,7 @@
   },
   "dependencies": {
     "@autofleet/logger": "^1.2.8",
-    "@autofleet/zehut": "3.0.7",
+    "@autofleet/zehut": "^3.0.6",
     "@types/amqplib": "0.8.2",
     "@types/uuid": "^8.3.3",
     "amqp-connection-manager": "4.1.9",

package/src/index.ts

@@ -162,7 +162,7 @@ class RabbitMq implements IAfRabbitMq {
   /** Array of consumers tags used for canceling consumption */
   consumersTags: Array<[ConfirmChannel, string]>;
 
-  private consumers: Set<AfConsumer>;
+  private consumers: Array<AfConsumer> = [];
 
   constructor(options?: AfRabbitOptions, redisConfig?: RedisConfig) {
     this.em = new EventEmitter();
@@ -171,7 +171,7 @@ class RabbitMq implements IAfRabbitMq {
     this.creatingConnection = false;
     this.exchanges = {};
     this.queues = {};
-    this.consumers = new Set();
+    this.consumers = [];
     this.options = options;
     this.redisClient = redisConfig && getRedisInstance(redisConfig);
     if (this.redisClient) {
@@ -357,29 +357,33 @@ class RabbitMq implements IAfRabbitMq {
         logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
         reject(e);
       }
-      const channel = connection.createChannel({
+      const channel = connection?.createChannel({
         ...options,
       });
 
       let isResolved = false;
-      channel.on('error', (err) => {
-        logger.error(`rabbit: channel error ${name} error`, { err });
-        if (!isResolved) {
+      if (channel) {
+        channel.on('error', (err) => {
+          logger.error(`rabbit: channel error ${name} error`, { err });
+          if (!isResolved) {
+            isResolved = true;
+            reject(err);
+          }
+        });
+        channel.on('close', (...args) => {
+          logger.error(`rabbit: channel ${name} closed`, { args });
+          if (onClose) {
+            onClose(args);
+          }
+        });
+        channel.once('connect', () => {
+          debug(`rabbit: channel ${name} CONNECTED`);
           isResolved = true;
-          reject(err);
-        }
-      });
-      channel.on('close', (...args) => {
-        logger.error(`rabbit: channel ${name} closed`, { args });
-        if (onClose) {
-          onClose(args);
-        }
-      });
-      channel.once('connect', () => {
-        debug(`rabbit: channel ${name} CONNECTED`);
-        isResolved = true;
-        resolve(channel);
-      });
+          resolve(channel);
+        });
+      } else {
+        debug(`rabbit: channel ${name} not connected and therefore no listener was registered`);
+      }
     });
   }
 
@@ -470,16 +474,19 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   private saveConsumer(queue: string, callback: CallbackFunction, options: ConsumeOptions | undefined) {
-    this.consumers.add({
-      queue,
-      callback,
-      options,
-    });
+    const isConsumerExist :boolean = this.consumers.some((consumer) => consumer.queue === queue);
+    if (!isConsumerExist) {
+      logger.info(`rabbit: consumer: ${queue} saved in consumer array`);
+      this.consumers.push({
+        queue,
+        callback,
+        options,
+      });
+    }
   }
 
   async consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
     await this.consumeFromRabbit(queue, callback, options);
-    return this.saveConsumer(queue, callback, options);
   }
 
   private async lockRedisIfNeeded(msg: any, options: any) {
@@ -505,6 +512,7 @@ class RabbitMq implements IAfRabbitMq {
   private async consumeFromRabbit(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
     const optionsWithDefaults = { ...DEFAULT_OPTIONS, ...options };
     RabbitMq.validateName('queue', queue);
+    this.saveConsumer(queue, callback, options);
     const uniqueId = v4();
     const {
       limit, deadMessageTtl, useConsumeWithLock, lockTimeout, auditContext, enableRabbitTrace,
@@ -676,7 +684,7 @@ class RabbitMq implements IAfRabbitMq {
     try {
       await Promise.all([
         channel.waitForConnect(),
-        ...Array.from(this.consumers, (c) => channel.checkQueue(c.queue)),
+        ...this.consumers.map((c: AfConsumer) => channel.checkQueue(c.queue)),
       ]);
     } catch (e) {
       logger.error('rabbit: isConnected - false');