@autofleet/rabbit 3.2.22-beta.1 → 3.2.22-beta.3

package/dist/index.d.ts

@@ -37,7 +37,7 @@ type newChannelOpts = {
     name?: string;
     onClose?: null | ((args: any | null) => void);
     options?: CreateChannelOpts | undefined;
-    connectionPurpose: ConnectionPurpose;
+    connectionPurpose?: ConnectionPurpose;
 };
 type assertChannelOpts = {
     channelName?: string;
@@ -97,7 +97,7 @@ declare class RabbitMq implements IAfRabbitMq {
     consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any>;
     publish(exchange: string, content: any, customHeaders?: any): Promise<boolean>;
     sendToQueue(queue: string, content: any, options?: any, customHeaders?: any): Promise<boolean | undefined>;
-    isConnected(connectionPurpose: ConnectionPurpose): Promise<boolean>;
+    isConnected(): Promise<boolean>;
     gracefulShutdown(signal: string): Promise<void>;
 }
 export default RabbitMq;

package/dist/index.js

@@ -182,10 +182,6 @@ class RabbitMq {
             const newConnection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
                 findServers,
             });
-            if (!newConnection) {
-                logger_1.default.error('rabbit: couldnt create a connection');
-                return resolve(connection);
-            }
             this.connectionsMap[connectionPurpose].connection = newConnection;
             newConnection.on('error', (err) => {
                 logger_1.default.error('rabbit: connection error', { err });
@@ -463,7 +459,7 @@ 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}`, connectionPurpose: types_1.ConnectionPurpose.Consume });
+        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);
@@ -505,35 +501,33 @@ class RabbitMq {
             return res;
         }
         catch (e) {
-            const isConnected = await this.isConnected(types_1.ConnectionPurpose.Publish);
-            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(connectionPurpose) {
-        const connection = await this.getConnection(connectionPurpose);
-        if (!connection) {
-            logger_1.default.error('rabbit: isConnected - false');
-            return false;
-        }
-        const isConnected = connection.isConnected();
-        if (!isConnected) {
-            logger_1.default.error('rabbit: isConnected - false');
-            return false;
-        }
-        const channel = await this.assertChannel({ 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;
+    async isConnected() {
+        const isEachConnectionConnected = await Promise.all(Object.entries(this.connectionsMap).map(async ([connectionPurpose, connectionData]) => {
+            const { connection } = connectionData;
+            const isConnected = connection?.isConnected();
+            if (!isConnected) {
+                logger_1.default.error('rabbit: isConnected - false');
+                return false;
+            }
+            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/package.json

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

package/src/index.ts

@@ -83,7 +83,7 @@ type newChannelOpts = {
   name?: string;
   onClose?: null | ((args: any | null) => void);
   options?: CreateChannelOpts | undefined;
-  connectionPurpose: ConnectionPurpose,
+  connectionPurpose?: ConnectionPurpose,
 };
 
 type assertChannelOpts = {
@@ -321,11 +321,6 @@ class RabbitMq implements IAfRabbitMq {
         findServers,
       });
 
-      if (!newConnection) {
-        logger.error('rabbit: couldnt create a connection');
-        return resolve(connection);
-      }
-
       this.connectionsMap[connectionPurpose].connection = newConnection;
 
       newConnection.on('error', (err) => {
@@ -638,7 +633,7 @@ class RabbitMq implements IAfRabbitMq {
     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}`, connectionPurpose: ConnectionPurpose.Consume });
+    const channel: ChannelWrapper = await this.getNewChannel({ name: `consume - exchange - ${exchange} -queue - ${queue}` });
 
     return channel.addSetup(async (c: ConfirmChannel) => {
       const assertExchange = await assertExchangeFanout(c, exchange);
@@ -695,35 +690,35 @@ class RabbitMq implements IAfRabbitMq {
       debug(`rabbit: sending to queue ${queue}`, { res });
       return res;
     } catch (e) {
-      const isConnected = await this.isConnected(ConnectionPurpose.Publish);
-      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(connectionPurpose: ConnectionPurpose): Promise<boolean> {
-    const connection = await this.getConnection(connectionPurpose);
-    if (!connection) {
-      logger.error('rabbit: isConnected - false');
-      return false;
-    }
-    const isConnected = connection.isConnected();
-    if (!isConnected) {
-      logger.error('rabbit: isConnected - false');
-      return false;
-    }
-    const channel: any = await this.assertChannel({ 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;
+  async isConnected(): Promise<boolean> {
+    const isEachConnectionConnected = await Promise.all(
+      Object.entries(this.connectionsMap).map(async ([connectionPurpose, connectionData]) => {
+        const { connection } = connectionData;
+        const isConnected = connection?.isConnected();
+        if (!isConnected) {
+          logger.error('rabbit: isConnected - false');
+          return false;
+        }
+        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> {