@autofleet/rabbit 3.4.0-beta.9 → 3.5.0

package/dist/mock/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/mock/index.ts"],"names":[],"mappings":";;AAAA,gDAAgD;AAChD,gBAAc;AAGd,MAAM,QAAQ;IAAd;QACE,QAAG,GAAQ,IAAI,CAAC,EAAE,EAAE,CAAC;QAErB,SAAI,GAAQ,IAAI,CAAC,EAAE,EAAE,CAAC;QAEtB,kBAAa,GAAQ,IAAI,CAAC,EAAE,EAAE,CAAC;QAE/B,mBAAc,GAAQ,IAAI,CAAC,EAAE,EAAE,CAAC;QAEhC,gBAAW,GAAQ,IAAI,CAAC,EAAE,EAAE,CAAC;QAE7B,YAAO,GAAQ,IAAI,CAAC,EAAE,EAAE,CAAC;QAEzB,wBAAmB,GAAQ,IAAI,CAAC,EAAE,EAAE,CAAC;QAErC,YAAO,GAAQ,IAAI,CAAC,EAAE,EAAE,CAAC;QAEzB,gBAAW,GAAQ,IAAI,CAAC,EAAE,EAAE,CAAC;IAC/B,CAAC;CAAA;AAED,kBAAe,QAAQ,CAAC"}

package/dist/mock/vitest.d.ts

@@ -0,0 +1,13 @@
+import { IAfRabbitMq } from '../index';
+declare class RabbitMq implements IAfRabbitMq {
+    ack: import("@vitest/spy").Mock<(...args: any[]) => any>;
+    nack: import("@vitest/spy").Mock<(...args: any[]) => any>;
+    assertChannel: import("@vitest/spy").Mock<(...args: any[]) => any>;
+    assertExchange: import("@vitest/spy").Mock<(...args: any[]) => any>;
+    assertQueue: import("@vitest/spy").Mock<(...args: any[]) => any>;
+    consume: import("@vitest/spy").Mock<(...args: any[]) => any>;
+    consumeFromExchange: import("@vitest/spy").Mock<(...args: any[]) => any>;
+    publish: import("@vitest/spy").Mock<(...args: any[]) => any>;
+    sendToQueue: import("@vitest/spy").Mock<(...args: any[]) => any>;
+}
+export default RabbitMq;

package/dist/mock/vitest.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+class RabbitMq {
+    constructor() {
+        this.ack = vitest_1.vi.fn();
+        this.nack = vitest_1.vi.fn();
+        this.assertChannel = vitest_1.vi.fn();
+        this.assertExchange = vitest_1.vi.fn();
+        this.assertQueue = vitest_1.vi.fn();
+        this.consume = vitest_1.vi.fn();
+        this.consumeFromExchange = vitest_1.vi.fn();
+        this.publish = vitest_1.vi.fn();
+        this.sendToQueue = vitest_1.vi.fn();
+    }
+}
+exports.default = RabbitMq;
+//# sourceMappingURL=vitest.js.map

package/dist/mock/vitest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.js","sourceRoot":"","sources":["../../src/mock/vitest.ts"],"names":[],"mappings":";;AAAA,mCAA4B;AAG5B,MAAM,QAAQ;IAAd;QACE,QAAG,GAAG,WAAE,CAAC,EAAE,EAAE,CAAC;QAEd,SAAI,GAAG,WAAE,CAAC,EAAE,EAAE,CAAC;QAEf,kBAAa,GAAG,WAAE,CAAC,EAAE,EAAE,CAAC;QAExB,mBAAc,GAAG,WAAE,CAAC,EAAE,EAAE,CAAC;QAEzB,gBAAW,GAAG,WAAE,CAAC,EAAE,EAAE,CAAC;QAEtB,YAAO,GAAG,WAAE,CAAC,EAAE,EAAE,CAAC;QAElB,wBAAmB,GAAG,WAAE,CAAC,EAAE,EAAE,CAAC;QAE9B,YAAO,GAAG,WAAE,CAAC,EAAE,EAAE,CAAC;QAElB,gBAAW,GAAG,WAAE,CAAC,EAAE,EAAE,CAAC;IACxB,CAAC;CAAA;AAED,kBAAe,QAAQ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "3.4.0-beta.9",
+  "version": "3.5.0",
   "description": "",
   "main": "dist/index.js",
   "engines": {
@@ -10,40 +10,47 @@
     "postinstall": "echo '\\033[0;31m\nWARNING: in case of migrating to new version of @autofleet/rabbit \nyou might have to delete existing queues or the deployment will fail.\\033[0m\n'",
     "start": "ts-node  src/index.ts",
     "example": "ts-node  src/example.ts",
-    "build": "rm -rf dist && tsc",
-    "linter": "./node_modules/.bin/eslint .",
-    "test": "jest  --runInBand --forceExit",
-    "test-local": "RABBITMQ_SERVICE_HOST=localhost:5672 jest --forceExit",
-    "coverage": "jest --coverage --forceExit && rm -rf ./coverage",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "linter": "eslint .",
+    "test": "vitest",
+    "test-local": "RABBITMQ_SERVICE_HOST=localhost:5672 node --inspect-brk ./node_modules/.bin/vitest --testTimeout=10000000000",
+    "coverage": "vitest --coverage",
     "dev": "nodemon"
   },
   "dependencies": {
     "@autofleet/zehut": "^3.1.2",
-    "amqp-connection-manager": "4.1.9",
-    "amqplib": "0.10.3",
+    "amqp-connection-manager": "4.1.14",
+    "amqplib": "0.10.5",
     "bluebird": "^3.7.2",
-    "moment": "^2.29.1",
+    "moment": "^2.30.1",
     "redis": "^3.1.2",
     "redis-lock": "^0.1.4"
   },
   "peerDependencies": {
-    "@autofleet/logger": "*"
+    "@autofleet/logger": "*",
+    "jest": "*"
+  },
+  "peerDependenciesMeta": {
+    "jest": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@autofleet/logger": "4.0.6",
-    "@types/amqplib": "0.8.2",
+    "@types/amqplib": "0.10.7",
+    "@types/bluebird": "^3.5.42",
     "@types/jest": "^29.5.12",
     "@types/node": "^20.14.11",
     "@typescript-eslint/eslint-plugin": "^4.8.1",
+    "@vitest/coverage-v8": "^3.1.3",
     "eslint": "^7.13.0",
     "eslint-config-airbnb-typescript": "^12.0.0",
     "eslint-plugin-import": "^2.22.1",
-    "jest": "^29.7.0",
     "node-tcp-proxy": "^0.0.28",
-    "ts-jest": "^29.2.3",
     "ts-node": "^8.6.2",
-    "typescript": "^4.9.5"
+    "typescript": "^4.9.5",
+    "vitest": "^3.1.3"
   },
   "author": "",
-  "license": "ISC"
+  "license": "Proprietary"
 }

package/src/index.ts

@@ -45,6 +45,11 @@ const debug = logger.debug.bind(logger);
 
 const PUBLISH_TIMEOUT = 1000 * 10;
 
+// TODO: [QUORUM-PHASE-3] Delete this env var
+const {
+  DISABLE_QUORUM_QUEUES,
+} = process.env;
+
 export interface IAfRabbitMq {
   ack: any;
   nack: any;
@@ -149,8 +154,6 @@ class RabbitMq implements IAfRabbitMq {
 
   blockReconnect: boolean | null | undefined
 
-  connection: AmqpConnectionManager | null | undefined
-
   publishConnection: ConnectionData
 
   consumeConnection: ConnectionData
@@ -213,16 +216,15 @@ class RabbitMq implements IAfRabbitMq {
     this.em = new EventEmitter();
     this.publishChannel = null;
     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 +258,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',
@@ -378,13 +380,13 @@ class RabbitMq implements IAfRabbitMq {
       if (
         !skipRetry
         && (
-          !msg.properties.headers[RETRY_HEADER]
+          !msg.properties.headers?.[RETRY_HEADER]
           || parseInt(msg.properties.headers[RETRY_HEADER], 10) < options.retries
         )
       ) {
         await this.sendToQueue(queue, RabbitMq.parseMsg(msg).content, options, {
           ...msg.properties.headers,
-          [RETRY_HEADER]: msg.properties.headers[RETRY_HEADER]
+          [RETRY_HEADER]: msg.properties.headers?.[RETRY_HEADER]
             ? msg.properties.headers[RETRY_HEADER] + 1
             : 1,
         });
@@ -392,7 +394,7 @@ class RabbitMq implements IAfRabbitMq {
         const deadQueue = `${queue}-dead`;
         await this.sendToQueue(deadQueue, RabbitMq.parseMsg(msg).content, deadQueueOptions, {
           ...msg.properties.headers,
-          [RETRY_HEADER]: msg.properties.headers[RETRY_HEADER]
+          [RETRY_HEADER]: msg.properties.headers?.[RETRY_HEADER]
             ? msg.properties.headers[RETRY_HEADER] + 1
             : 1,
         });
@@ -409,12 +411,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 (blockReconnect) {
         debug('rabbit: block reconnect');
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -456,12 +459,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) {
@@ -473,6 +471,9 @@ class RabbitMq implements IAfRabbitMq {
 
       newConnection.on('connectFailed', (err) => {
         this.consumersTags = [];
+        if (typeof err.url === 'string') {
+          err.url = this.maskURL(err.url);
+        }
         logger.error('rabbit: connection connectFailed', { err, advice: 'Check if the vhost exist', vhost: this.vhost });
         if (!isResolved) {
           isResolved = true;
@@ -496,7 +497,7 @@ class RabbitMq implements IAfRabbitMq {
       newConnection.once('connect', async () => {
         debug('rabbit: connection established');
         connection.creatingConnection = false;
-        this.em.emit(connectionCreatedEventName, connection);
+        this.em.emit(connectionCreatedEventName, newConnection);
         isResolved = true;
         resolve(newConnection);
       });
@@ -576,7 +577,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);
   }
 
@@ -682,7 +683,7 @@ class RabbitMq implements IAfRabbitMq {
   // Used by the microservices to consume messages from the queue
   async consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
     // TODO: [QUORUM-PHASE-3] Use only the implementation of consumeNew and delete consumeNew and consumeOld
-    if (options?.isQuorumQueue !== false) {
+    if (options?.isQuorumQueue !== false && DISABLE_QUORUM_QUEUES !== 'true') {
       await this.assertVHost();
       await this.consumeNew(queue, callback, options);
     }
@@ -745,9 +746,9 @@ class RabbitMq implements IAfRabbitMq {
             return null;
           }
 
-          const traceId = msg.properties.headers[TRACING_HEADER];
-          const userId = msg.properties.headers[USER_TRACING_HEADER];
-          const automationId = msg.properties.headers[AUTOMATION_ID_HEADER];
+          const traceId = msg.properties.headers![TRACING_HEADER];
+          const userId = msg.properties.headers![USER_TRACING_HEADER];
+          const automationId = msg.properties.headers![AUTOMATION_ID_HEADER];
           const parsedMessage = RabbitMq.parseMsg(msg);
           const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
           const trace = newTrace(traceTypes.RABBIT);
@@ -831,7 +832,7 @@ class RabbitMq implements IAfRabbitMq {
     RabbitMq.validateName('queue', queue);
     const { limit, deadMessageTtl } = optionsWithDefaults;
     // TODO: [QUORUM-PHASE-3] Delete the if statement after all the queues are created as quorum queues
-    if (options?.isQuorumQueue !== false) {
+    if (options?.isQuorumQueue !== false && DISABLE_QUORUM_QUEUES !== 'true') {
       await this.assertVHost();
       await this.saveConsumer(queue, callback, options);
       const channel: ChannelWrapper = await this.getNewChannel({
@@ -853,28 +854,27 @@ class RabbitMq implements IAfRabbitMq {
           ),
         ]);
       });
-    } else {
-      // TODO: [QUORUM-PHASE-3] Delete the old implementation
-      await this.saveConsumerOld(queue, callback, options);
-      const channelOld: ChannelWrapper = await this.getNewChannelOld({
-        name: `consume-exchange-${exchange}-queue-${queue}-old`,
-        connection: this.oldConsumeConnection,
-      });
-      await channelOld.addSetup(async (c: ConfirmChannel) => {
-        const assertExchange = await assertExchangeFanout(c, exchange);
-        await c.assertQueue(queue);
-        this.oldExchanges[exchange] = assertExchange;
-        await c.prefetch(limit, false);
-        return Promise.all([
-          c.bindQueue(queue, exchange, ''),
-          this.consumeOld(
-            queue,
-            callback,
-            options,
-          ),
-        ]);
-      });
     }
+    // TODO: [QUORUM-PHASE-3] Delete the old implementation
+    await this.saveConsumerOld(queue, callback, options);
+    const channelOld: ChannelWrapper = await this.getNewChannelOld({
+      name: `consume-exchange-${exchange}-queue-${queue}-old`,
+      connection: this.oldConsumeConnection,
+    });
+    await channelOld.addSetup(async (c: ConfirmChannel) => {
+      const assertExchange = await assertExchangeFanout(c, exchange);
+      await c.assertQueue(queue);
+      this.oldExchanges[exchange] = assertExchange;
+      await c.prefetch(limit, false);
+      return Promise.all([
+        c.bindQueue(queue, exchange, ''),
+        this.consumeOld(
+          queue,
+          callback,
+          options,
+        ),
+      ]);
+    });
   }
 
   // Used by the microservices to publish messages to the exchange
@@ -920,53 +920,71 @@ class RabbitMq implements IAfRabbitMq {
       debug(`rabbit: sending to queue ${queue}`, { res });
       return res;
     } catch (e) {
-      const isConnected = await this.isConnected();
+      const isConnected = await this.isConnectedOld();
       logger.error(`rabbit sendToQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { e });
       throw e;
     }
   }
 
   // TODO: [QUORUM-PHASE-2] After changing the publish from old to new change from the old to the new 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');
+  async isConnected(): Promise<boolean> {
+    const [connectionNew, connectionOld] = await Promise.all([
+      this.isConnectedNew(),
+      this.isConnectedOld(),
+    ]);
+
+    return connectionNew && connectionOld;
+  }
+
+  // TODO: [QUORUM-PHASE-2] After changing the publish from old to new change from the old to the new implementation
+  async isConnectedNew(): Promise<boolean> {
+    if (DISABLE_QUORUM_QUEUES === 'true') {
+      return true;
+    }
+
+    debug('rabbit: start new 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: new isConnected - false');
       return false;
     }
-    const oldChannel: any = await this.assertChannelOld({ connection: this.oldPublishConnection });
+    const channel: any = await this.assertChannel({ connection: this.publishConnection });
     try {
       await Promise.all([
-        oldChannel.waitForConnect(),
-        ...this.oldConsumers.map((c: AfConsumer) => oldChannel.checkQueue(c.queue)),
+        channel.waitForConnect(),
+        ...this.consumers.map((c: AfConsumer) => channel.checkQueue(c.queue)),
       ]);
     } catch (e) {
-      logger.error('rabbit: isConnected - false');
+      logger.error('rabbit: new isConnected - false');
       return false;
     }
-    logger.debug('rabbit: old isConnected - true');
+    logger.debug('rabbit: new isConnected - true');
+    return true;
+  }
 
-    debug('rabbit: start is connected');
-    const consumeConnection = await this.getConnectionOld(this.oldConsumeConnection);
-    const publishConnection = await this.getConnectionOld(this.oldPublishConnection);
-    const isConnected = consumeConnection.isConnected() && publishConnection.isConnected();
-    if (!isConnected) {
-      logger.error('rabbit: isConnected - false');
+  // TODO: [QUORUM-PHASE-2] After changing the publish from old to new change from the old to the new implementation
+  async isConnectedOld(): 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: old isConnected - false');
       return false;
     }
-    const channel: any = await this.assertChannelOld({ connection: this.oldPublishConnection });
+    const oldChannel: any = await this.assertChannelOld({ connection: this.oldPublishConnection });
     try {
       await Promise.all([
-        channel.waitForConnect(),
-        ...this.oldConsumers.map((c: AfConsumer) => channel.checkQueue(c.queue)),
+        oldChannel.waitForConnect(),
+        ...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: isConnected - true');
+    logger.debug('rabbit: old isConnected - true');
     return true;
   }
 
@@ -990,7 +1008,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();
@@ -1014,9 +1031,9 @@ class RabbitMq implements IAfRabbitMq {
             return null;
           }
 
-          const traceId = msg.properties.headers[TRACING_HEADER];
-          const userId = msg.properties.headers[USER_TRACING_HEADER];
-          const automationId = msg.properties.headers[AUTOMATION_ID_HEADER];
+          const traceId = msg.properties.headers![TRACING_HEADER];
+          const userId = msg.properties.headers![USER_TRACING_HEADER];
+          const automationId = msg.properties.headers![AUTOMATION_ID_HEADER];
           const parsedMessage = RabbitMq.parseMsg(msg);
           const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
           const trace = newTrace(traceTypes.RABBIT);
@@ -1098,11 +1115,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) {
@@ -1114,7 +1126,6 @@ class RabbitMq implements IAfRabbitMq {
       throw new Error(`rabbit: couldnt get connection for new channel ${name}`);
     }
 
-    debug('rabbit: getNewChannelOld', { localConnection });
     const channel = localConnection?.createChannel({ ...options });
     once(channel, 'close').then((args) => {
       logger.error(`rabbit: channel ${name} closed`);
@@ -1133,18 +1144,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
@@ -1187,12 +1193,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) {
@@ -1204,6 +1205,9 @@ class RabbitMq implements IAfRabbitMq {
 
       newConnection.on('connectFailed', (err) => {
         this.oldConsumersTags = [];
+        if (typeof err.url === 'string') {
+          err.url = this.maskURL(err.url);
+        }
         logger.error('rabbit: connection connectFailed', { err });
         if (!isResolved) {
           isResolved = true;
@@ -1226,7 +1230,7 @@ class RabbitMq implements IAfRabbitMq {
       newConnection.once('connect', async () => {
         debug('rabbit: connection established');
         connection.creatingConnection = false;
-        this.oldEm.emit(connectionCreatedEventName, connection);
+        this.oldEm.emit(connectionCreatedEventName, newConnection);
         isResolved = true;
         resolve(newConnection);
       });
@@ -1300,11 +1304,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) {
@@ -1313,16 +1312,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);
@@ -1359,6 +1352,17 @@ class RabbitMq implements IAfRabbitMq {
     this.oldExchanges[exchangeName] = await this.oldAssertExchangePromises[exchangeName];
     return this.oldExchanges[exchangeName];
   }
+
+  private maskURL = (url: string): string => {
+    try {
+      const urlObj = new URL(url);
+      urlObj.username = '***';
+      urlObj.password = '***';
+      return urlObj.toString();
+    } catch {
+      return url;
+    }
+  }
 }
 
 export default RabbitMq;

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;

package/src/{mock.ts → mock/index.ts}

@@ -1,6 +1,6 @@
-// eslint-disable-next-line import/no-extraneous-dependencies
+// eslint-disable-next-line import/no-unresolved
 import 'jest';
-import { IAfRabbitMq } from './index';
+import type { IAfRabbitMq } from '../index';
 
 class RabbitMq implements IAfRabbitMq {
   ack: any = jest.fn();

package/src/mock/vitest.ts

@@ -0,0 +1,24 @@
+import { vi } from 'vitest';
+import { IAfRabbitMq } from '../index';
+
+class RabbitMq implements IAfRabbitMq {
+  ack = vi.fn();
+
+  nack = vi.fn();
+
+  assertChannel = vi.fn();
+
+  assertExchange = vi.fn();
+
+  assertQueue = vi.fn();
+
+  consume = vi.fn();
+
+  consumeFromExchange = vi.fn();
+
+  publish = vi.fn();
+
+  sendToQueue = vi.fn();
+}
+
+export default RabbitMq;

package/tsconfig.build.json

@@ -0,0 +1,5 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "src/example.ts", "**/*.test.ts"],
+}

package/tsconfig.json

@@ -9,8 +9,8 @@
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
     "skipLibCheck": true,
-    "types": ["@types/jest"]
+    "sourceMap": true,
   },
   "exclude": ["node_modules"],
-  "include": ["src/**/*.ts"]
+  "include": ["src/", "vitest.config.ts"],
 }

package/vitest.config.ts

@@ -0,0 +1,16 @@
+// eslint-disable-next-line import/no-unresolved
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    coverage: {
+      provider: 'v8',
+      include: ['src/**/*.ts'],
+      exclude: ['src/example.ts', 'src/mock/*.ts'],
+      reporter: 'text',
+      thresholds: {
+        lines: 74,
+      },
+    },
+  },
+});