@autofleet/rabbit 3.4.0-beta.16 → 3.4.0-beta.18

package/dist/index.js

@@ -168,14 +168,14 @@ class RabbitMq {
         this.publishChannelSetupPromise = null;
         this.connection = null;
         this.publishConnection = {
-            connection: null,
+            amqpConnection: null,
             creatingConnection: false,
             connectionCreatedEventName: 'publishConnectionCreated',
             connectionFailedEventName: 'publishConnectionFailed',
             blockReconnect: false,
         };
         this.consumeConnection = {
-            connection: null,
+            amqpConnection: null,
             creatingConnection: false,
             connectionCreatedEventName: 'consumeConnectionCreated',
             connectionFailedEventName: 'consumeConnectionFailed',
@@ -207,14 +207,14 @@ class RabbitMq {
         this.oldPublishChannel = null;
         this.oldPublishChannelSetupPromise = null;
         this.oldPublishConnection = {
-            connection: null,
+            amqpConnection: null,
             creatingConnection: false,
             connectionCreatedEventName: 'oldPublishConnectionCreated',
             connectionFailedEventName: 'oldPublishConnectionFailed',
             blockReconnect: false,
         };
         this.oldConsumeConnection = {
-            connection: null,
+            amqpConnection: null,
             creatingConnection: false,
             connectionCreatedEventName: 'oldConsumeConnectionCreated',
             connectionFailedEventName: 'oldConsumeConnectionFailed',
@@ -230,13 +230,7 @@ class RabbitMq {
     }
     async getConnection(connection) {
         return new Promise(async (resolve, reject) => {
-            const { connection: connectionLocal, creatingConnection, connectionCreatedEventName, connectionFailedEventName, blockReconnect, } = connection;
-            if (connection === this.publishConnection) {
-                debug('rabbit: getConnection publish', { connectionLocal, creatingConnection, blockReconnect });
-            }
-            else if (connection === this.consumeConnection) {
-                debug('rabbit: getConnection consume', { connectionLocal, creatingConnection, blockReconnect });
-            }
+            const { amqpConnection: connectionLocal, creatingConnection, connectionCreatedEventName, connectionFailedEventName, blockReconnect, } = connection;
             if (blockReconnect) {
                 debug('rabbit: block reconnect');
                 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -244,12 +238,6 @@ class RabbitMq {
                 return resolve();
             }
             if (connectionLocal !== null) {
-                if (connection === this.publishConnection) {
-                    debug('rabbit: getConnection publish getConnection is not null', { connectionLocal });
-                }
-                else if (connection === this.consumeConnection) {
-                    debug('rabbit: getConnection consume getConnection is not null', { connectionLocal });
-                }
                 if (this.options?.disableReconnect || connectionLocal?.isConnected()) {
                     debug('rabbit: connection - is connected');
                     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -280,13 +268,7 @@ class RabbitMq {
             const newConnection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
                 findServers,
             });
-            connection.connection = newConnection;
-            if (connection === this.publishConnection) {
-                debug('rabbit: publishConnection set');
-            }
-            else if (connection === this.consumeConnection) {
-                debug('rabbit: consumeConnection set');
-            }
+            connection.amqpConnection = newConnection;
             newConnection.on('error', (err) => {
                 logger_1.default.error('rabbit: connection error', { err });
                 if (!isResolved) {
@@ -334,12 +316,6 @@ class RabbitMq {
             logger_1.default.error(`rabbit: error on get connection for new channel ${name} `, { e });
             throw e;
         }
-        if (connection === this.publishConnection) {
-            debug('rabbit: getNewChannel publish', { localConnection });
-        }
-        else if (connection === this.consumeConnection) {
-            debug('rabbit: getNewChannel consume', { localConnection });
-        }
         const channel = localConnection?.createChannel({ ...options });
         (0, events_1.once)(channel, 'close').then((args) => {
             logger_1.default.error(`rabbit: channel ${name} closed`);
@@ -356,15 +332,6 @@ class RabbitMq {
         }
     }
     async assertChannel({ force = false, connection }) {
-        if (connection === this.publishConnection) {
-            debug('rabbit: assertChannel publish', { force, promiseSetup: this.oldPublishChannelSetupPromise });
-        }
-        else if (connection === this.consumeConnection) {
-            debug('rabbit: assertChannel consume', { force, promiseSetup: this.oldPublishChannelSetupPromise });
-        }
-        else {
-            debug('rabbit: assertChannel with undefined connection', { force, promiseSetup: this.oldPublishChannelSetupPromise, connection });
-        }
         if (!this.publishChannelSetupPromise) {
             this.publishChannelSetupPromise = new Promise(async (resolve, reject) => {
                 if (this.publishChannel && !force) {
@@ -407,7 +374,7 @@ class RabbitMq {
         if (!channel) {
             throw new rabbitError_1.default('channel is not defined');
         }
-        debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
+        debug('rabbit: getting queue length', { queue, connected: this.oldPublishConnection.amqpConnection?.isConnected() });
         return channel?.checkQueue(queue);
     }
     async deleteQueue(queue, connection) {
@@ -702,13 +669,12 @@ class RabbitMq {
     }
     // TODO: [QUORUM-PHASE-2] After changing the publish from old to new change from the old to the new implementation
     async isConnected() {
-        // TODO: OLD IMPLEMENTATION
         debug('rabbit: start old is connected');
         const oldConsumeConnection = await this.getConnectionOld(this.oldConsumeConnection);
         const oldPublishConnection = await this.getConnectionOld(this.oldPublishConnection);
         const oldIsConnected = oldConsumeConnection.isConnected() && oldPublishConnection.isConnected();
         if (!oldIsConnected) {
-            logger_1.default.error('rabbit: isConnected - false');
+            logger_1.default.error('rabbit: old isConnected - false');
             return false;
         }
         const oldChannel = await this.assertChannelOld({ connection: this.oldPublishConnection });
@@ -719,31 +685,10 @@ class RabbitMq {
             ]);
         }
         catch (e) {
-            logger_1.default.error('rabbit: isConnected - false');
+            logger_1.default.error('rabbit: old isConnected - false');
             return false;
         }
         logger_1.default.debug('rabbit: old isConnected - true');
-        // TODO: NEW IMPLEMENTATION
-        debug('rabbit: start is connected');
-        const consumeConnection = await this.getConnection(this.consumeConnection);
-        const publishConnection = await this.getConnection(this.publishConnection);
-        const isConnected = consumeConnection.isConnected() && publishConnection.isConnected();
-        if (!isConnected) {
-            logger_1.default.error('rabbit: isConnected - false');
-            return false;
-        }
-        const channel = await this.assertChannel({ connection: this.publishConnection });
-        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.debug('rabbit: isConnected - true');
         return true;
     }
     async gracefulShutdown(signal) {
@@ -766,7 +711,6 @@ class RabbitMq {
     }
     async consumeFromRabbitOld(queue, callback, options) {
         const optionsWithDefaults = { ...consts_1.DEFAULT_OPTIONS, ...options };
-        debug('rabbit: consumeFromRabbitOld', { queue });
         RabbitMq.validateName('queue', queue);
         this.saveConsumerOld(queue, callback, options);
         const uniqueId = (0, node_crypto_1.randomUUID)();
@@ -858,12 +802,6 @@ class RabbitMq {
     // TODO: [QUORUM-PHASE-3] Delete all the function under this line (getNewChannelOld, getConnectionOld, assertQueueOld, setupQueueOld, saveConsumerOld)
     async getNewChannelOld({ name = (0, utils_1.rand)().toString(), onClose = null, options = {}, connection, }) {
         let localConnection;
-        if (connection === this.oldPublishConnection) {
-            debug('rabbit: getConnectionOld publish', { connection });
-        }
-        else if (connection === this.oldConsumeConnection) {
-            debug('rabbit: getConnectionOld consume', { connection });
-        }
         try {
             localConnection = await this.getConnectionOld(connection);
         }
@@ -874,12 +812,6 @@ class RabbitMq {
         if (!localConnection) {
             throw new Error(`rabbit: couldnt get connection for new channel ${name}`);
         }
-        if (connection === this.oldPublishConnection) {
-            debug('rabbit: getNewChannelOld publish', { localConnection });
-        }
-        else if (connection === this.oldConsumeConnection) {
-            debug('rabbit: getNewChannelOld consume', { localConnection });
-        }
         const channel = localConnection?.createChannel({ ...options });
         (0, events_1.once)(channel, 'close').then((args) => {
             logger_1.default.error(`rabbit: channel ${name} closed`);
@@ -897,13 +829,7 @@ class RabbitMq {
     }
     async getConnectionOld(connection) {
         return new Promise(async (resolve, reject) => {
-            const { connection: connectionLocal, creatingConnection, connectionCreatedEventName, connectionFailedEventName, blockReconnect, } = connection;
-            if (connection === this.oldPublishConnection) {
-                debug('rabbit: getConnectionOld publish', { connectionLocal, creatingConnection, blockReconnect });
-            }
-            else if (connection === this.oldConsumeConnection) {
-                debug('rabbit: getConnectionOld consume', { connectionLocal, creatingConnection, blockReconnect });
-            }
+            const { amqpConnection: connectionLocal, creatingConnection, connectionCreatedEventName, connectionFailedEventName, blockReconnect, } = connection;
             if (blockReconnect) {
                 debug('rabbit: block reconnect');
                 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -941,13 +867,7 @@ class RabbitMq {
             const newConnection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
                 findServers,
             });
-            connection.connection = newConnection;
-            if (connection === this.oldPublishConnection) {
-                debug('rabbit: oldPublishConnection set');
-            }
-            else if (connection === this.oldConsumeConnection) {
-                debug('rabbit: oldConsumeConnection set');
-            }
+            connection.amqpConnection = newConnection;
             newConnection.on('error', (err) => {
                 logger_1.default.error('rabbit: connection error', { err });
                 if (!isResolved) {
@@ -1047,12 +967,6 @@ class RabbitMq {
         return queue;
     }
     async assertChannelOld({ force = false, connection }) {
-        if (connection === this.oldPublishConnection) {
-            debug('rabbit: assertChannelOld publish', { force, promiseSetup: this.oldPublishChannelSetupPromise });
-        }
-        else if (connection === this.oldConsumeConnection) {
-            debug('rabbit: assertChannelOld consume', { force, promiseSetup: this.oldPublishChannelSetupPromise });
-        }
         if (!this.oldPublishChannelSetupPromise) {
             this.oldPublishChannelSetupPromise = new Promise(async (resolve, reject) => {
                 if (this.oldPublishChannel && !force) {
@@ -1060,17 +974,10 @@ class RabbitMq {
                 }
                 try {
                     const channel = await this.getNewChannelOld({ connection });
-                    if (connection === this.oldPublishConnection) {
-                        debug('rabbit: old new channel got publish', { force, channel });
-                    }
-                    else if (connection === this.oldConsumeConnection) {
-                        debug('rabbit: old new channel got consume', { force, channel });
-                    }
                     channel.on('error', (err) => {
                         logger_1.default.error('rabbit: channel error', { err });
                     });
                     if (this.oldPublishConnection === connection) {
-                        debug('rabbit: a new channel assigned to the oldPublishChannel', { connection });
                         this.oldPublishChannel = channel;
                     }
                     resolve(channel);

package/dist/lib/types.d.ts

@@ -44,7 +44,7 @@ export type AfConsumer = {
 };
 export declare const CONSUMER_DEFAULT_OPTIONS: Options.Consume;
 export type ConnectionData = {
-    connection: AmqpConnectionManager | null;
+    amqpConnection: AmqpConnectionManager | null;
     creatingConnection: boolean;
     connectionCreatedEventName: string;
     connectionFailedEventName: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "3.4.0-beta.16",
+  "version": "3.4.0-beta.18",
   "description": "",
   "main": "dist/index.js",
   "engines": {

package/src/index.ts

@@ -215,14 +215,14 @@ class RabbitMq implements IAfRabbitMq {
     this.publishChannelSetupPromise = null;
     this.connection = null;
     this.publishConnection = {
-      connection: null,
+      amqpConnection: null,
       creatingConnection: false,
       connectionCreatedEventName: 'publishConnectionCreated',
       connectionFailedEventName: 'publishConnectionFailed',
       blockReconnect: false,
     };
     this.consumeConnection = {
-      connection: null,
+      amqpConnection: null,
       creatingConnection: false,
       connectionCreatedEventName: 'consumeConnectionCreated',
       connectionFailedEventName: 'consumeConnectionFailed',
@@ -256,14 +256,14 @@ class RabbitMq implements IAfRabbitMq {
     this.oldPublishChannel = null;
     this.oldPublishChannelSetupPromise = null;
     this.oldPublishConnection = {
-      connection: null,
+      amqpConnection: null,
       creatingConnection: false,
       connectionCreatedEventName: 'oldPublishConnectionCreated',
       connectionFailedEventName: 'oldPublishConnectionFailed',
       blockReconnect: false,
     };
     this.oldConsumeConnection = {
-      connection: null,
+      amqpConnection: null,
       creatingConnection: false,
       connectionCreatedEventName: 'oldConsumeConnectionCreated',
       connectionFailedEventName: 'oldConsumeConnectionFailed',
@@ -409,18 +409,13 @@ class RabbitMq implements IAfRabbitMq {
   async getConnection(connection: ConnectionData) {
     return new Promise<AmqpConnectionManager>(async (resolve, reject) => {
       const {
-        connection: connectionLocal,
+        amqpConnection: connectionLocal,
         creatingConnection,
         connectionCreatedEventName,
         connectionFailedEventName,
         blockReconnect,
       } = connection;
 
-      if (connection === this.publishConnection) {
-        debug('rabbit: getConnection publish', { connectionLocal, creatingConnection, blockReconnect });
-      } else if (connection === this.consumeConnection) {
-        debug('rabbit: getConnection consume', { connectionLocal, creatingConnection, blockReconnect });
-      }
       if (blockReconnect) {
         debug('rabbit: block reconnect');
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -428,11 +423,6 @@ class RabbitMq implements IAfRabbitMq {
         return resolve();
       }
       if (connectionLocal !== null) {
-        if (connection === this.publishConnection) {
-          debug('rabbit: getConnection publish getConnection is not null', { connectionLocal });
-        } else if (connection === this.consumeConnection) {
-          debug('rabbit: getConnection consume getConnection is not null', { connectionLocal });
-        }
         if (this.options?.disableReconnect || connectionLocal?.isConnected()) {
           debug('rabbit: connection - is connected');
           // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -467,12 +457,7 @@ class RabbitMq implements IAfRabbitMq {
         findServers,
       });
 
-      connection.connection = newConnection;
-      if (connection === this.publishConnection) {
-        debug('rabbit: publishConnection set');
-      } else if (connection === this.consumeConnection) {
-        debug('rabbit: consumeConnection set');
-      }
+      connection.amqpConnection = newConnection;
       newConnection.on('error', (err) => {
         logger.error('rabbit: connection error', { err });
         if (!isResolved) {
@@ -524,11 +509,6 @@ class RabbitMq implements IAfRabbitMq {
       logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
       throw e;
     }
-    if (connection === this.publishConnection) {
-      debug('rabbit: getNewChannel publish', { localConnection });
-    } else if (connection === this.consumeConnection) {
-      debug('rabbit: getNewChannel consume', { localConnection });
-    }
     const channel = localConnection?.createChannel({ ...options });
     once(channel, 'close').then((args) => {
       logger.error(`rabbit: channel ${name} closed`);
@@ -545,13 +525,6 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   async assertChannel({ force = false, connection }: assertChannelOpts): Promise<ChannelWrapper> {
-    if (connection === this.publishConnection) {
-      debug('rabbit: assertChannel publish', { force, promiseSetup: this.oldPublishChannelSetupPromise });
-    } else if (connection === this.consumeConnection) {
-      debug('rabbit: assertChannel consume', { force, promiseSetup: this.oldPublishChannelSetupPromise });
-    } else {
-      debug('rabbit: assertChannel with undefined connection', { force, promiseSetup: this.oldPublishChannelSetupPromise, connection });
-    }
     if (!this.publishChannelSetupPromise) {
       this.publishChannelSetupPromise = new Promise<ChannelWrapper>(async (resolve, reject) => {
         if (this.publishChannel && !force) {
@@ -599,7 +572,7 @@ class RabbitMq implements IAfRabbitMq {
     if (!channel) {
       throw new RabbitError('channel is not defined');
     }
-    debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
+    debug('rabbit: getting queue length', { queue, connected: this.oldPublishConnection.amqpConnection?.isConnected() });
     return channel?.checkQueue(queue);
   }
 
@@ -949,14 +922,13 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   // TODO: [QUORUM-PHASE-2] After changing the publish from old to new change from the old to the new implementation
-  async isConnected() : Promise<boolean> {
-    // TODO: OLD IMPLEMENTATION
+  async isConnected(): Promise<boolean> {
     debug('rabbit: start old is connected');
     const oldConsumeConnection = await this.getConnectionOld(this.oldConsumeConnection);
     const oldPublishConnection = await this.getConnectionOld(this.oldPublishConnection);
     const oldIsConnected = oldConsumeConnection.isConnected() && oldPublishConnection.isConnected();
     if (!oldIsConnected) {
-      logger.error('rabbit: isConnected - false');
+      logger.error('rabbit: old isConnected - false');
       return false;
     }
     const oldChannel: any = await this.assertChannelOld({ connection: this.oldPublishConnection });
@@ -966,31 +938,10 @@ class RabbitMq implements IAfRabbitMq {
         ...this.oldConsumers.map((c: AfConsumer) => oldChannel.checkQueue(c.queue)),
       ]);
     } catch (e) {
-      logger.error('rabbit: isConnected - false');
+      logger.error('rabbit: old isConnected - false');
       return false;
     }
     logger.debug('rabbit: old isConnected - true');
-
-    // TODO: NEW IMPLEMENTATION
-    debug('rabbit: start is connected');
-    const consumeConnection = await this.getConnection(this.consumeConnection);
-    const publishConnection = await this.getConnection(this.publishConnection);
-    const isConnected = consumeConnection.isConnected() && publishConnection.isConnected();
-    if (!isConnected) {
-      logger.error('rabbit: isConnected - false');
-      return false;
-    }
-    const channel: any = await this.assertChannel({ connection: this.publishConnection });
-    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.debug('rabbit: isConnected - true');
     return true;
   }
 
@@ -1014,7 +965,6 @@ class RabbitMq implements IAfRabbitMq {
 
   private async consumeFromRabbitOld(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
     const optionsWithDefaults = { ...DEFAULT_OPTIONS, ...options };
-    debug('rabbit: consumeFromRabbitOld', { queue });
     RabbitMq.validateName('queue', queue);
     this.saveConsumerOld(queue, callback, options);
     const uniqueId = randomUUID();
@@ -1122,11 +1072,6 @@ class RabbitMq implements IAfRabbitMq {
     name = rand().toString(), onClose = null, options = {}, connection,
   }: newChannelOpts) {
     let localConnection!: AmqpConnectionManager;
-    if (connection === this.oldPublishConnection) {
-      debug('rabbit: getConnectionOld publish', { connection });
-    } else if (connection === this.oldConsumeConnection) {
-      debug('rabbit: getConnectionOld consume', { connection });
-    }
     try {
       localConnection = await this.getConnectionOld(connection);
     } catch (e) {
@@ -1137,11 +1082,7 @@ class RabbitMq implements IAfRabbitMq {
     if (!localConnection) {
       throw new Error(`rabbit: couldnt get connection for new channel ${name}`);
     }
-    if (connection === this.oldPublishConnection) {
-      debug('rabbit: getNewChannelOld publish', { localConnection });
-    } else if (connection === this.oldConsumeConnection) {
-      debug('rabbit: getNewChannelOld consume', { localConnection });
-    }
+
     const channel = localConnection?.createChannel({ ...options });
     once(channel, 'close').then((args) => {
       logger.error(`rabbit: channel ${name} closed`);
@@ -1160,18 +1101,13 @@ class RabbitMq implements IAfRabbitMq {
   async getConnectionOld(connection: ConnectionData) {
     return new Promise<AmqpConnectionManager>(async (resolve, reject) => {
       const {
-        connection: connectionLocal,
+        amqpConnection: connectionLocal,
         creatingConnection,
         connectionCreatedEventName,
         connectionFailedEventName,
         blockReconnect,
       } = connection;
 
-      if (connection === this.oldPublishConnection) {
-        debug('rabbit: getConnectionOld publish', { connectionLocal, creatingConnection, blockReconnect });
-      } else if (connection === this.oldConsumeConnection) {
-        debug('rabbit: getConnectionOld consume', { connectionLocal, creatingConnection, blockReconnect });
-      }
       if (blockReconnect) {
         debug('rabbit: block reconnect');
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -1214,12 +1150,7 @@ class RabbitMq implements IAfRabbitMq {
         findServers,
       });
 
-      connection.connection = newConnection;
-      if (connection === this.oldPublishConnection) {
-        debug('rabbit: oldPublishConnection set');
-      } else if (connection === this.oldConsumeConnection) {
-        debug('rabbit: oldConsumeConnection set');
-      }
+      connection.amqpConnection = newConnection;
       newConnection.on('error', (err) => {
         logger.error('rabbit: connection error', { err });
         if (!isResolved) {
@@ -1327,11 +1258,6 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   async assertChannelOld({ force = false, connection }: assertChannelOpts): Promise<ChannelWrapper> {
-    if (connection === this.oldPublishConnection) {
-      debug('rabbit: assertChannelOld publish', { force, promiseSetup: this.oldPublishChannelSetupPromise });
-    } else if (connection === this.oldConsumeConnection) {
-      debug('rabbit: assertChannelOld consume', { force, promiseSetup: this.oldPublishChannelSetupPromise });
-    }
     if (!this.oldPublishChannelSetupPromise) {
       this.oldPublishChannelSetupPromise = new Promise<ChannelWrapper>(async (resolve, reject) => {
         if (this.oldPublishChannel && !force) {
@@ -1340,16 +1266,10 @@ class RabbitMq implements IAfRabbitMq {
 
         try {
           const channel = await this.getNewChannelOld({ connection });
-          if (connection === this.oldPublishConnection) {
-            debug('rabbit: old new channel got publish', { force, channel });
-          } else if (connection === this.oldConsumeConnection) {
-            debug('rabbit: old new channel got consume', { force, channel });
-          }
           channel.on('error', (err) => {
             logger.error('rabbit: channel error', { err });
           });
           if (this.oldPublishConnection === connection) {
-            debug('rabbit: a new channel assigned to the oldPublishChannel', { connection });
             this.oldPublishChannel = channel;
           }
           resolve(channel);

package/src/lib/types.ts

@@ -64,7 +64,7 @@ export const CONSUMER_DEFAULT_OPTIONS: Options.Consume = {
 };
 
 export type ConnectionData = {
-  connection: AmqpConnectionManager | null;
+  amqpConnection: AmqpConnectionManager | null;
   creatingConnection: boolean;
   connectionCreatedEventName: string;
   connectionFailedEventName: string;