@autofleet/rabbit 3.2.26-beta.3 → 3.3.0-beta.0

package/dist/index.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendCeleryTaskViaHttp = void 0;
 const events_1 = require("events");
 const util_1 = require("util");
 const moment_1 = __importDefault(require("moment"));
@@ -117,28 +116,15 @@ class RabbitMq {
             }
         };
         this.em = new events_1.EventEmitter();
-        this.publishChannel = null;
-        this.publishChannelSetupPromise = null;
-        this.connectionsMap = {
-            [consts_1.ConnectionPurpose.Consume]: {
-                connection: null,
-                creatingConnection: false,
-                connectionCreatedEventName: 'consumeConnectionCreated',
-                connectionFailedEventName: 'consumeConnectionFailed',
-            },
-            [consts_1.ConnectionPurpose.Publish]: {
-                connection: null,
-                creatingConnection: false,
-                connectionCreatedEventName: 'publishConnectionCreated',
-                connectionFailedEventName: 'publishConnectionFailed',
-            },
-        };
+        this.channel = null;
+        this.connection = null;
+        this.creatingConnection = false;
         this.exchanges = {};
         this.queues = {};
         this.queueSetupPromises = {};
-        this.assertExchangePromises = {};
         this.consumers = [];
         this.options = options;
+        this.podId = `${options?.serviceName}${options?.podIp ? `-${options.podIp}` : ''}`;
         this.redisClient = redisConfig && (0, redis_1.default)(redisConfig);
         if (this.redisClient) {
             this.redisLock = (0, util_1.promisify)((0, redis_lock_1.default)(this.redisClient));
@@ -154,31 +140,30 @@ class RabbitMq {
             });
         }
     }
-    async getConnection(connectionPurpose) {
+    async getConnection() {
         return new Promise(async (resolve, reject) => {
-            const { connection, creatingConnection, connectionCreatedEventName, connectionFailedEventName, } = this.connectionsMap[connectionPurpose];
             if (this.blockReconnect) {
                 debug('rabbit: block reconnect');
                 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                 // @ts-ignore
                 return resolve();
             }
-            if (connection !== null) {
-                if (this.options?.disableReconnect || connection?.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(connection);
+                    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;
             }
-            this.connectionsMap[connectionPurpose].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
@@ -191,29 +176,28 @@ 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,
             });
-            this.connectionsMap[connectionPurpose].connection = newConnection;
-            logger_1.default.info(`rabbit: created new connection ${connectionPurpose}`);
-            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 = [];
                 logger_1.default.error('rabbit: connection connectFailed', { err });
                 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.connection.on('disconnect', ({ err }) => {
                 this.consumersTags = [];
                 debug('rabbit: connection closed');
                 if (this.options?.disableReconnect) {
@@ -224,27 +208,25 @@ class RabbitMq {
                     logger_1.default.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
                 }
             });
-            newConnection.once('connect', async () => {
-                this.connectionsMap[connectionPurpose].creatingConnection = false;
-                this.em.emit(connectionCreatedEventName, newConnection);
+            this.connection.once('connect', async () => {
+                debug('rabbit: connection established');
+                this.creatingConnection = false;
+                this.em.emit(consts_1.CONNECTION_CREATED_CONST, connection);
                 isResolved = true;
-                resolve(newConnection);
+                resolve(connection);
             });
         });
     }
-    async getNewChannel({ name = (0, utils_1.rand)().toString(), onClose = null, options = {}, connectionPurpose = consts_1.ConnectionPurpose.Consume, }) {
+    async getNewChannel({ name = (0, utils_1.rand)().toString(), onClose = null, options = {} } = {}) {
         let connection;
         try {
-            connection = await this.getConnection(connectionPurpose);
+            connection = await this.getConnection();
         }
         catch (e) {
             logger_1.default.error(`rabbit: error on get connection for new channel ${name} `, { e });
             throw e;
         }
-        if (!connection) {
-            throw new Error(`rabbit: couldnt get connection for new channel ${name}`);
-        }
-        const channel = connection.createChannel({ ...options });
+        const channel = connection.createChannel({ ...options, name });
         (0, events_1.once)(channel, 'close').then((args) => {
             logger_1.default.error(`rabbit: channel ${name} closed`);
             onClose?.(args);
@@ -259,117 +241,83 @@ class RabbitMq {
             throw err;
         }
     }
-    async assertChannel({ force = false, connectionPurpose = consts_1.ConnectionPurpose.Consume }) {
-        debug('rabbit: start assert channel', { connectionPurpose, publishPromise: this.publishChannelSetupPromise, channel: this.publishChannel });
-        if (!this.publishChannelSetupPromise || (!this.publishChannel && connectionPurpose === consts_1.ConnectionPurpose.Publish)) {
-            this.publishChannelSetupPromise = new Promise(async (resolve, reject) => {
-                if (this.publishChannel && !force) {
-                    return resolve(this.publishChannel);
-                }
-                try {
-                    const channel = await this.getNewChannel({ connectionPurpose });
-                    debug('rabbit: new channel got', { connectionPurpose, channel: this.publishChannel });
-                    channel.on('error', (err) => {
-                        logger_1.default.error('rabbit: channel error', { err });
-                    });
-                    if (connectionPurpose === consts_1.ConnectionPurpose.Publish) {
-                        this.publishChannel = channel;
-                    }
-                    resolve(channel);
-                }
-                catch (e) {
-                    reject(e);
-                }
-            });
-        }
-        return this.publishChannelSetupPromise;
+    async assertChannel({ force = false } = {}) {
+        return new Promise(async (resolve, reject) => {
+            if (this.channel && !force) {
+                return resolve(this.channel);
+            }
+            try {
+                const channel = await this.getNewChannel({});
+                channel.on('error', (err) => {
+                    logger_1.default.error('rabbit: channel error', { err });
+                });
+                this.channel = channel;
+                resolve(channel);
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
     }
-    async assertExchange(exchangeName, options = { connectionPurpose: consts_1.ConnectionPurpose.Consume }) {
-        const channel = await this.assertChannel({ connectionPurpose: options.connectionPurpose });
+    async assertExchange(exchangeName, options) {
+        const channel = await this.assertChannel();
         if (this.exchanges[exchangeName]) {
-            delete this.assertExchangePromises[exchangeName];
             return this.exchanges[exchangeName];
         }
-        if (this.assertExchangePromises[exchangeName]) {
-            return this.assertExchangePromises[exchangeName];
-        }
-        this.assertExchangePromises[exchangeName] = (0, utils_1.assertExchangeFanout)(channel, exchangeName);
-        this.exchanges[exchangeName] = await this.assertExchangePromises[exchangeName];
-        return this.exchanges[exchangeName];
+        const exchange = await (0, utils_1.assertExchangeFanout)(channel, exchangeName);
+        this.exchanges[exchangeName] = exchange;
+        return exchange;
     }
-    async getQueueLength(queue, connectionPurpose = consts_1.ConnectionPurpose.Consume) {
+    async getQueueLength(queue) {
         RabbitMq.validateName('queue', queue);
-        const { connection } = this.connectionsMap[connectionPurpose];
-        const { publishChannel } = this;
-        if (!publishChannel) {
+        const { channel } = this;
+        if (!channel) {
             throw new Error('channel is not defined');
         }
-        debug('rabbit: getting queue length', { queue, connected: connection?.isConnected() });
-        return publishChannel?.checkQueue(queue);
+        debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
+        return channel?.checkQueue(queue);
     }
-    async deleteQueue(queue, connectionPurpose) {
+    async deleteQueue(queue) {
         RabbitMq.validateName('queue', queue);
-        const channel = await this.assertChannel({ connectionPurpose });
+        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;
     }
     async bindQueue(queue, exchange) {
-        const channel = await this.assertChannel({ connectionPurpose: consts_1.ConnectionPurpose.Publish });
+        const channel = await this.assertChannel();
         await channel.addSetup((setupChannel) => setupChannel.bindQueue(queue, exchange, ''));
         return channel.bindQueue(queue, exchange, '');
     }
-    async setupQueue(queueName, connectionPurpose, options) {
+    async setupQueue(queueName, options) {
         let queue;
-        const shouldUseQuorum = RabbitMq.shouldUseQuorum(queueName);
-        const localeOptions = {
-            ...options,
-            durable: true,
-            arguments: {
-                ...options?.arguments,
-                'x-consumer-timeout': 1000 * 60 * 60 * 24,
-                'x-queue-type': shouldUseQuorum ? 'quorum' : 'classic',
-            },
-        };
         try {
-            const channel = await this.assertChannel({ connectionPurpose });
+            const channel = await this.assertChannel();
             debug('assertQueue->channel.addSetup', { queueName });
-            await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, localeOptions));
+            await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, options));
             debug('assertQueue->channel.assertQueue', { queueName });
-            queue = await channel.assertQueue(queueName, localeOptions);
+            queue = await channel.assertQueue(queueName, options);
         }
         catch (e) {
             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, connectionPurpose });
-                await this.deleteQueue(queueName, connectionPurpose);
+                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));
+                await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, options));
                 debug('retrying assertQueue->channel.assertQueue', { queueName });
-                queue = await channel.assertQueue(queueName, localeOptions);
+                queue = await channel.assertQueue(queueName, options);
             }
             else {
                 throw e;
             }
         }
-        this.queues[queueName] = queue;
+        this.queues[queueName] = queueName;
         return queue;
     }
-    static shouldUseQuorum(queueName) {
-        const envQuorumQueuesWhitelist = process.env.QUORUM_QUEUES_WHITELIST;
-        if (envQuorumQueuesWhitelist === '*') {
-            return true;
-        }
-        if (envQuorumQueuesWhitelist) {
-            const whitelist = envQuorumQueuesWhitelist.split(',');
-            return whitelist.includes(queueName);
-        }
-        return false;
-    }
-    async assertQueue(queueName, connectionPurpose, options) {
-        debug('rabbit: start assert queue', { connectionPurpose, queueName });
+    async assertQueue(queueName, options) {
         RabbitMq.validateName('queue', queueName);
         if (this.queues[queueName]) {
             delete this.queueSetupPromises[queueName];
@@ -378,8 +326,7 @@ class RabbitMq {
         if (this.queueSetupPromises[queueName]) {
             return this.queueSetupPromises[queueName];
         }
-        this.queueSetupPromises[queueName] = this.setupQueue(queueName, connectionPurpose, options);
-        debug('rabbit: done assert queue', { connectionPurpose, queueName });
+        this.queueSetupPromises[queueName] = this.setupQueue(queueName, options);
         return this.queueSetupPromises[queueName];
     }
     saveConsumer(queue, callback, options) {
@@ -422,17 +369,16 @@ class RabbitMq {
             }
             logger_1.default.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
         }
-        const channel = await this.getNewChannel({ connectionPurpose: consts_1.ConnectionPurpose.Consume });
+        const channel = await this.getNewChannel({ name: `${this.podId}_queue_${queue}` });
         return channel.addSetup(async (confirmChannel) => {
-            const q = await this.assertQueue(queue, consts_1.ConnectionPurpose.Consume, optionsWithDefaults);
-            await confirmChannel.prefetch(limit, false);
+            await confirmChannel.assertQueue(queue, options ? { messageTtl: options.messageTtl } : undefined);
+            await confirmChannel.prefetch(limit, true);
             const { consumerTag } = await confirmChannel.consume(queue, async (msg) => {
                 if (!msg) {
                     return null;
                 }
                 const traceId = msg.properties.headers[consts_1.TRACING_HEADER];
                 const userId = msg.properties.headers[consts_1.USER_TRACING_HEADER];
-                const automationId = msg.properties.headers[consts_1.AUTOMATION_ID_HEADER];
                 const parsedMessage = RabbitMq.parseMsg(msg);
                 const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
                 const trace = (0, zehut_1.newTrace)(zehut_1.traceTypes.RABBIT);
@@ -457,10 +403,7 @@ class RabbitMq {
                     outbreakTrace?.context.set(consts_1.TRACING_HEADER, traceId);
                 }
                 if (auditContext) {
-                    await auditContext(queue, {
-                        userId,
-                        automationId,
-                    });
+                    await auditContext(queue);
                 }
                 const shouldConsume = await this.shouldConsumeMessageByTimestamp(parsedMessage);
                 if (!shouldConsume) {
@@ -506,12 +449,12 @@ class RabbitMq {
         RabbitMq.validateName('queue', queue);
         const { limit, deadMessageTtl } = optionsWithDefaults;
         await this.saveConsumer(queue, callback, options);
-        const channel = await this.getNewChannel({ name: `consume - exchange - ${exchange} -queue - ${queue}` });
+        const channel = await this.getNewChannel({ name: `${this.podId}_exchange_${exchange}_queue_${queue}` });
         return channel.addSetup(async (c) => {
             const assertExchange = await (0, utils_1.assertExchangeFanout)(c, exchange);
             await c.assertQueue(queue);
             this.exchanges[exchange] = assertExchange;
-            await c.prefetch(limit, false);
+            await c.prefetch(limit, true);
             return Promise.all([
                 c.bindQueue(queue, exchange, ''),
                 this.consume(queue, callback, options),
@@ -519,67 +462,53 @@ class RabbitMq {
         });
     }
     async publish(exchange, content, customHeaders) {
-        debug('rabbit: start publish msg');
         return (0, utils_1.wrapSetImmediate)(async () => {
             RabbitMq.validateName('exchange', exchange);
-            const channel = await this.assertChannel({ connectionPurpose: consts_1.ConnectionPurpose.Publish });
-            await this.assertExchange(exchange, { connectionPurpose: consts_1.ConnectionPurpose.Publish });
+            const channel = await this.assertChannel();
+            await this.assertExchange(exchange);
             await channel.publish(exchange, '', Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
         });
     }
-    async sendToQueue(queue, content, options, customHeaders) {
-        try {
-            await this.assertChannel({ connectionPurpose: consts_1.ConnectionPurpose.Publish });
-        }
-        catch (e) {
-            logger_1.default.error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });
-            throw e;
-        }
-        try {
-            RabbitMq.validateName('queue', queue);
-            await this.assertQueue(queue, consts_1.ConnectionPurpose.Publish, options);
+    async sendToQueue(queue, content, options, customHeaders, isBlocking) {
+        const callback = async () => {
+            try {
+                RabbitMq.validateName('queue', queue);
+                await this.assertChannel();
+                await this.assertQueue(queue, options);
+                const res = await this.channel?.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
+                debug(`rabbit: sending to queue ${queue}`, { res });
+                return res;
+            }
+            catch (e) {
+                logger_1.default.error(`rabbit: failed to send to queue ${queue}`, { e });
+                throw e;
+            }
+        };
+        if (isBlocking) {
+            return callback();
         }
-        catch (e) {
-            logger_1.default.error(`rabbit sendToQueue: failed to assert queue ${queue}`, { e });
-            throw e;
+        return (0, utils_1.wrapSetImmediate)(callback);
+    }
+    async isConnected() {
+        const connection = await this.getConnection();
+        const isConnected = connection.isConnected();
+        if (!isConnected) {
+            logger_1.default.error('rabbit: isConnected - false');
+            return false;
         }
+        const channel = await this.assertChannel();
         try {
-            const res = await this.publishChannel?.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
-            debug(`rabbit: sending to queue ${queue}`, { res });
-            return res;
+            await Promise.all([
+                channel.waitForConnect(),
+                ...this.consumers.map((c) => channel.checkQueue(c.queue)),
+            ]);
         }
         catch (e) {
-            logger_1.default.error(`rabbit sendToQueue: failed to send to queue ${queue}`, { e });
-            throw e;
+            logger_1.default.error('rabbit: isConnected - false');
+            return false;
         }
-    }
-    async isConnected() {
-        debug('rabbit: start is connected');
-        const isEachConnectionConnected = await Promise.all(Object.entries(this.connectionsMap).map(async ([connectionPurpose, connectionData]) => {
-            if (connectionPurpose === consts_1.ConnectionPurpose.Publish) {
-                const channel = await this.assertChannel({ connectionPurpose: connectionPurpose });
-                try {
-                    await Promise.all([
-                        channel.waitForConnect(),
-                        ...this.consumers.map((c) => channel.checkQueue(c.queue)),
-                    ]);
-                }
-                catch (e) {
-                    logger_1.default.error('rabbit: isConnected - false');
-                    return false;
-                }
-            }
-            const { connection } = connectionData;
-            debug('rabbit: is connected inside map', { connection, connectionPurpose });
-            const isConnected = connection?.isConnected();
-            if (!isConnected) {
-                logger_1.default.error('rabbit: isConnected - false', { connectionPurpose });
-                return false;
-            }
-            logger_1.default.info('rabbit: isConnected - true');
-            return true;
-        }));
-        return isEachConnectionConnected.every((isConnected) => isConnected === true);
+        logger_1.default.info('rabbit: isConnected - true');
+        return true;
     }
     async gracefulShutdown(signal) {
         const tagsNumber = this.consumersTags.length;
@@ -598,5 +527,3 @@ class RabbitMq {
     }
 }
 exports.default = RabbitMq;
-var celery_1 = require("./lib/celery");
-Object.defineProperty(exports, "sendCeleryTaskViaHttp", { enumerable: true, get: function () { return celery_1.sendCeleryTaskViaHttp; } });

package/dist/lib/consts.d.ts

@@ -3,9 +3,10 @@ export declare const DEFAULT_LOCK_TIMEOUT: number;
 export declare const RETRY_HEADER = "x-retry-count";
 export declare const TRACING_HEADER = "x-trace-id";
 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;
@@ -15,7 +16,3 @@ export declare const DEFAULT_OPTIONS: {
     auditContext: null;
     enableRabbitTrace: boolean;
 };
-export declare enum ConnectionPurpose {
-    Consume = "consume",
-    Publish = "publish"
-}

package/dist/lib/consts.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectionPurpose = 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_OPTIONS = exports.CONNECTION_FAILED_CONST = exports.CONNECTION_CREATED_CONST = exports.DEFAULT_USE_CONSUME_WITH_LOCK = exports.USER_OBJECT = 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';
 exports.TRACING_HEADER = 'x-trace-id';
 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,
@@ -18,8 +19,3 @@ exports.DEFAULT_OPTIONS = {
     auditContext: null,
     enableRabbitTrace: false,
 };
-var ConnectionPurpose;
-(function (ConnectionPurpose) {
-    ConnectionPurpose["Consume"] = "consume";
-    ConnectionPurpose["Publish"] = "publish";
-})(ConnectionPurpose = exports.ConnectionPurpose || (exports.ConnectionPurpose = {}));

package/dist/lib/types.d.ts

@@ -1,4 +1,3 @@
-import { AmqpConnectionManager } from 'amqp-connection-manager';
 import { ConsumeMessage, Options, Replies } from 'amqplib';
 export interface ExchangesCache {
     [key: string]: any;
@@ -9,9 +8,6 @@ export interface QueuesCache {
 export interface QueueSetupPromisesDictionary {
     [key: string]: Promise<Replies.AssertQueue> | undefined;
 }
-export interface AssertExchangePromisesDictionary {
-    [key: string]: Promise<Replies.AssertExchange> | undefined;
-}
 export type CustomMessageHeaders = {
     redisTimestampValidationKey?: string;
 };
@@ -42,9 +38,3 @@ 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;
-};

package/dist/lib/utils.d.ts

@@ -1,5 +1,5 @@
 import { ChannelWrapper } from 'amqp-connection-manager';
-import { ConfirmChannel, Replies } from 'amqplib';
-export declare const assertExchangeFanout: (c: ChannelWrapper | ConfirmChannel, exchangeName: string) => Promise<Replies.AssertExchange>;
+import { ConfirmChannel } from 'amqplib';
+export declare const assertExchangeFanout: (c: ChannelWrapper | ConfirmChannel, exchangeName: string) => Promise<import("amqplib").Replies.AssertExchange>;
 export declare const wrapSetImmediate: (callback: () => any) => Promise<any>;
 export declare const rand: () => number;

package/package.json

@@ -1,11 +1,8 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "3.2.26-beta.3",
+  "version": "3.3.0-beta.0",
   "description": "",
   "main": "dist/index.js",
-  "engines": {
-    "node": ">=16.7.0"
-  },
   "scripts": {
     "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",
@@ -18,7 +15,7 @@
     "dev": "nodemon"
   },
   "dependencies": {
-    "@autofleet/zehut": "^3.1.2",
+    "@autofleet/zehut": "3.0.8",
     "amqp-connection-manager": "4.1.9",
     "amqplib": "0.10.3",
     "bluebird": "^3.7.2",