@autofleet/rabbit 3.2.14-beta.2 → 3.2.14-beta.4

package/dist/index.js

@@ -1,4 +1,5 @@
 "use strict";
+/* eslint-disable no-empty,consistent-return,no-async-promise-executor,@typescript-eslint/no-unused-vars */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -216,29 +217,38 @@ class RabbitMq {
     }
     async getNewChannel({ name = utils_1.rand().toString(), onClose = null, options = {} } = {}) {
         return new Promise(async (resolve, reject) => {
-            const connection = await this.getConnection();
-            const channel = connection.createChannel({
+            let connection;
+            try {
+                connection = await this.getConnection();
+            }
+            catch (e) {
+                logger_1.default.error(`rabbit: error on get connection for new channel ${name} `, { e });
+                reject(e);
+            }
+            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);
+                });
+            }
         });
     }
     async assertChannel({ force = false } = {}) {
@@ -322,15 +332,18 @@ class RabbitMq {
         return queue;
     }
     saveConsumer(queue, callback, options) {
-        this.consumers.push({
-            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;
@@ -349,6 +362,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) {
@@ -437,6 +451,7 @@ class RabbitMq {
         RabbitMq.validateName('exchange', exchange);
         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}` });
         return channel.addSetup(async (c) => {
             const assertExchange = await utils_1.assertExchangeFanout(c, exchange);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "3.2.14-beta.2",
+  "version": "3.2.14-beta.4",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -16,7 +16,7 @@
   },
   "dependencies": {
     "@autofleet/logger": "^1.2.8",
-    "@autofleet/zehut": "3.0.6",
+    "@autofleet/zehut": "3.0.8",
     "@types/amqplib": "0.8.2",
     "@types/uuid": "^8.3.3",
     "amqp-connection-manager": "4.1.9",
@@ -28,7 +28,7 @@
     "uuid": "^8.3.2"
   },
   "peerDependencies": {
-    "@autofleet/outbreak": "0.2.1"
+    "@autofleet/outbreak": "^1.0.4"
   },
   "devDependencies": {
     "@types/jest": "^26.0.23",
@@ -44,4 +44,4 @@
   },
   "author": "",
   "license": "ISC"
-}
+}

package/src/index.ts

@@ -1,3 +1,5 @@
+/* eslint-disable no-empty,consistent-return,no-async-promise-executor,@typescript-eslint/no-unused-vars */
+
 import { EventEmitter } from 'events';
 import { promisify } from 'util';
 import moment from 'moment';
@@ -348,30 +350,38 @@ class RabbitMq implements IAfRabbitMq {
 
   async getNewChannel({ name = rand().toString(), onClose = null, options = {} }: newChannelOpts = {}) {
     return new Promise<ChannelWrapper>(async (resolve, reject) => {
-      const connection: AmqpConnectionManager = await this.getConnection();
-      const channel = connection.createChannel({
+      let connection!: AmqpConnectionManager;
+      try {
+        connection = await this.getConnection();
+      } catch (e) {
+        logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
+        reject(e);
+      }
+      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);
+        });
+      }
     });
   }
 
@@ -462,16 +472,19 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   private saveConsumer(queue: string, callback: CallbackFunction, options: ConsumeOptions | undefined) {
-    this.consumers.push({
-      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) {
@@ -497,6 +510,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,
@@ -599,6 +613,7 @@ class RabbitMq implements IAfRabbitMq {
     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}` });
 
     return channel.addSetup(async (c: ConfirmChannel) => {