@autofleet/rabbit 3.6.1-beta-e33c35c7.0 → 4.0.0-beta.0

package/dist/index.js

@@ -1,10 +1,10 @@
 "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 };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sendCeleryTaskViaHttp = void 0;
-/* eslint-disable no-empty,consistent-return,no-async-promise-executor,@typescript-eslint/no-unused-vars,no-param-reassign */
 const events_1 = require("events");
 const util_1 = require("util");
 const moment_1 = __importDefault(require("moment"));
@@ -12,6 +12,7 @@ const redis_lock_1 = __importDefault(require("redis-lock"));
 const amqp_connection_manager_1 = require("amqp-connection-manager");
 const zehut_1 = require("@autofleet/zehut");
 const node_crypto_1 = require("node:crypto");
+const axios_1 = __importDefault(require("axios"));
 const logger_1 = __importDefault(require("./logger"));
 const rabbitError_1 = __importDefault(require("./lib/rabbitError"));
 const redis_1 = __importDefault(require("./lib/redis"));
@@ -21,8 +22,6 @@ const types_1 = require("./lib/types");
 // const debug = nodeDebug('af-rabbitmq')
 const debug = logger_1.default.debug.bind(logger_1.default);
 const PUBLISH_TIMEOUT = 1000 * 10;
-// TODO: [QUORUM-PHASE-3] Delete this env var
-const { DISABLE_QUORUM_QUEUES, } = process.env;
 const HEARTBEAT = '60';
 class RabbitMq {
     static parseMsg(msg) {
@@ -62,52 +61,48 @@ class RabbitMq {
         this.DISCONNECT_MSG = 'rabbit: connection disconnect';
         this.RECONNECT_MSG = 'rabbit: connection disconnect - reconnecting';
         this.consumers = [];
-        this.doesVHostExist = false;
-        this.vhost = 'quorum-vhost';
-        this.needsConsumerReestablishment = false;
+        this.isVHostExist = false;
         this.oldConsumers = [];
-        this.oldNeedsConsumerReestablishment = false;
         this.assertVHost = async () => {
-            if (this.doesVHostExist) {
+            if (this.isVHostExist) {
                 return;
             }
-            const username = process.env.RABBITMQ_USERNAME || 'guest';
-            const password = process.env.RABBITMQ_PASSWORD || 'guest';
-            const credentials = Buffer.from(`${username}:${password}`).toString('base64');
-            const headers = {
-                Authorization: `Basic ${credentials}`,
-                'Content-Type': 'application/json',
+            if (!this.options?.vhost) {
+                throw new Error('vhost is not defined');
+            }
+            const { vhost } = this.options;
+            const auth = {
+                auth: {
+                    username: process.env.RABBITMQ_USERNAME || 'guest',
+                    password: process.env.RABBITMQ_PASSWORD || 'guest',
+                },
             };
-            const rabbitHost = `http://${(this.options?.rabbitHost || process.env.RABBITMQ_SERVICE_HOST || 'localhost').split(':')[0]}:15672`;
-            const url = `${rabbitHost}/api/vhosts/${encodeURIComponent(this.vhost)}`;
+            const rabbitHost = `http://${(this.options.rabbitHost || process.env.RABBITMQ_SERVICE_HOST || 'localhost').split(':')[0]}:15672`;
             try {
-                const response = await fetch(url, {
-                    method: 'GET',
-                    headers,
-                });
-                if (response.status === 200) {
-                    this.doesVHostExist = true;
-                    logger_1.default.info('Vhost exists', { vhost: this.vhost });
-                    return;
-                }
-                if (response.status !== 404) {
-                    logger_1.default.error('Failed to check vhost', { response });
-                    throw new rabbitError_1.default('Failed to check vhost');
-                }
-                const createResponse = await fetch(url, {
-                    method: 'PUT',
-                    headers,
-                    body: JSON.stringify({ default_queue_type: 'quorum' }),
-                });
-                if (!createResponse.ok) {
-                    logger_1.default.error('Failed to create vhost', { response: createResponse });
-                    throw new rabbitError_1.default('Failed to create vhost');
+                const response = await axios_1.default.get(`${rabbitHost}/api/vhosts/${encodeURIComponent(vhost)}`, auth);
+                if (response.status !== 200) {
+                    throw new Error('Failed to check vhost');
                 }
-                this.doesVHostExist = true;
-                logger_1.default.info('Vhost created', { vhost: this.vhost });
+                this.isVHostExist = true;
+                logger_1.default.info('Vhost exists', { vhost });
             }
             catch (error) {
-                logger_1.default.error('Failed to check or create vhost', { error });
+                // If the vhost does not exist, create it
+                if (error instanceof axios_1.default.AxiosError && error.response?.status === 404) {
+                    try {
+                        await axios_1.default.put(`${rabbitHost}/api/vhosts/${encodeURIComponent(vhost)}`, {
+                            default_queue_type: 'quorum',
+                        }, auth);
+                        this.isVHostExist = true;
+                        logger_1.default.info('Vhost created', { vhost: this.options?.vhost });
+                        return;
+                    }
+                    catch (createError) {
+                        logger_1.default.error('Failed to create vhost', { error: createError });
+                        throw createError;
+                    }
+                }
+                logger_1.default.error('Failed to check vhost', { error });
                 throw error;
             }
         };
@@ -140,11 +135,11 @@ class RabbitMq {
             await this.unlockRedisIfNeeded(releaseLock);
             if (channel && msg) {
                 if (!skipRetry
-                    && (!msg.properties.headers?.[consts_1.RETRY_HEADER]
+                    && (!msg.properties.headers[consts_1.RETRY_HEADER]
                         || parseInt(msg.properties.headers[consts_1.RETRY_HEADER], 10) < options.retries)) {
                     await this.sendToQueue(queue, RabbitMq.parseMsg(msg).content, options, {
                         ...msg.properties.headers,
-                        [consts_1.RETRY_HEADER]: msg.properties.headers?.[consts_1.RETRY_HEADER]
+                        [consts_1.RETRY_HEADER]: msg.properties.headers[consts_1.RETRY_HEADER]
                             ? msg.properties.headers[consts_1.RETRY_HEADER] + 1
                             : 1,
                     });
@@ -153,7 +148,7 @@ class RabbitMq {
                     const deadQueue = `${queue}-dead`;
                     await this.sendToQueue(deadQueue, RabbitMq.parseMsg(msg).content, deadQueueOptions, {
                         ...msg.properties.headers,
-                        [consts_1.RETRY_HEADER]: msg.properties.headers?.[consts_1.RETRY_HEADER]
+                        [consts_1.RETRY_HEADER]: msg.properties.headers[consts_1.RETRY_HEADER]
                             ? msg.properties.headers[consts_1.RETRY_HEADER] + 1
                             : 1,
                     });
@@ -167,34 +162,10 @@ class RabbitMq {
                 });
             }
         };
-        this.maskURL = (url) => {
-            try {
-                const urlObj = new URL(url);
-                urlObj.username = '***';
-                urlObj.password = '***';
-                return urlObj.toString();
-            }
-            catch {
-                return url;
-            }
-        };
         this.em = new events_1.EventEmitter();
-        this.publishChannel = null;
+        this.channel = null;
         this.publishChannelSetupPromise = null;
-        this.publishConnection = {
-            amqpConnection: null,
-            creatingConnection: false,
-            connectionCreatedEventName: 'publishConnectionCreated',
-            connectionFailedEventName: 'publishConnectionFailed',
-            blockReconnect: false,
-        };
-        this.consumeConnection = {
-            amqpConnection: null,
-            creatingConnection: false,
-            connectionCreatedEventName: 'consumeConnectionCreated',
-            connectionFailedEventName: 'consumeConnectionFailed',
-            blockReconnect: false,
-        };
+        this.connection = null;
         this.creatingConnection = false;
         this.exchanges = {};
         this.queues = {};
@@ -202,6 +173,9 @@ class RabbitMq {
         this.assertExchangePromises = {};
         this.consumers = [];
         this.options = options;
+        if (!options?.vhost) {
+            this.options.vhost = process.env.VHOST_NAME || 'quorum-vhost';
+        }
         this.redisClient = redisConfig && (0, redis_1.default)(redisConfig);
         if (this.redisClient) {
             this.redisLock = (0, util_1.promisify)((0, redis_lock_1.default)(this.redisClient));
@@ -216,24 +190,11 @@ class RabbitMq {
                 await this.gracefulShutdown('SIGINT');
             });
         }
-        // TODO: [QUORUM-PHASE-3] Delete the old properties that we use for the old consumers and publishers
+        // TODO: DELETE OLD PROPERTIES
         this.oldEm = new events_1.EventEmitter();
-        this.oldPublishChannel = null;
+        this.oldChannel = null;
         this.oldPublishChannelSetupPromise = null;
-        this.oldPublishConnection = {
-            amqpConnection: null,
-            creatingConnection: false,
-            connectionCreatedEventName: 'oldPublishConnectionCreated',
-            connectionFailedEventName: 'oldPublishConnectionFailed',
-            blockReconnect: false,
-        };
-        this.oldConsumeConnection = {
-            amqpConnection: null,
-            creatingConnection: false,
-            connectionCreatedEventName: 'oldConsumeConnectionCreated',
-            connectionFailedEventName: 'oldConsumeConnectionFailed',
-            blockReconnect: false,
-        };
+        this.oldConnection = null;
         this.oldCreatingConnection = false;
         this.oldExchanges = {};
         this.oldQueues = {};
@@ -242,31 +203,30 @@ class RabbitMq {
         this.oldConsumers = [];
         this.oldConsumersTags = [];
     }
-    async getConnection(connection) {
+    async getConnection() {
         return new Promise(async (resolve, reject) => {
-            const { amqpConnection: connectionLocal, creatingConnection, connectionCreatedEventName, connectionFailedEventName, blockReconnect, } = connection;
-            if (blockReconnect) {
+            if (this.blockReconnect) {
                 debug('rabbit: block reconnect');
                 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                 // @ts-ignore
                 return resolve();
             }
-            if (connectionLocal !== null) {
-                if (this.options?.disableReconnect || connectionLocal?.isConnected()) {
+            if (this.connection !== null) {
+                if (this.options?.disableReconnect || this.connection?.isConnected()) {
                     debug('rabbit: connection - is connected');
                     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                     // @ts-ignore
-                    return resolve(connectionLocal);
+                    return resolve(this.connection);
                 }
                 debug('rabbit: connection - reconnecting');
             }
-            if (creatingConnection) {
+            if (this.creatingConnection) {
                 debug('rabbit: creating connection emi');
-                this.em.once(connectionCreatedEventName, resolve);
-                this.em.once(connectionFailedEventName, reject);
+                this.em.once(consts_1.CONNECTION_CREATED_CONST, resolve);
+                this.em.once(consts_1.CONNECTION_FAILED_CONST, reject);
                 return;
             }
-            connection.creatingConnection = true;
+            this.creatingConnection = true;
             let isResolved = false;
             // It is import to use it as a function and not as a variable
             // because of k8s changes the env variables
@@ -276,82 +236,61 @@ class RabbitMq {
                 const password = process.env.RABBITMQ_PASSWORD || 'guest';
                 const host = this.options?.rabbitHost || process.env.RABBITMQ_SERVICE_HOST || 'localhost';
                 debug('rabbit: creating connection', { host, userName, HEARTBEAT });
-                return [`amqp://${userName}:${password}@${host}/${this.vhost}?heartbeat=${HEARTBEAT}`];
+                return [`amqp://${userName}:${password}@${host}/${this.options?.vhost}?heartbeat=${HEARTBEAT}`];
             };
             const defaultUrls = findServers();
-            const newConnection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
+            const connection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
                 findServers,
             });
-            connection.amqpConnection = newConnection;
-            newConnection.on('error', (err) => {
+            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(connectionFailedEventName, err);
+                    this.em.emit(consts_1.CONNECTION_FAILED_CONST, err);
                 }
             });
-            newConnection.on('connectFailed', (err) => {
+            this.connection.on('connectFailed', (err) => {
                 this.consumersTags = [];
-                if (typeof err.url === 'string') {
-                    err.url = this.maskURL(err.url);
-                }
-                logger_1.default.error('rabbit: connection connectFailed', { err, advice: 'Check if the vhost exist', vhost: this.vhost });
+                logger_1.default.error('rabbit: connection connectFailed', { err, advice: 'Check if the vhost exist', vhost: this.options?.vhost });
                 if (!isResolved) {
                     isResolved = true;
                     reject(err);
-                    this.em.emit(connectionFailedEventName, err);
+                    this.em.emit(consts_1.CONNECTION_FAILED_CONST, err);
                 }
             });
-            newConnection.on('disconnect', ({ err }) => {
-                this.publishChannel = null;
-                this.publishChannelSetupPromise = null;
+            this.connection.on('disconnect', ({ err }) => {
+                // this.channel = null;
                 this.consumersTags = [];
-                if (this.consumers.length > 0) {
-                    this.needsConsumerReestablishment = true;
-                }
                 debug('rabbit: connection closed');
                 if (this.options?.disableReconnect) {
                     logger_1.default.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
-                    connection.blockReconnect = true;
+                    this.blockReconnect = true;
                 }
                 else {
                     logger_1.default.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
                 }
             });
-            newConnection.once('connect', async () => {
+            this.connection.once('connect', async () => {
                 debug('rabbit: connection established');
-                connection.creatingConnection = false;
-                this.em.emit(connectionCreatedEventName, newConnection);
+                this.creatingConnection = false;
+                this.em.emit(consts_1.CONNECTION_CREATED_CONST, connection);
                 isResolved = true;
-                resolve(newConnection);
-                // Re-establish consumers after reconnection
-                if (connection === this.consumeConnection && this.needsConsumerReestablishment) {
-                    logger_1.default.info(`rabbit: re-establishing ${this.consumers.length} consumers after reconnection`);
-                    const reestablishPromises = this.consumers.map(async (consumer) => {
-                        try {
-                            await this.consumeFromRabbit(consumer.queue, consumer.callback, consumer.options);
-                        }
-                        catch (e) {
-                            logger_1.default.error(`rabbit: failed to re-establish consumer for queue ${consumer.queue}`, { e });
-                        }
-                    });
-                    await Promise.all(reestablishPromises);
-                    this.needsConsumerReestablishment = false;
-                }
+                resolve(connection);
             });
         });
     }
-    async getNewChannel({ name = (0, utils_1.rand)().toString(), onClose = null, options = {}, connection, }) {
-        let localConnection;
+    async getNewChannel({ name = (0, utils_1.rand)().toString(), onClose = null, options = {} } = {}) {
+        let connection;
         try {
-            localConnection = await this.getConnection(connection);
+            connection = await this.getConnection();
         }
         catch (e) {
             logger_1.default.error(`rabbit: error on get connection for new channel ${name} `, { e });
             throw e;
         }
-        const channel = localConnection?.createChannel({ ...options });
+        const channel = connection.createChannel({ ...options });
         (0, events_1.once)(channel, 'close').then((args) => {
             logger_1.default.error(`rabbit: channel ${name} closed`);
             onClose?.(args);
@@ -366,39 +305,29 @@ class RabbitMq {
             throw err;
         }
     }
-    async assertChannel({ force = false, connection }) {
-        if (!this.publishChannelSetupPromise || force) {
+    async assertChannel({ force = false } = {}) {
+        if (!this.publishChannelSetupPromise) {
             this.publishChannelSetupPromise = new Promise(async (resolve, reject) => {
-                if (this.publishChannel && !force && connection.amqpConnection?.isConnected()) {
-                    return resolve(this.publishChannel);
+                if (this.channel && !force) {
+                    return resolve(this.channel);
                 }
                 try {
-                    const channel = await this.getNewChannel({ connection });
+                    const channel = await this.getNewChannel({});
                     channel.on('error', (err) => {
                         logger_1.default.error('rabbit: channel error', { err });
-                        this.publishChannel = null;
-                        this.publishChannelSetupPromise = null;
-                    });
-                    channel.on('close', () => {
-                        logger_1.default.error('rabbit: channel closed');
-                        this.publishChannel = null;
-                        this.publishChannelSetupPromise = null;
                     });
-                    if (this.publishConnection === connection) {
-                        this.publishChannel = channel;
-                    }
+                    this.channel = channel;
                     resolve(channel);
                 }
                 catch (e) {
-                    this.publishChannelSetupPromise = null;
                     reject(e);
                 }
             });
         }
         return this.publishChannelSetupPromise;
     }
-    async assertExchange(exchangeName, connection) {
-        const channel = await this.assertChannel({ connection });
+    async assertExchange(exchangeName, options) {
+        const channel = await this.assertChannel();
         if (this.exchanges[exchangeName]) {
             delete this.assertExchangePromises[exchangeName];
             return this.exchanges[exchangeName];
@@ -410,33 +339,32 @@ class RabbitMq {
         this.exchanges[exchangeName] = await this.assertExchangePromises[exchangeName];
         return this.exchanges[exchangeName];
     }
-    // TODO: [QUORUM-PHASE-2] Change the implementation to the new one
+    // TODO: Change the implementation to the new one
     async getQueueLength(queue) {
         RabbitMq.validateName('queue', queue);
-        const { oldPublishChannel: channel } = this;
+        const { oldChannel: channel } = this;
         if (!channel) {
-            throw new rabbitError_1.default('channel is not defined');
+            throw new Error('channel is not defined');
         }
-        debug('rabbit: getting queue length', { queue, connected: this.oldPublishConnection.amqpConnection?.isConnected() });
+        debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
         return channel?.checkQueue(queue);
     }
-    async deleteQueue(queue, connection) {
+    async deleteQueue(queue) {
         RabbitMq.validateName('queue', queue);
-        const channel = await this.assertChannel({ connection });
+        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;
     }
-    // TODO: [QUORUM-PHASE-2] Change the implementation to the new one
+    // TODO: Change the implementation to the new one
     async bindQueue(queue, exchange) {
-        const channel = await this.assertChannelOld({ connection: this.oldPublishConnection });
+        const channel = await this.assertChannelOld();
         await channel.addSetup((setupChannel) => setupChannel.bindQueue(queue, exchange, ''));
         return channel.bindQueue(queue, exchange, '');
     }
     async setupQueue(queueName, options) {
         let queue;
-        const connection = this.publishConnection;
         const localeOptions = {
             ...options,
             durable: true,
@@ -447,7 +375,7 @@ class RabbitMq {
             },
         };
         try {
-            const channel = await this.assertChannel({ connection });
+            const channel = await this.assertChannel();
             debug('assertQueue->channel.addSetup', { queueName });
             await channel.addSetup(async (setupChannel) => {
                 await setupChannel.assertQueue(queueName, localeOptions);
@@ -459,8 +387,8 @@ class RabbitMq {
             logger_1.default.error('rabbit: assertQueue error', { queueName, options, error: e });
             if (!this.options?.dontRetryAssert) {
                 debug('retrying assertQueue', { queueName });
-                const channel = await this.assertChannel({ force: true, connection });
-                await this.deleteQueue(queueName, connection);
+                const channel = await this.assertChannel({ force: true });
+                await this.deleteQueue(queueName);
                 debug('retrying assertQueue->channel.addSetup', { queueName });
                 await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, localeOptions));
                 debug('retrying assertQueue->channel.assertQueue', { queueName });
@@ -473,7 +401,7 @@ class RabbitMq {
         this.queues[queueName] = queue;
         return queue;
     }
-    // TODO: [QUORUM-PHASE-3] Can be deleted after deleting the old consumers and publishers because all the queues are created us quorum queues
+    // TODO: Can be deleted after deleting the old consumers
     static shouldUseQuorum(queueName) {
         const envQuorumQueuesWhitelist = process.env.QUORUM_QUEUES_WHITELIST;
         if (envQuorumQueuesWhitelist === '*') {
@@ -510,18 +438,18 @@ class RabbitMq {
     }
     // Used by the microservices to consume messages from the queue
     async consume(queue, callback, options) {
-        // TODO: [QUORUM-PHASE-3] Use only the implementation of consumeNew and delete consumeNew and consumeOld
-        if (options?.isQuorumQueue !== false && DISABLE_QUORUM_QUEUES !== 'true') {
+        // TODO: USE THE IMPLEMENTATION OF THE NEW CONSUME AND DELETE THE NEW AND OLD
+        if (options?.isQuorumQueue !== false) {
             await this.assertVHost();
             await this.consumeNew(queue, callback, options);
         }
         await this.consumeOld(queue, callback, options);
     }
-    // TODO: [QUORUM-PHASE-3] Delete consumeNew we do not use it anymore
+    // TODO: DELETE
     async consumeNew(queue, callback, options) {
         await this.consumeFromRabbit(queue, callback, options);
     }
-    // TODO: [QUORUM-PHASE-3] Delete consumeOld we do not use it anymore
+    // TODO: DELETE
     async consumeOld(queue, callback, options) {
         await this.consumeFromRabbitOld(queue, callback, options);
     }
@@ -547,11 +475,11 @@ class RabbitMq {
         const { limit, deadMessageTtl, useConsumeWithLock, lockTimeout, auditContext, enableRabbitTrace, } = optionsWithDefaults;
         if (useConsumeWithLock) {
             if (!this.redisLock) {
-                throw new rabbitError_1.default('Usage of consumeWithLock requires RedisInstance');
+                throw new Error('Usage of consumeWithLock requires RedisInstance');
             }
             logger_1.default.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
         }
-        const channel = await this.getNewChannel({ connection: this.consumeConnection });
+        const channel = await this.getNewChannel({});
         return channel.addSetup(async (confirmChannel) => {
             const q = await this.assertQueue(queue, optionsWithDefaults);
             await confirmChannel.prefetch(limit, false);
@@ -635,14 +563,10 @@ class RabbitMq {
         RabbitMq.validateName('exchange', exchange);
         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 && DISABLE_QUORUM_QUEUES !== 'true') {
+        if (options?.isQuorumQueue !== false) {
             await this.assertVHost();
             await this.saveConsumer(queue, callback, options);
-            const channel = await this.getNewChannel({
-                name: `consume-exchange-${exchange}-queue-${queue}`,
-                connection: this.consumeConnection,
-            });
+            const channel = await this.getNewChannel({ name: `consume-exchange-${exchange}-queue-${queue}` });
             await channel.addSetup(async (c) => {
                 const assertExchange = await (0, utils_1.assertExchangeFanout)(c, exchange);
                 await c.assertQueue(queue);
@@ -654,12 +578,9 @@ class RabbitMq {
                 ]);
             });
         }
-        // TODO: [QUORUM-PHASE-3] Delete the old implementation
+        // TODO: DELETE OLD
         await this.saveConsumerOld(queue, callback, options);
-        const channelOld = await this.getNewChannelOld({
-            name: `consume-exchange-${exchange}-queue-${queue}-old`,
-            connection: this.oldConsumeConnection,
-        });
+        const channelOld = await this.getNewChannelOld({ name: `consume-exchange-${exchange}-queue-${queue}-old` });
         await channelOld.addSetup(async (c) => {
             const assertExchange = await (0, utils_1.assertExchangeFanout)(c, exchange);
             await c.assertQueue(queue);
@@ -672,20 +593,20 @@ class RabbitMq {
         });
     }
     // Used by the microservices to publish messages to the exchange
-    // TODO: [QUORUM-PHASE-2] Change the implementation to the new one
+    // TODO: Change the implementation to the new one
     async publish(exchange, content, customHeaders) {
         return (0, utils_1.wrapSetImmediate)(async () => {
             RabbitMq.validateName('exchange', exchange);
-            const channel = await this.assertChannelOld({ connection: this.oldPublishConnection });
-            await this.assertExchangeOld(exchange, this.oldPublishConnection);
+            const channel = await this.assertChannelOld();
+            await this.assertExchangeOld(exchange);
             await channel.publish(exchange, '', Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
         });
     }
     // Used by the microservices to send messages to the queue
-    // TODO: [QUORUM-PHASE-2] Change the implementation to the new one
+    // TODO: Change the implementation to the new one
     async sendToQueue(queue, content, options, customHeaders) {
         try {
-            await this.assertChannelOld({ connection: this.oldPublishConnection });
+            await this.assertChannelOld();
         }
         catch (e) {
             logger_1.default.error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });
@@ -700,7 +621,7 @@ class RabbitMq {
             throw e;
         }
         try {
-            const res = await this.oldPublishChannel?.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
+            const res = await this.oldChannel?.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
             debug(`rabbit: sending to queue ${queue}`, { res });
             return res;
         }
@@ -710,32 +631,30 @@ class RabbitMq {
             throw e;
         }
     }
-    // TODO: [QUORUM-PHASE-2] After changing the publish from old to new change from the old to the new implementation
+    // TODO: After changing the publish to the new implementation change the from the old to the new
     async isConnected() {
-        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: old isConnected - false');
+        const connection = await this.getConnectionOld();
+        const isConnected = connection.isConnected();
+        if (!isConnected) {
+            logger_1.default.error('rabbit: isConnected - false');
             return false;
         }
-        const oldChannel = await this.assertChannelOld({ connection: this.oldPublishConnection });
+        const channel = await this.assertChannelOld();
         try {
             await Promise.all([
-                oldChannel.waitForConnect(),
-                ...this.oldConsumers.map((c) => oldChannel.checkQueue(c.queue)),
+                channel.waitForConnect(),
+                ...this.oldConsumers.map((c) => channel.checkQueue(c.queue)),
             ]);
         }
         catch (e) {
-            logger_1.default.error('rabbit: old isConnected - false');
+            logger_1.default.error('rabbit: isConnected - false');
             return false;
         }
-        logger_1.default.debug('rabbit: old isConnected - true');
+        logger_1.default.info('rabbit: isConnected - true');
         return true;
     }
     async gracefulShutdown(signal) {
-        // TODO: [QUORUM-PHASE-2] After changing the publish from old to new change from the old to the new implementation
+        // TODO: DELETE OLD
         const tagsNumber = this.consumersTags.length + this.oldConsumersTags.length;
         logger_1.default.info(`rabbit: [gracefully-shutdown] received ${signal}! canceling #${tagsNumber} tags...`);
         const cancelTagPromises = this.consumersTags.map(([channel, tag]) => channel.cancel(tag));
@@ -760,11 +679,11 @@ class RabbitMq {
         const { limit, deadMessageTtl, useConsumeWithLock, lockTimeout, auditContext, enableRabbitTrace, } = optionsWithDefaults;
         if (useConsumeWithLock) {
             if (!this.redisLock) {
-                throw new rabbitError_1.default('Usage of consumeWithLock requires RedisInstance');
+                throw new Error('Usage of consumeWithLock requires RedisInstance');
             }
             logger_1.default.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
         }
-        const channel = await this.getNewChannelOld({ connection: this.oldConsumeConnection });
+        const channel = await this.getNewChannelOld({});
         return channel.addSetup(async (confirmChannel) => {
             const q = await this.assertQueueOld(queue, optionsWithDefaults);
             await confirmChannel.prefetch(limit, false);
@@ -842,20 +761,17 @@ 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;
+    // TODO: DELETE OLD PROPERTIES UNDER THIS LINE
+    async getNewChannelOld({ name = (0, utils_1.rand)().toString(), onClose = null, options = {} } = {}) {
+        let connection;
         try {
-            localConnection = await this.getConnectionOld(connection);
+            connection = await this.getConnectionOld();
         }
         catch (e) {
             logger_1.default.error(`rabbit: error on get connection for new channel ${name} `, { e });
             throw e;
         }
-        if (!localConnection) {
-            throw new Error(`rabbit: couldnt get connection for new channel ${name}`);
-        }
-        const channel = localConnection?.createChannel({ ...options });
+        const channel = connection.createChannel({ ...options });
         (0, events_1.once)(channel, 'close').then((args) => {
             logger_1.default.error(`rabbit: channel ${name} closed`);
             onClose?.(args);
@@ -870,31 +786,30 @@ class RabbitMq {
             throw err;
         }
     }
-    async getConnectionOld(connection) {
+    async getConnectionOld() {
         return new Promise(async (resolve, reject) => {
-            const { amqpConnection: connectionLocal, creatingConnection, connectionCreatedEventName, connectionFailedEventName, blockReconnect, } = connection;
-            if (blockReconnect) {
+            if (this.oldBlockReconnect) {
                 debug('rabbit: block reconnect');
                 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                 // @ts-ignore
                 return resolve();
             }
-            if (connectionLocal !== null) {
-                if (this.options?.disableReconnect || connectionLocal?.isConnected()) {
+            if (this.oldConnection !== null) {
+                if (this.options?.disableReconnect || this.oldConnection?.isConnected()) {
                     debug('rabbit: connection - is connected');
                     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                     // @ts-ignore
-                    return resolve(connectionLocal);
+                    return resolve(this.oldConnection);
                 }
                 debug('rabbit: connection - reconnecting');
             }
-            if (creatingConnection) {
+            if (this.oldCreatingConnection) {
                 debug('rabbit: creating connection emi');
-                this.oldEm.once(connectionCreatedEventName, resolve);
-                this.oldEm.once(connectionFailedEventName, reject);
+                this.oldEm.once(consts_1.CONNECTION_CREATED_CONST, resolve);
+                this.oldEm.once(consts_1.CONNECTION_FAILED_CONST, reject);
                 return;
             }
-            connection.creatingConnection = true;
+            this.oldCreatingConnection = true;
             let isResolved = false;
             // It is import to use it as a function and not as a variable
             // because of k8s changes the env variables
@@ -907,66 +822,44 @@ class RabbitMq {
                 return [`amqp://${userName}:${password}@${host}?heartbeat=${HEARTBEAT}`];
             };
             const defaultUrls = findServers();
-            const newConnection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
+            const connection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
                 findServers,
             });
-            connection.amqpConnection = newConnection;
-            newConnection.on('error', (err) => {
+            this.oldConnection = connection;
+            this.oldConnection.on('error', (err) => {
                 logger_1.default.error('rabbit: connection error', { err });
                 if (!isResolved) {
                     isResolved = true;
                     reject(err);
-                    this.oldEm.emit(connectionFailedEventName, err);
+                    this.oldEm.emit(consts_1.CONNECTION_FAILED_CONST, err);
                 }
             });
-            newConnection.on('connectFailed', (err) => {
+            this.oldConnection.on('connectFailed', (err) => {
                 this.oldConsumersTags = [];
-                if (typeof err.url === 'string') {
-                    err.url = this.maskURL(err.url);
-                }
                 logger_1.default.error('rabbit: connection connectFailed', { err });
                 if (!isResolved) {
                     isResolved = true;
                     reject(err);
-                    this.oldEm.emit(connectionFailedEventName, err);
+                    this.oldEm.emit(consts_1.CONNECTION_FAILED_CONST, err);
                 }
             });
-            newConnection.on('disconnect', ({ err }) => {
-                this.oldPublishChannel = null;
-                this.oldPublishChannelSetupPromise = null;
+            this.oldConnection.on('disconnect', ({ err }) => {
                 this.oldConsumersTags = [];
-                if (this.oldConsumers.length > 0) {
-                    this.oldNeedsConsumerReestablishment = true;
-                }
                 debug('rabbit: connection closed');
                 if (this.options?.disableReconnect) {
                     logger_1.default.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
-                    connection.blockReconnect = true;
+                    this.oldBlockReconnect = true;
                 }
                 else {
                     logger_1.default.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
                 }
             });
-            newConnection.once('connect', async () => {
+            this.oldConnection.once('connect', async () => {
                 debug('rabbit: connection established');
-                connection.creatingConnection = false;
-                this.oldEm.emit(connectionCreatedEventName, newConnection);
+                this.oldCreatingConnection = false;
+                this.oldEm.emit(consts_1.CONNECTION_CREATED_CONST, connection);
                 isResolved = true;
-                resolve(newConnection);
-                // Re-establish old consumers after reconnection
-                if (connection === this.oldConsumeConnection && this.oldNeedsConsumerReestablishment) {
-                    logger_1.default.info(`rabbit: re-establishing ${this.oldConsumers.length} old consumers after reconnection`);
-                    const reestablishPromises = this.oldConsumers.map(async (consumer) => {
-                        try {
-                            await this.consumeFromRabbitOld(consumer.queue, consumer.callback, consumer.options);
-                        }
-                        catch (e) {
-                            logger_1.default.error(`rabbit: failed to re-establish old consumer for queue ${consumer.queue}`, { e });
-                        }
-                    });
-                    await Promise.all(reestablishPromises);
-                    this.oldNeedsConsumerReestablishment = false;
-                }
+                resolve(connection);
             });
         });
     }
@@ -995,7 +888,6 @@ class RabbitMq {
     }
     async setupQueueOld(queueName, options) {
         let queue;
-        const connection = this.oldPublishConnection;
         const shouldUseQuorum = RabbitMq.shouldUseQuorum(queueName);
         const localeOptions = {
             ...options,
@@ -1007,7 +899,7 @@ class RabbitMq {
             },
         };
         try {
-            const channel = await this.assertChannelOld({ connection });
+            const channel = await this.assertChannelOld();
             debug('assertQueue->channel.addSetup', { queueName });
             await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, localeOptions));
             debug('assertQueue->channel.assertQueue', { queueName });
@@ -1017,8 +909,8 @@ class RabbitMq {
             logger_1.default.error('rabbit: assertQueue error', { queueName, options, error: e });
             if (!this.options?.dontRetryAssert) {
                 debug('retrying assertQueue', { queueName });
-                const channel = await this.assertChannelOld({ force: true, connection });
-                await this.deleteQueueOld(queueName, connection);
+                const channel = await this.assertChannelOld({ force: true });
+                await this.deleteQueueOld(queueName);
                 debug('retrying assertQueue->channel.addSetup', { queueName });
                 await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, localeOptions));
                 debug('retrying assertQueue->channel.assertQueue', { queueName });
@@ -1031,47 +923,37 @@ class RabbitMq {
         this.oldQueues[queueName] = queue;
         return queue;
     }
-    async assertChannelOld({ force = false, connection }) {
-        if (!this.oldPublishChannelSetupPromise || force) {
+    async assertChannelOld({ force = false } = {}) {
+        if (!this.oldPublishChannelSetupPromise) {
             this.oldPublishChannelSetupPromise = new Promise(async (resolve, reject) => {
-                if (this.oldPublishChannel && !force && connection.amqpConnection?.isConnected()) {
-                    return resolve(this.oldPublishChannel);
+                if (this.oldChannel && !force) {
+                    return resolve(this.oldChannel);
                 }
                 try {
-                    const channel = await this.getNewChannelOld({ connection });
+                    const channel = await this.getNewChannelOld({});
                     channel.on('error', (err) => {
                         logger_1.default.error('rabbit: channel error', { err });
-                        this.oldPublishChannel = null;
-                        this.oldPublishChannelSetupPromise = null;
                     });
-                    channel.on('close', () => {
-                        logger_1.default.error('rabbit: channel closed');
-                        this.oldPublishChannel = null;
-                        this.oldPublishChannelSetupPromise = null;
-                    });
-                    if (this.oldPublishConnection === connection) {
-                        this.oldPublishChannel = channel;
-                    }
+                    this.oldChannel = channel;
                     resolve(channel);
                 }
                 catch (e) {
-                    this.oldPublishChannelSetupPromise = null;
                     reject(e);
                 }
             });
         }
         return this.oldPublishChannelSetupPromise;
     }
-    async deleteQueueOld(queue, connection) {
+    async deleteQueueOld(queue) {
         RabbitMq.validateName('queue', queue);
-        const channel = await this.assertChannelOld({ connection });
+        const channel = await this.assertChannelOld();
         logger_1.default.info('rabbit: deleting queue', { queue });
         const deleteQueueRes = await channel.deleteQueue(queue);
         debug('queue deleted', deleteQueueRes);
         return deleteQueueRes;
     }
-    async assertExchangeOld(exchangeName, connection) {
-        const channel = await this.assertChannelOld({ connection });
+    async assertExchangeOld(exchangeName, options) {
+        const channel = await this.assertChannelOld();
         if (this.oldExchanges[exchangeName]) {
             delete this.oldAssertExchangePromises[exchangeName];
             return this.oldExchanges[exchangeName];
@@ -1087,4 +969,3 @@ class RabbitMq {
 exports.default = RabbitMq;
 var celery_1 = require("./lib/celery");
 Object.defineProperty(exports, "sendCeleryTaskViaHttp", { enumerable: true, get: function () { return celery_1.sendCeleryTaskViaHttp; } });
-//# sourceMappingURL=index.js.map