@autofleet/rabbit 3.4.0-beta--beta--0.0 → 3.4.0-beta.1

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"));
@@ -164,9 +164,23 @@ class RabbitMq {
             }
         };
         this.em = new events_1.EventEmitter();
-        this.channel = null;
+        this.publishChannel = null;
         this.publishChannelSetupPromise = null;
         this.connection = null;
+        this.publishConnection = {
+            connection: null,
+            creatingConnection: false,
+            connectionCreatedEventName: 'publishConnectionCreated',
+            connectionFailedEventName: 'publishConnectionFailed',
+            blockReconnect: false,
+        };
+        this.consumeConnection = {
+            connection: null,
+            creatingConnection: false,
+            connectionCreatedEventName: 'consumeConnectionCreated',
+            connectionFailedEventName: 'consumeConnectionFailed',
+            blockReconnect: false,
+        };
         this.creatingConnection = false;
         this.exchanges = {};
         this.queues = {};
@@ -190,9 +204,22 @@ class RabbitMq {
         }
         // TODO: [QUORUM-PHASE-3] Delete the old properties that we use for the old consumers and publishers
         this.oldEm = new events_1.EventEmitter();
-        this.oldChannel = null;
+        this.oldPublishChannel = null;
         this.oldPublishChannelSetupPromise = null;
-        this.oldConnection = null;
+        this.oldPublishConnection = {
+            connection: null,
+            creatingConnection: false,
+            connectionCreatedEventName: 'publishConnectionCreated',
+            connectionFailedEventName: 'publishConnectionFailed',
+            blockReconnect: false,
+        };
+        this.oldConsumeConnection = {
+            connection: null,
+            creatingConnection: false,
+            connectionCreatedEventName: 'consumeConnectionCreated',
+            connectionFailedEventName: 'consumeConnectionFailed',
+            blockReconnect: false,
+        };
         this.oldCreatingConnection = false;
         this.oldExchanges = {};
         this.oldQueues = {};
@@ -201,30 +228,31 @@ class RabbitMq {
         this.oldConsumers = [];
         this.oldConsumersTags = [];
     }
-    async getConnection() {
+    async getConnection(connection) {
         return new Promise(async (resolve, reject) => {
-            if (this.blockReconnect) {
+            const { connection: connectionLocal, creatingConnection, connectionCreatedEventName, connectionFailedEventName, blockReconnect, } = connection;
+            if (blockReconnect) {
                 debug('rabbit: block reconnect');
                 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                 // @ts-ignore
                 return resolve();
             }
-            if (this.connection !== null) {
-                if (this.options?.disableReconnect || this.connection?.isConnected()) {
+            if (connectionLocal !== null) {
+                if (this.options?.disableReconnect || connectionLocal?.isConnected()) {
                     debug('rabbit: connection - is connected');
                     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                     // @ts-ignore
-                    return resolve(this.connection);
+                    return resolve(connectionLocal);
                 }
                 debug('rabbit: connection - reconnecting');
             }
-            if (this.creatingConnection) {
+            if (creatingConnection) {
                 debug('rabbit: creating connection emi');
-                this.em.once(consts_1.CONNECTION_CREATED_CONST, resolve);
-                this.em.once(consts_1.CONNECTION_FAILED_CONST, reject);
+                this.em.once(connectionCreatedEventName, resolve);
+                this.em.once(connectionFailedEventName, reject);
                 return;
             }
-            this.creatingConnection = true;
+            connection.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
@@ -237,58 +265,58 @@ class RabbitMq {
                 return [`amqp://${userName}:${password}@${host}/${this.vhost}?heartbeat=${HEARTBEAT}`];
             };
             const defaultUrls = findServers();
-            const connection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
+            const newConnection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
                 findServers,
             });
-            this.connection = connection;
-            this.connection.on('error', (err) => {
+            connection.connection = newConnection;
+            newConnection.on('error', (err) => {
                 logger_1.default.error('rabbit: connection error', { err });
                 if (!isResolved) {
                     isResolved = true;
                     reject(err);
-                    this.em.emit(consts_1.CONNECTION_FAILED_CONST, err);
+                    this.em.emit(connectionFailedEventName, err);
                 }
             });
-            this.connection.on('connectFailed', (err) => {
+            newConnection.on('connectFailed', (err) => {
                 this.consumersTags = [];
                 logger_1.default.error('rabbit: connection connectFailed', { err, advice: 'Check if the vhost exist', vhost: this.vhost });
                 if (!isResolved) {
                     isResolved = true;
                     reject(err);
-                    this.em.emit(consts_1.CONNECTION_FAILED_CONST, err);
+                    this.em.emit(connectionFailedEventName, err);
                 }
             });
-            this.connection.on('disconnect', ({ err }) => {
-                // this.channel = null;
+            newConnection.on('disconnect', ({ err }) => {
+                // this.publishChannel = null;
                 this.consumersTags = [];
                 debug('rabbit: connection closed');
                 if (this.options?.disableReconnect) {
                     logger_1.default.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
-                    this.blockReconnect = true;
+                    connection.blockReconnect = true;
                 }
                 else {
                     logger_1.default.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
                 }
             });
-            this.connection.once('connect', async () => {
+            newConnection.once('connect', async () => {
                 debug('rabbit: connection established');
-                this.creatingConnection = false;
-                this.em.emit(consts_1.CONNECTION_CREATED_CONST, connection);
+                connection.creatingConnection = false;
+                this.em.emit(connectionCreatedEventName, connection);
                 isResolved = true;
-                resolve(connection);
+                resolve(newConnection);
             });
         });
     }
-    async getNewChannel({ name = (0, utils_1.rand)().toString(), onClose = null, options = {} } = {}) {
-        let connection;
+    async getNewChannel({ name = (0, utils_1.rand)().toString(), onClose = null, options = {}, connection, }) {
+        let localConnection;
         try {
-            connection = await this.getConnection();
+            localConnection = await this.getConnection(connection);
         }
         catch (e) {
             logger_1.default.error(`rabbit: error on get connection for new channel ${name} `, { e });
             throw e;
         }
-        const channel = connection.createChannel({ ...options });
+        const channel = localConnection.createChannel({ ...options });
         (0, events_1.once)(channel, 'close').then((args) => {
             logger_1.default.error(`rabbit: channel ${name} closed`);
             onClose?.(args);
@@ -303,18 +331,20 @@ class RabbitMq {
             throw err;
         }
     }
-    async assertChannel({ force = false } = {}) {
+    async assertChannel({ force = false, connection }) {
         if (!this.publishChannelSetupPromise) {
             this.publishChannelSetupPromise = new Promise(async (resolve, reject) => {
-                if (this.channel && !force) {
-                    return resolve(this.channel);
+                if (this.publishChannel && !force) {
+                    return resolve(this.publishChannel);
                 }
                 try {
-                    const channel = await this.getNewChannel({});
+                    const channel = await this.getNewChannel({ connection });
                     channel.on('error', (err) => {
                         logger_1.default.error('rabbit: channel error', { err });
                     });
-                    this.channel = channel;
+                    if (this.publishConnection === connection) {
+                        this.publishChannel = channel;
+                    }
                     resolve(channel);
                 }
                 catch (e) {
@@ -324,8 +354,8 @@ class RabbitMq {
         }
         return this.publishChannelSetupPromise;
     }
-    async assertExchange(exchangeName, options) {
-        const channel = await this.assertChannel();
+    async assertExchange(exchangeName, connection) {
+        const channel = await this.assertChannel({ connection });
         if (this.exchanges[exchangeName]) {
             delete this.assertExchangePromises[exchangeName];
             return this.exchanges[exchangeName];
@@ -340,16 +370,16 @@ class RabbitMq {
     // TODO: [QUORUM-PHASE-2] Change the implementation to the new one
     async getQueueLength(queue) {
         RabbitMq.validateName('queue', queue);
-        const { oldChannel: channel } = this;
+        const { oldPublishChannel: channel } = this;
         if (!channel) {
             throw new rabbitError_1.default('channel is not defined');
         }
         debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
         return channel?.checkQueue(queue);
     }
-    async deleteQueue(queue) {
+    async deleteQueue(queue, connection) {
         RabbitMq.validateName('queue', queue);
-        const channel = await this.assertChannel();
+        const channel = await this.assertChannel({ connection });
         logger_1.default.info('rabbit: deleting queue', { queue });
         const deleteQueueRes = await channel.deleteQueue(queue);
         debug('queue deleted', deleteQueueRes);
@@ -357,12 +387,13 @@ class RabbitMq {
     }
     // TODO: [QUORUM-PHASE-2] Change the implementation to the new one
     async bindQueue(queue, exchange) {
-        const channel = await this.assertChannelOld();
+        const channel = await this.assertChannelOld({ connection: this.oldPublishConnection });
         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,
@@ -373,7 +404,7 @@ class RabbitMq {
             },
         };
         try {
-            const channel = await this.assertChannel();
+            const channel = await this.assertChannel({ connection });
             debug('assertQueue->channel.addSetup', { queueName });
             await channel.addSetup(async (setupChannel) => {
                 await setupChannel.assertQueue(queueName, localeOptions);
@@ -385,8 +416,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 });
-                await this.deleteQueue(queueName);
+                const channel = await this.assertChannel({ force: true, connection });
+                await this.deleteQueue(queueName, connection);
                 debug('retrying assertQueue->channel.addSetup', { queueName });
                 await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, localeOptions));
                 debug('retrying assertQueue->channel.assertQueue', { queueName });
@@ -477,7 +508,7 @@ class RabbitMq {
             }
             logger_1.default.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
         }
-        const channel = await this.getNewChannel({});
+        const channel = await this.getNewChannel({ connection: this.consumeConnection });
         return channel.addSetup(async (confirmChannel) => {
             const q = await this.assertQueue(queue, optionsWithDefaults);
             await confirmChannel.prefetch(limit, false);
@@ -565,7 +596,10 @@ class RabbitMq {
         if (options?.isQuorumQueue !== false) {
             await this.assertVHost();
             await this.saveConsumer(queue, callback, options);
-            const channel = await this.getNewChannel({ name: `consume-exchange-${exchange}-queue-${queue}` });
+            const channel = await this.getNewChannel({
+                name: `consume-exchange-${exchange}-queue-${queue}`,
+                connection: this.consumeConnection,
+            });
             await channel.addSetup(async (c) => {
                 const assertExchange = await (0, utils_1.assertExchangeFanout)(c, exchange);
                 await c.assertQueue(queue);
@@ -579,7 +613,10 @@ class RabbitMq {
         }
         // TODO: [QUORUM-PHASE-3] Delete the old implementation
         await this.saveConsumerOld(queue, callback, options);
-        const channelOld = await this.getNewChannelOld({ name: `consume-exchange-${exchange}-queue-${queue}-old` });
+        const channelOld = await this.getNewChannelOld({
+            name: `consume-exchange-${exchange}-queue-${queue}-old`,
+            connection: this.oldConsumeConnection,
+        });
         await channelOld.addSetup(async (c) => {
             const assertExchange = await (0, utils_1.assertExchangeFanout)(c, exchange);
             await c.assertQueue(queue);
@@ -596,8 +633,8 @@ class RabbitMq {
     async publish(exchange, content, customHeaders) {
         return (0, utils_1.wrapSetImmediate)(async () => {
             RabbitMq.validateName('exchange', exchange);
-            const channel = await this.assertChannelOld();
-            await this.assertExchangeOld(exchange);
+            const channel = await this.assertChannelOld({ connection: this.oldPublishConnection });
+            await this.assertExchangeOld(exchange, this.oldPublishConnection);
             await channel.publish(exchange, '', Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
         });
     }
@@ -605,7 +642,7 @@ class RabbitMq {
     // TODO: [QUORUM-PHASE-2] Change the implementation to the new one
     async sendToQueue(queue, content, options, customHeaders) {
         try {
-            await this.assertChannelOld();
+            await this.assertChannelOld({ connection: this.oldPublishConnection });
         }
         catch (e) {
             logger_1.default.error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });
@@ -620,7 +657,7 @@ class RabbitMq {
             throw e;
         }
         try {
-            const res = await this.oldChannel?.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
+            const res = await this.oldPublishChannel?.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
             debug(`rabbit: sending to queue ${queue}`, { res });
             return res;
         }
@@ -630,51 +667,17 @@ class RabbitMq {
             throw e;
         }
     }
-    async sendToCeleryQueue(data, taskName, queueName) {
-        const taskId = (0, node_crypto_1.randomUUID)();
-        // Celery-compatible message body
-        const taskPayload = {
-            task: taskName,
-            id: taskId,
-            args: [data],
-            kwargs: {},
-            retries: 0,
-            eta: null,
-        };
-        // Celery-compatible AMQP headers
-        const publishOptions = {
-            contentType: 'application/json',
-            contentEncoding: 'utf-8',
-            deliveryMode: 2,
-            headers: {
-                lang: 'py',
-                task: taskName,
-                id: taskId,
-                root_id: taskId,
-                parent_id: null,
-                group: null,
-                retries: 0,
-                eta: null,
-            },
-        };
-        try {
-            return await this.sendToQueue(queueName, taskPayload, undefined, publishOptions);
-        }
-        catch (e) {
-            const isConnected = await this.isConnected();
-            logger_1.default.error(`rabbit sendToQueue: failed to send to queue ${queueName}, 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() {
-        const connection = await this.getConnectionOld();
-        const isConnected = connection.isConnected();
+        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_1.default.error('rabbit: isConnected - false');
             return false;
         }
-        const channel = await this.assertChannelOld();
+        const channel = await this.assertChannelOld({ connection: this.oldPublishConnection });
         try {
             await Promise.all([
                 channel.waitForConnect(),
@@ -685,7 +688,7 @@ class RabbitMq {
             logger_1.default.error('rabbit: isConnected - false');
             return false;
         }
-        logger_1.default.info('rabbit: isConnected - true');
+        logger_1.default.debug('rabbit: isConnected - true');
         return true;
     }
     async gracefulShutdown(signal) {
@@ -718,7 +721,7 @@ class RabbitMq {
             }
             logger_1.default.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
         }
-        const channel = await this.getNewChannelOld({});
+        const channel = await this.getNewChannelOld({ connection: this.oldConsumeConnection });
         return channel.addSetup(async (confirmChannel) => {
             const q = await this.assertQueueOld(queue, optionsWithDefaults);
             await confirmChannel.prefetch(limit, false);
@@ -797,16 +800,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 = {} } = {}) {
-        let connection;
+    async getNewChannelOld({ name = (0, utils_1.rand)().toString(), onClose = null, options = {}, connection, }) {
+        let localConnection;
         try {
-            connection = await this.getConnectionOld();
+            localConnection = await this.getConnectionOld(connection);
         }
         catch (e) {
             logger_1.default.error(`rabbit: error on get connection for new channel ${name} `, { e });
             throw e;
         }
-        const channel = connection.createChannel({ ...options });
+        debug('rabbit: getNewChannelOld', { localConnection });
+        const channel = localConnection.createChannel({ ...options });
         (0, events_1.once)(channel, 'close').then((args) => {
             logger_1.default.error(`rabbit: channel ${name} closed`);
             onClose?.(args);
@@ -821,30 +825,32 @@ class RabbitMq {
             throw err;
         }
     }
-    async getConnectionOld() {
+    async getConnectionOld(connection) {
         return new Promise(async (resolve, reject) => {
-            if (this.oldBlockReconnect) {
+            const { connection: connectionLocal, creatingConnection, connectionCreatedEventName, connectionFailedEventName, blockReconnect, } = connection;
+            debug('rabbit: getConnectionOld', { connectionLocal, creatingConnection, blockReconnect });
+            if (blockReconnect) {
                 debug('rabbit: block reconnect');
                 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                 // @ts-ignore
                 return resolve();
             }
-            if (this.oldConnection !== null) {
-                if (this.options?.disableReconnect || this.oldConnection?.isConnected()) {
+            if (connectionLocal !== null) {
+                if (this.options?.disableReconnect || connectionLocal?.isConnected()) {
                     debug('rabbit: connection - is connected');
                     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                     // @ts-ignore
-                    return resolve(this.oldConnection);
+                    return resolve(connectionLocal);
                 }
                 debug('rabbit: connection - reconnecting');
             }
-            if (this.oldCreatingConnection) {
+            if (creatingConnection) {
                 debug('rabbit: creating connection emi');
-                this.oldEm.once(consts_1.CONNECTION_CREATED_CONST, resolve);
-                this.oldEm.once(consts_1.CONNECTION_FAILED_CONST, reject);
+                this.oldEm.once(connectionCreatedEventName, resolve);
+                this.oldEm.once(connectionFailedEventName, reject);
                 return;
             }
-            this.oldCreatingConnection = true;
+            connection.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
@@ -857,44 +863,44 @@ class RabbitMq {
                 return [`amqp://${userName}:${password}@${host}?heartbeat=${HEARTBEAT}`];
             };
             const defaultUrls = findServers();
-            const connection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
+            const newConnection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
                 findServers,
             });
-            this.oldConnection = connection;
-            this.oldConnection.on('error', (err) => {
+            connection.connection = newConnection;
+            newConnection.on('error', (err) => {
                 logger_1.default.error('rabbit: connection error', { err });
                 if (!isResolved) {
                     isResolved = true;
                     reject(err);
-                    this.oldEm.emit(consts_1.CONNECTION_FAILED_CONST, err);
+                    this.oldEm.emit(connectionFailedEventName, err);
                 }
             });
-            this.oldConnection.on('connectFailed', (err) => {
+            newConnection.on('connectFailed', (err) => {
                 this.oldConsumersTags = [];
                 logger_1.default.error('rabbit: connection connectFailed', { err });
                 if (!isResolved) {
                     isResolved = true;
                     reject(err);
-                    this.oldEm.emit(consts_1.CONNECTION_FAILED_CONST, err);
+                    this.oldEm.emit(connectionFailedEventName, err);
                 }
             });
-            this.oldConnection.on('disconnect', ({ err }) => {
+            newConnection.on('disconnect', ({ err }) => {
                 this.oldConsumersTags = [];
                 debug('rabbit: connection closed');
                 if (this.options?.disableReconnect) {
                     logger_1.default.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
-                    this.oldBlockReconnect = true;
+                    connection.blockReconnect = true;
                 }
                 else {
                     logger_1.default.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
                 }
             });
-            this.oldConnection.once('connect', async () => {
+            newConnection.once('connect', async () => {
                 debug('rabbit: connection established');
-                this.oldCreatingConnection = false;
-                this.oldEm.emit(consts_1.CONNECTION_CREATED_CONST, connection);
+                connection.creatingConnection = false;
+                this.oldEm.emit(connectionCreatedEventName, connection);
                 isResolved = true;
-                resolve(connection);
+                resolve(newConnection);
             });
         });
     }
@@ -923,6 +929,7 @@ class RabbitMq {
     }
     async setupQueueOld(queueName, options) {
         let queue;
+        const connection = this.oldPublishConnection;
         const shouldUseQuorum = RabbitMq.shouldUseQuorum(queueName);
         const localeOptions = {
             ...options,
@@ -934,7 +941,7 @@ class RabbitMq {
             },
         };
         try {
-            const channel = await this.assertChannelOld();
+            const channel = await this.assertChannelOld({ connection });
             debug('assertQueue->channel.addSetup', { queueName });
             await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, localeOptions));
             debug('assertQueue->channel.assertQueue', { queueName });
@@ -944,8 +951,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 });
-                await this.deleteQueueOld(queueName);
+                const channel = await this.assertChannelOld({ force: true, connection });
+                await this.deleteQueueOld(queueName, connection);
                 debug('retrying assertQueue->channel.addSetup', { queueName });
                 await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, localeOptions));
                 debug('retrying assertQueue->channel.assertQueue', { queueName });
@@ -958,18 +965,21 @@ class RabbitMq {
         this.oldQueues[queueName] = queue;
         return queue;
     }
-    async assertChannelOld({ force = false } = {}) {
+    async assertChannelOld({ force = false, connection }) {
         if (!this.oldPublishChannelSetupPromise) {
             this.oldPublishChannelSetupPromise = new Promise(async (resolve, reject) => {
-                if (this.oldChannel && !force) {
-                    return resolve(this.oldChannel);
+                if (this.oldPublishChannel && !force) {
+                    return resolve(this.oldPublishChannel);
                 }
                 try {
-                    const channel = await this.getNewChannelOld({});
+                    const channel = await this.getNewChannelOld({ connection });
                     channel.on('error', (err) => {
                         logger_1.default.error('rabbit: channel error', { err });
                     });
-                    this.oldChannel = channel;
+                    if (this.oldPublishConnection === connection) {
+                        debug('rabbit: a new channel assigned to the oldPublishChannel', { connection });
+                        this.oldPublishChannel = channel;
+                    }
                     resolve(channel);
                 }
                 catch (e) {
@@ -979,16 +989,16 @@ class RabbitMq {
         }
         return this.oldPublishChannelSetupPromise;
     }
-    async deleteQueueOld(queue) {
+    async deleteQueueOld(queue, connection) {
         RabbitMq.validateName('queue', queue);
-        const channel = await this.assertChannelOld();
+        const channel = await this.assertChannelOld({ connection });
         logger_1.default.info('rabbit: deleting queue', { queue });
         const deleteQueueRes = await channel.deleteQueue(queue);
         debug('queue deleted', deleteQueueRes);
         return deleteQueueRes;
     }
-    async assertExchangeOld(exchangeName, options) {
-        const channel = await this.assertChannelOld();
+    async assertExchangeOld(exchangeName, connection) {
+        const channel = await this.assertChannelOld({ connection });
         if (this.oldExchanges[exchangeName]) {
             delete this.oldAssertExchangePromises[exchangeName];
             return this.oldExchanges[exchangeName];

package/dist/lib/consts.d.ts

@@ -6,8 +6,6 @@ export declare const USER_TRACING_HEADER = "x-af-user-id";
 export declare const AUTOMATION_ID_HEADER = "x-af-automation-id";
 export declare const USER_OBJECT = "userObject";
 export declare const DEFAULT_USE_CONSUME_WITH_LOCK = false;
-export declare const CONNECTION_CREATED_CONST = "connectionCreated";
-export declare const CONNECTION_FAILED_CONST = "connectionFailed";
 export declare const DEFAULT_OPTIONS: {
     limit: number;
     retries: number;

package/dist/lib/consts.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_OPTIONS = exports.CONNECTION_FAILED_CONST = exports.CONNECTION_CREATED_CONST = exports.DEFAULT_USE_CONSUME_WITH_LOCK = exports.USER_OBJECT = exports.AUTOMATION_ID_HEADER = exports.USER_TRACING_HEADER = exports.TRACING_HEADER = exports.RETRY_HEADER = exports.DEFAULT_LOCK_TIMEOUT = exports.DEFAULT_DEAD_TTL_TWO_DAYS = void 0;
+exports.DEFAULT_OPTIONS = exports.DEFAULT_USE_CONSUME_WITH_LOCK = exports.USER_OBJECT = exports.AUTOMATION_ID_HEADER = exports.USER_TRACING_HEADER = exports.TRACING_HEADER = exports.RETRY_HEADER = exports.DEFAULT_LOCK_TIMEOUT = exports.DEFAULT_DEAD_TTL_TWO_DAYS = void 0;
 exports.DEFAULT_DEAD_TTL_TWO_DAYS = 60000 * 60 * 12;
 exports.DEFAULT_LOCK_TIMEOUT = 1000 * 5;
 exports.RETRY_HEADER = 'x-retry-count';
@@ -9,8 +9,6 @@ exports.USER_TRACING_HEADER = 'x-af-user-id';
 exports.AUTOMATION_ID_HEADER = 'x-af-automation-id';
 exports.USER_OBJECT = 'userObject';
 exports.DEFAULT_USE_CONSUME_WITH_LOCK = false;
-exports.CONNECTION_CREATED_CONST = 'connectionCreated';
-exports.CONNECTION_FAILED_CONST = 'connectionFailed';
 exports.DEFAULT_OPTIONS = {
     limit: 1,
     retries: 1,

package/dist/lib/types.d.ts

@@ -1,3 +1,4 @@
+import { AmqpConnectionManager } from 'amqp-connection-manager';
 import { ConsumeMessage, Options, Replies } from 'amqplib';
 export interface ExchangesCache {
     [key: string]: any;
@@ -42,3 +43,10 @@ export type AfConsumer = {
     options: ConsumeOptions | undefined;
 };
 export declare const CONSUMER_DEFAULT_OPTIONS: Options.Consume;
+export type ConnectionData = {
+    connection: AmqpConnectionManager | null;
+    creatingConnection: boolean;
+    connectionCreatedEventName: string;
+    connectionFailedEventName: string;
+    blockReconnect: boolean;
+};

package/package.json

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