@autofleet/rabbit 3.1.1 → 3.1.2

package/dist/index.js

@@ -139,7 +139,7 @@ class RabbitMq {
         };
     }
     async getConnection() {
-        return new Promise(async (resolve) => {
+        return new Promise(async (resolve, reject) => {
             if (this.blockReconnect) {
                 debug('rabbit: block reconnect');
                 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -158,12 +158,30 @@ class RabbitMq {
             if (this.creatingConnection) {
                 debug('rabbit: creating connection emi');
                 this.em.once(consts_1.CONNECTION_CREATED_CONST, resolve);
+                this.em.once(consts_1.CONNECTION_FAILED_CONST, reject);
                 return;
             }
             this.creatingConnection = true;
+            let isResolved = false;
             debug('rabbit: creating connection', { HOST, USERNAME, HEARTBEAT });
             const connection = await amqp_connection_manager_1.connect([`amqp://${USERNAME}:${PASSWORD}@${HOST}?heartbeat=${HEARTBEAT}}`]);
             this.connection = connection;
+            this.connection.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.connection.on('connectFailed', (err) => {
+                logger_1.default.error('rabbit: connection connectFailed', { err });
+                if (!isResolved) {
+                    isResolved = true;
+                    reject(err);
+                    this.em.emit(consts_1.CONNECTION_FAILED_CONST, err);
+                }
+            });
             this.connection.on('disconnect', ({ err }) => {
                 debug('rabbit: connection closed');
                 this.exchanges = {};
@@ -183,6 +201,7 @@ class RabbitMq {
                 await this.loadConsumers();
                 this.creatingConnection = false;
                 this.em.emit(consts_1.CONNECTION_CREATED_CONST, connection);
+                isResolved = true;
                 resolve(connection);
             });
         });
@@ -191,8 +210,13 @@ class RabbitMq {
         return new Promise(async (resolve, reject) => {
             const connection = await this.getConnection();
             const channel = connection.createChannel({});
+            let isResolved = false;
             channel.on('error', (err) => {
                 logger_1.default.error(`rabbit: channel ${name} error`, { err });
+                if (!isResolved) {
+                    isResolved = true;
+                    reject(err);
+                }
             });
             channel.on('close', (...args) => {
                 logger_1.default.error(`rabbit: channel ${name} closed`, { args });
@@ -202,6 +226,7 @@ class RabbitMq {
             });
             channel.once('connect', () => {
                 debug(`rabbit: channel ${name} CONNECTED`);
+                isResolved = true;
                 resolve(channel);
             });
         });
@@ -241,14 +266,12 @@ class RabbitMq {
         return channel.checkQueue(queue);
     }
     async deleteQueue(queue) {
-        return new Promise(async (resolve, reject) => {
-            RabbitMq.validateName('queue', queue);
-            const channel = await this.assertChannel();
-            logger_1.default.info('rabbit: deleting queue', { queue });
-            const deleteQueueRes = await channel.deleteQueue(queue);
-            debug('queue deleted', deleteQueueRes);
-            resolve(deleteQueueRes);
-        });
+        RabbitMq.validateName('queue', queue);
+        const channel = await this.assertChannel();
+        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();

package/dist/lib/consts.d.ts

@@ -6,6 +6,7 @@ export declare const USER_TRACING_HEADER = "x-af-user-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;

package/dist/lib/consts.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_OPTIONS = exports.CONNECTION_CREATED_CONST = exports.DEFAULT_USE_CONSUME_WITH_LOCK = exports.USER_OBJECT = exports.USER_TRACING_HEADER = exports.TRACING_HEADER = exports.RETRY_HEADER = exports.DEFAULT_LOCK_TIMEOUT = exports.DEFAULT_DEAD_TTL_TWO_DAYS = void 0;
+exports.DEFAULT_OPTIONS = exports.CONNECTION_FAILED_CONST = exports.CONNECTION_CREATED_CONST = exports.DEFAULT_USE_CONSUME_WITH_LOCK = exports.USER_OBJECT = 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,6 +9,7 @@ exports.USER_TRACING_HEADER = 'x-af-user-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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "3.1.1",
+  "version": "3.1.2",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/index.ts

@@ -17,6 +17,7 @@ import getRedisInstance, { RedisConfig } from './lib/redis';
 import { assertExchangeFanout, rand, wrapSetImmediate } from './lib/utils';
 import {
   CONNECTION_CREATED_CONST,
+  CONNECTION_FAILED_CONST,
   DEFAULT_LOCK_TIMEOUT,
   DEFAULT_OPTIONS,
   RETRY_HEADER,
@@ -259,7 +260,7 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   async getConnection() {
-    return new Promise<AmqpConnectionManager>(async (resolve) => {
+    return new Promise<AmqpConnectionManager>(async (resolve, reject) => {
       if (this.blockReconnect) {
         debug('rabbit: block reconnect');
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -278,12 +279,32 @@ class RabbitMq implements IAfRabbitMq {
       if (this.creatingConnection) {
         debug('rabbit: creating connection emi');
         this.em.once(CONNECTION_CREATED_CONST, resolve);
+        this.em.once(CONNECTION_FAILED_CONST, reject);
         return;
       }
       this.creatingConnection = true;
+      let isResolved = false;
       debug('rabbit: creating connection', { HOST, USERNAME, HEARTBEAT });
       const connection: AmqpConnectionManager = await connect([`amqp://${USERNAME}:${PASSWORD}@${HOST}?heartbeat=${HEARTBEAT}}`]);
       this.connection = connection;
+      this.connection.on('error', (err) => {
+        logger.error('rabbit: connection error', { err });
+        if (!isResolved) {
+          isResolved = true;
+          reject(err);
+          this.em.emit(CONNECTION_FAILED_CONST, err);
+        }
+      });
+
+      this.connection.on('connectFailed', (err) => {
+        logger.error('rabbit: connection connectFailed', { err });
+        if (!isResolved) {
+          isResolved = true;
+          reject(err);
+          this.em.emit(CONNECTION_FAILED_CONST, err);
+        }
+      });
+
       this.connection.on('disconnect', ({ err }) => {
         debug('rabbit: connection closed');
         this.exchanges = {};
@@ -302,6 +323,7 @@ class RabbitMq implements IAfRabbitMq {
         await this.loadConsumers();
         this.creatingConnection = false;
         this.em.emit(CONNECTION_CREATED_CONST, connection);
+        isResolved = true;
         resolve(connection);
       });
     });
@@ -312,8 +334,13 @@ class RabbitMq implements IAfRabbitMq {
       const connection: AmqpConnectionManager = await this.getConnection();
       const channel = connection.createChannel({});
 
+      let isResolved = false;
       channel.on('error', (err) => {
         logger.error(`rabbit: channel ${name} error`, { err });
+        if (!isResolved) {
+          isResolved = true;
+          reject(err);
+        }
       });
       channel.on('close', (...args) => {
         logger.error(`rabbit: channel ${name} closed`, { args });
@@ -323,6 +350,7 @@ class RabbitMq implements IAfRabbitMq {
       });
       channel.once('connect', () => {
         debug(`rabbit: channel ${name} CONNECTED`);
+        isResolved = true;
         resolve(channel);
       });
     });
@@ -366,14 +394,12 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   private async deleteQueue(queue: string) {
-    return new Promise(async (resolve, reject) => {
-      RabbitMq.validateName('queue', queue);
-      const channel: ChannelWrapper = await this.assertChannel();
-      logger.info('rabbit: deleting queue', { queue });
-      const deleteQueueRes = await channel.deleteQueue(queue);
-      debug('queue deleted', deleteQueueRes);
-      resolve(deleteQueueRes);
-    });
+    RabbitMq.validateName('queue', queue);
+    const channel: ChannelWrapper = await this.assertChannel();
+    logger.info('rabbit: deleting queue', { queue });
+    const deleteQueueRes = await channel.deleteQueue(queue);
+    debug('queue deleted', deleteQueueRes);
+    return deleteQueueRes;
   }
 
   async bindQueue(queue: string, exchange: string) {

package/src/lib/consts.ts

@@ -6,6 +6,7 @@ export const USER_TRACING_HEADER = 'x-af-user-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,