@autofleet/rabbit 3.2.20 → 3.2.21-beta.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "3.2.20",
+  "version": "3.2.21-beta.0.0",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -43,4 +43,4 @@
   },
   "author": "",
   "license": "ISC"
-}
+}

package/src/index.ts

@@ -697,6 +697,63 @@ class RabbitMq implements IAfRabbitMq {
     }
   }
 
+
+  async sendToCeleryQueue(
+      queue: string,
+      taskName: string,
+      data: any,
+      options?: any,
+      customHeaders?: any,
+  ): Promise<boolean | undefined> {
+    try {
+      await this.assertChannel();
+    } catch (e) {
+      logger.error(`rabbit sendToCeleryQueue: failed to assert channel when sending to queue ${queue}`, { e });
+      throw e;
+    }
+
+    try {
+      RabbitMq.validateName('queue', queue);
+      await this.assertQueue(queue, options);
+    } catch (e) {
+      logger.error(`rabbit sendToCeleryQueue: failed to assert queue ${queue}`, { e });
+      throw e;
+    }
+
+    try {
+      // Create Celery-compatible message format
+      const celeryMessage = {
+        task: taskName,
+        id: randomUUID(),
+        args: [data],
+      };
+
+      // Merge default Celery properties with custom headers
+      const celeryHeaders = {
+        ...RabbitMq.getPublishOptions(customHeaders),
+        properties: {
+          ...RabbitMq.getPublishOptions(customHeaders)?.properties,
+          delivery_mode: 2,
+          content_type: 'application/json',
+          content_encoding: 'utf-8',
+        },
+      };
+
+      const res = await this.channel?.sendToQueue(
+          queue,
+          Buffer.from(JSON.stringify(celeryMessage)),
+          celeryHeaders
+      );
+
+      debug(`rabbit: sending to celery queue ${queue}`, { res });
+      return res;
+    } catch (e) {
+      const isConnected = await this.isConnected();
+      logger.error(`rabbit sendToCeleryQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { e });
+      throw e;
+    }
+  }
+
   async isConnected() : Promise<boolean> {
     const connection = await this.getConnection();
     const isConnected = connection.isConnected();

package/dist/index.d.ts

@@ -1,100 +0,0 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-import { AmqpConnectionManager, ChannelWrapper, CreateChannelOpts } from 'amqp-connection-manager';
-import { ConfirmChannel, ConsumeMessage, Options, Replies } from 'amqplib';
-import { RedisConfig } from './lib/redis';
-import { CallbackFunction, ConsumeMessageOrNull, ConsumeOptions, CustomMessageHeaders, QueuesCache, RedisLockType, ExchangesCache, QueueSetupPromisesDictionary, AssertExchangePromisesDictionary } from './lib/types';
-export interface IAfRabbitMq {
-    ack: any;
-    nack: any;
-    assertChannel: any;
-    assertExchange: any;
-    assertQueue: any;
-    consume: any;
-    consumeFromExchange: any;
-    publish: any;
-    sendToQueue: any;
-    redisClient?: any;
-}
-interface NackOptions {
-    skipRetry?: boolean;
-}
-export interface AfRabbitOptions {
-    disableReconnect?: boolean;
-    /**
-     * When you want your own grace-full shutdown, set this to true.
-     * @default false
-     */
-    dontGracefulShutdown?: boolean;
-    /**
-     * dont retry on creation error
-     * @default false
-     */
-    dontRetryAssert?: boolean;
-    rabbitHost?: string;
-}
-type newChannelOpts = {
-    name?: string;
-    onClose?: null | ((args: any | null) => void);
-    options?: CreateChannelOpts | undefined;
-};
-type assertChannelOpts = {
-    channelName?: string;
-    force?: boolean;
-};
-declare class RabbitMq implements IAfRabbitMq {
-    static parseMsg(msg: any): any;
-    static validateName(type: string, name: string): void;
-    static getPublishOptions(customHeaders?: CustomMessageHeaders): {
-        timestamp: number;
-        timeout: number;
-        headers: {
-            "x-af-user-id": any;
-            "x-trace-id": any;
-            redisTimestampValidationKey?: string | undefined;
-            creationTimestamp: number;
-        };
-    };
-    DISCONNECT_MSG: string;
-    RECONNECT_MSG: string;
-    channel: ChannelWrapper | null;
-    publishChannelSetupPromise: Promise<ChannelWrapper> | null;
-    blockReconnect: boolean | null | undefined;
-    connection: AmqpConnectionManager | null | undefined;
-    em: EventEmitter;
-    creatingConnection: boolean;
-    exchanges: ExchangesCache;
-    queues: QueuesCache;
-    queueSetupPromises: QueueSetupPromisesDictionary;
-    assertExchangePromises: AssertExchangePromisesDictionary;
-    options: AfRabbitOptions | undefined;
-    redisClient: any;
-    redisLock?: RedisLockType;
-    /** Array of consumers tags used for canceling consumption */
-    consumersTags: Array<[ConfirmChannel, string]>;
-    private consumers;
-    constructor(options?: AfRabbitOptions, redisConfig?: RedisConfig);
-    private shouldConsumeMessageByTimestamp;
-    ack: (channel: ConfirmChannel, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp?: boolean, releaseLock?: null) => (userMsg: ConsumeMessage) => Promise<any>;
-    nack: (channel: ConfirmChannel, queue: string, options: any, deadQueueOptions: Options.AssertQueue, msg: ConsumeMessageOrNull, releaseLock: any) => (userMsg: ConsumeMessageOrNull, { skipRetry, }?: NackOptions) => Promise<any>;
-    getConnection(): Promise<AmqpConnectionManager>;
-    getNewChannel({ name, onClose, options }?: newChannelOpts): Promise<ChannelWrapper>;
-    assertChannel({ force }?: assertChannelOpts): Promise<ChannelWrapper>;
-    assertExchange(exchangeName: string, options?: any): Promise<any>;
-    getQueueLength(queue: string): Promise<Replies.AssertQueue>;
-    private deleteQueue;
-    bindQueue(queue: string, exchange: string): Promise<void>;
-    setupQueue(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
-    assertQueue(queueName: string, options?: Options.AssertQueue): Promise<any>;
-    private saveConsumer;
-    consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any>;
-    private lockRedisIfNeeded;
-    private unlockRedisIfNeeded;
-    private consumeFromRabbit;
-    consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any>;
-    publish(exchange: string, content: any, customHeaders?: any): Promise<boolean>;
-    sendToQueue(queue: string, content: any, options?: any, customHeaders?: any): Promise<boolean | undefined>;
-    isConnected(): Promise<boolean>;
-    gracefulShutdown(signal: string): Promise<void>;
-}
-export default RabbitMq;

package/dist/index.js

@@ -1,545 +0,0 @@
-"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 });
-const events_1 = require("events");
-const util_1 = require("util");
-const moment_1 = __importDefault(require("moment"));
-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 logger_1 = __importDefault(require("./logger"));
-const rabbitError_1 = __importDefault(require("./lib/rabbitError"));
-const redis_1 = __importDefault(require("./lib/redis"));
-const utils_1 = require("./lib/utils");
-const consts_1 = require("./lib/consts");
-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;
-const HEARTBEAT = '60';
-class RabbitMq {
-    static parseMsg(msg) {
-        let { content } = msg;
-        content = content.toString();
-        try {
-            content = JSON.parse(content);
-        }
-        catch (e) { }
-        return {
-            ...msg,
-            content,
-        };
-    }
-    static validateName(type, name) {
-        if (!name || name === '') {
-            throw new rabbitError_1.default(`error while using ${type} with no name`);
-        }
-    }
-    static getPublishOptions(customHeaders = {}) {
-        const trace = (0, zehut_1.getCurrentPayload)();
-        const user = trace?.context?.get(consts_1.USER_OBJECT);
-        const traceId = trace?.context?.get(consts_1.TRACING_HEADER);
-        const outbreakTrace = zehut_1.outbreak.getCurrentContext();
-        return {
-            timestamp: (0, moment_1.default)().unix(),
-            timeout: PUBLISH_TIMEOUT,
-            headers: {
-                creationTimestamp: (0, moment_1.default)().valueOf(),
-                ...customHeaders,
-                [consts_1.USER_TRACING_HEADER]: user?.id,
-                [consts_1.TRACING_HEADER]: traceId || outbreakTrace?.context?.get(consts_1.TRACING_HEADER),
-            },
-        };
-    }
-    constructor(options, redisConfig) {
-        this.DISCONNECT_MSG = 'rabbit: connection disconnect';
-        this.RECONNECT_MSG = 'rabbit: connection disconnect - reconnecting';
-        this.consumers = [];
-        this.shouldConsumeMessageByTimestamp = async (msg) => {
-            if (msg) {
-                const { properties: { headers } } = msg;
-                const timestamp = headers?.creationTimestamp;
-                if (timestamp && headers?.redisTimestampValidationKey && this.redisClient) {
-                    const lastMessageTimestamp = await this.redisClient.getAsync(headers.redisTimestampValidationKey);
-                    return !lastMessageTimestamp || (parseInt(lastMessageTimestamp, 10) <= parseInt(timestamp, 10));
-                }
-                return true;
-            }
-            return false;
-        };
-        this.ack = (channel, msg, shouldUpdateRedisTimestamp = false, releaseLock = null) => async (userMsg) => {
-            if (msg) {
-                debug('rabbit acking message', { deliveryTag: msg.fields.deliveryTag });
-                await channel.ack(msg);
-                const { properties: { headers } } = msg;
-                const timestamp = headers?.creationTimestamp;
-                if (shouldUpdateRedisTimestamp && timestamp && headers?.redisTimestampValidationKey && this.redisClient) {
-                    const parsedTimestamp = parseInt(timestamp, 10);
-                    await this.redisClient.setAsync(headers.redisTimestampValidationKey, parsedTimestamp, 'EX', 3600);
-                    await this.unlockRedisIfNeeded(releaseLock);
-                }
-            }
-        };
-        this.nack = (channel, queue, options, deadQueueOptions, msg, releaseLock) => async (userMsg, { skipRetry = false, } = {}) => {
-            await this.unlockRedisIfNeeded(releaseLock);
-            if (channel && msg) {
-                if (!skipRetry
-                    && (!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]
-                            ? msg.properties.headers[consts_1.RETRY_HEADER] + 1
-                            : 1,
-                    });
-                }
-                else {
-                    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]
-                            ? msg.properties.headers[consts_1.RETRY_HEADER] + 1
-                            : 1,
-                    });
-                }
-                debug('rabbit nacking message', { deliveryTag: msg.fields.deliveryTag });
-                await channel.ack(msg);
-            }
-            else {
-                logger_1.default.error('no channel or msg', {
-                    msg,
-                });
-            }
-        };
-        this.em = new events_1.EventEmitter();
-        this.channel = null;
-        this.publishChannelSetupPromise = null;
-        this.connection = null;
-        this.creatingConnection = false;
-        this.exchanges = {};
-        this.queues = {};
-        this.queueSetupPromises = {};
-        this.assertExchangePromises = {};
-        this.consumers = [];
-        this.options = options;
-        this.redisClient = redisConfig && (0, redis_1.default)(redisConfig);
-        if (this.redisClient) {
-            this.redisLock = (0, util_1.promisify)((0, redis_lock_1.default)(this.redisClient));
-        }
-        this.consumersTags = [];
-        logger_1.default.info(`rabbit: [gracefully-shutdown] adding gracefully shutdown for process.pid ${process.pid}`);
-        if (!this.options?.dontGracefulShutdown) {
-            process.on('SIGTERM', async () => {
-                await this.gracefulShutdown('SIGTERM');
-            });
-            process.on('SIGINT', async () => {
-                await this.gracefulShutdown('SIGINT');
-            });
-        }
-    }
-    async getConnection() {
-        return new Promise(async (resolve, reject) => {
-            if (this.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()) {
-                    debug('rabbit: connection - is connected');
-                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                    // @ts-ignore
-                    return resolve(this.connection);
-                }
-                debug('rabbit: connection - reconnecting');
-            }
-            if (this.creatingConnection) {
-                debug('rabbit: creating connection emi');
-                this.em.once(consts_1.CONNECTION_CREATED_CONST, resolve);
-                this.em.once(consts_1.CONNECTION_FAILED_CONST, reject);
-                return;
-            }
-            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
-            // and we want to use the new values
-            const findServers = () => {
-                const userName = process.env.RABBITMQ_USERNAME || 'guest';
-                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}?heartbeat=${HEARTBEAT}`];
-            };
-            const defaultUrls = findServers();
-            const connection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
-                findServers,
-            });
-            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(consts_1.CONNECTION_FAILED_CONST, 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(consts_1.CONNECTION_FAILED_CONST, err);
-                }
-            });
-            this.connection.on('disconnect', ({ err }) => {
-                // this.channel = null;
-                this.consumersTags = [];
-                debug('rabbit: connection closed');
-                if (this.options?.disableReconnect) {
-                    logger_1.default.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
-                    this.blockReconnect = true;
-                }
-                else {
-                    logger_1.default.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
-                }
-            });
-            this.connection.once('connect', async () => {
-                debug('rabbit: connection established');
-                this.creatingConnection = false;
-                this.em.emit(consts_1.CONNECTION_CREATED_CONST, connection);
-                isResolved = true;
-                resolve(connection);
-            });
-        });
-    }
-    async getNewChannel({ name = (0, utils_1.rand)().toString(), onClose = null, options = {} } = {}) {
-        let connection;
-        try {
-            connection = await this.getConnection();
-        }
-        catch (e) {
-            logger_1.default.error(`rabbit: error on get connection for new channel ${name} `, { e });
-            throw e;
-        }
-        const channel = connection.createChannel({ ...options });
-        (0, events_1.once)(channel, 'close').then((args) => {
-            logger_1.default.error(`rabbit: channel ${name} closed`);
-            onClose?.(args);
-        });
-        try {
-            await (0, events_1.once)(channel, 'connect');
-            debug(`rabbit: channel ${name} CONNECTED`);
-            return channel;
-        }
-        catch (err) {
-            logger_1.default.error(`rabbit: channel error ${name} error`, { err });
-            throw err;
-        }
-    }
-    async assertChannel({ force = false } = {}) {
-        if (!this.publishChannelSetupPromise) {
-            this.publishChannelSetupPromise = 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);
-                }
-            });
-        }
-        return this.publishChannelSetupPromise;
-    }
-    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];
-    }
-    async getQueueLength(queue) {
-        RabbitMq.validateName('queue', queue);
-        const { channel } = this;
-        if (!channel) {
-            throw new Error('channel is not defined');
-        }
-        debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
-        return channel?.checkQueue(queue);
-    }
-    async deleteQueue(queue) {
-        RabbitMq.validateName('queue', queue);
-        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();
-        await channel.addSetup((setupChannel) => setupChannel.bindQueue(queue, exchange, ''));
-        return channel.bindQueue(queue, exchange, '');
-    }
-    async setupQueue(queueName, options) {
-        let queue;
-        try {
-            const channel = await this.assertChannel();
-            debug('assertQueue->channel.addSetup', { queueName });
-            await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, options));
-            debug('assertQueue->channel.assertQueue', { queueName });
-            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 });
-                await this.deleteQueue(queueName);
-                debug('retrying assertQueue->channel.addSetup', { queueName });
-                await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, options));
-                debug('retrying assertQueue->channel.assertQueue', { queueName });
-                queue = await channel.assertQueue(queueName, options);
-            }
-            else {
-                throw e;
-            }
-        }
-        this.queues[queueName] = queueName;
-        return queue;
-    }
-    async assertQueue(queueName, options) {
-        RabbitMq.validateName('queue', queueName);
-        if (this.queues[queueName]) {
-            delete this.queueSetupPromises[queueName];
-            return this.queues[queueName];
-        }
-        if (this.queueSetupPromises[queueName]) {
-            return this.queueSetupPromises[queueName];
-        }
-        this.queueSetupPromises[queueName] = this.setupQueue(queueName, options);
-        return this.queueSetupPromises[queueName];
-    }
-    saveConsumer(queue, callback, options) {
-        const isConsumerExist = this.consumers.some((consumer) => consumer.queue === queue);
-        if (!isConsumerExist) {
-            logger_1.default.info(`rabbit: consumer: ${queue} saved in consumer array`);
-            this.consumers.push({
-                queue,
-                callback,
-                options,
-            });
-        }
-    }
-    async consume(queue, callback, options) {
-        await this.consumeFromRabbit(queue, callback, options);
-    }
-    async lockRedisIfNeeded(msg, options) {
-        const { properties: { headers } } = msg;
-        const timestamp = headers?.creationTimestamp;
-        let releaseLock = null;
-        if (options.useConsumeWithLock && timestamp && headers?.redisTimestampValidationKey && this.redisLock) {
-            releaseLock = await this.redisLock(headers.redisTimestampValidationKey, options?.lockTimeout || consts_1.DEFAULT_LOCK_TIMEOUT);
-        }
-        return releaseLock;
-    }
-    async unlockRedisIfNeeded(releaseLock) {
-        if (this.redisLock && releaseLock) {
-            await releaseLock();
-        }
-    }
-    async consumeFromRabbit(queue, callback, options) {
-        const optionsWithDefaults = { ...consts_1.DEFAULT_OPTIONS, ...options };
-        RabbitMq.validateName('queue', queue);
-        this.saveConsumer(queue, callback, options);
-        const uniqueId = (0, node_crypto_1.randomUUID)();
-        const { limit, deadMessageTtl, useConsumeWithLock, lockTimeout, auditContext, enableRabbitTrace, } = optionsWithDefaults;
-        if (useConsumeWithLock) {
-            if (!this.redisLock) {
-                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({});
-        return channel.addSetup(async (confirmChannel) => {
-            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 parsedMessage = RabbitMq.parseMsg(msg);
-                const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
-                const trace = (0, zehut_1.newTrace)(zehut_1.traceTypes.RABBIT);
-                // setting also outbreak trace as part of legacy code
-                const outbreakTrace = zehut_1.outbreak.newTrace(zehut_1.traceTypes.RABBIT);
-                // enableRabbitTrace is a flag to protect from different flows that doesn't work with permission
-                // and we don't want to fail the flow because of it
-                if (userId && enableRabbitTrace) {
-                    try {
-                        await Promise.all([
-                            (0, zehut_1.createOrSetRabbitTrace)(trace, userId),
-                            (0, zehut_1.createOrSetRabbitTrace)(outbreakTrace, userId),
-                        ]);
-                    }
-                    catch (e) {
-                        logger_1.default.error('rabbit: failed to setRabbitTrace', { userId, e });
-                        return this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
-                    }
-                }
-                if (traceId) {
-                    trace?.context?.set(consts_1.TRACING_HEADER, traceId);
-                    outbreakTrace?.context.set(consts_1.TRACING_HEADER, traceId);
-                }
-                if (auditContext) {
-                    await auditContext(queue);
-                }
-                const shouldConsume = await this.shouldConsumeMessageByTimestamp(parsedMessage);
-                if (!shouldConsume) {
-                    await this.unlockRedisIfNeeded(releaseLock);
-                    return this.ack(confirmChannel, msg)(msg);
-                }
-                let messageAcked = false;
-                // setting the localAck function to be used in the callback
-                const localAck = async () => {
-                    if (messageAcked) {
-                        return;
-                    }
-                    messageAcked = true;
-                    return this.ack(confirmChannel, msg, true, releaseLock)(msg);
-                };
-                const localNack = async (_, nackOptions = {}) => {
-                    if (messageAcked) {
-                        return;
-                    }
-                    debug('rabbit localNack', { messageAcked, uniqueId, deliveryTag: msg.fields.deliveryTag });
-                    messageAcked = true;
-                    return this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg, nackOptions);
-                };
-                try {
-                    await callback(parsedMessage, localAck, localNack);
-                }
-                catch (e) {
-                    await localNack(msg);
-                }
-            }, types_1.CONSUMER_DEFAULT_OPTIONS);
-            if (!consumerTag) {
-                logger_1.default.error(`rabbit: failed to consume from queue ${queue}`);
-            }
-            else {
-                logger_1.default.info(`rabbit: adding tag ${consumerTag} to the array.`);
-                this.consumersTags.push([confirmChannel, consumerTag]);
-            }
-        });
-    }
-    async consumeFromExchange(queue, exchange, callback, options) {
-        const optionsWithDefaults = { ...consts_1.DEFAULT_OPTIONS, ...options };
-        RabbitMq.validateName('exchange', exchange);
-        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}` });
-        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, true);
-            return Promise.all([
-                c.bindQueue(queue, exchange, ''),
-                this.consume(queue, callback, options),
-            ]);
-        });
-    }
-    async publish(exchange, content, customHeaders) {
-        return (0, utils_1.wrapSetImmediate)(async () => {
-            RabbitMq.validateName('exchange', exchange);
-            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();
-        }
-        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, options);
-        }
-        catch (e) {
-            logger_1.default.error(`rabbit sendToQueue: failed to assert queue ${queue}`, { e });
-            throw e;
-        }
-        try {
-            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) {
-            const isConnected = await this.isConnected();
-            logger_1.default.error(`rabbit sendToQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { e });
-            throw e;
-        }
-    }
-    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 {
-            await Promise.all([
-                channel.waitForConnect(),
-                ...this.consumers.map((c) => channel.checkQueue(c.queue)),
-            ]);
-        }
-        catch (e) {
-            logger_1.default.error('rabbit: isConnected - false');
-            return false;
-        }
-        logger_1.default.info('rabbit: isConnected - true');
-        return true;
-    }
-    async gracefulShutdown(signal) {
-        const tagsNumber = this.consumersTags.length;
-        logger_1.default.info(`rabbit: [gracefully-shutdown] received ${signal}! canceling #${tagsNumber} tags...`);
-        const cancelTagPromises = this.consumersTags.map(([channel, tag]) => channel.cancel(tag));
-        // Clean the array to avoid race
-        this.consumersTags = [];
-        const results = await Promise.allSettled(cancelTagPromises);
-        const rejected = results.filter((p) => p.status === 'rejected');
-        if (rejected.length > 0) {
-            logger_1.default.warn(`rabbit: [gracefully-shutdown] #${rejected.length}/${tagsNumber} tags failed to cancel: ${rejected}`);
-        }
-        else {
-            logger_1.default.info('rabbit: [gracefully-shutdown] all tags successfully canceled.');
-        }
-    }
-}
-exports.default = RabbitMq;

package/dist/lib/consts.d.ts

@@ -1,18 +0,0 @@
-export declare const DEFAULT_DEAD_TTL_TWO_DAYS: number;
-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 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;
-    deadMessageTtl: number;
-    lockTimeout: number;
-    useConsumeWithLock: boolean;
-    auditContext: null;
-    enableRabbitTrace: boolean;
-};

package/dist/lib/consts.js

@@ -1,21 +0,0 @@
-"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.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.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,
-    deadMessageTtl: exports.DEFAULT_DEAD_TTL_TWO_DAYS,
-    lockTimeout: exports.DEFAULT_LOCK_TIMEOUT,
-    useConsumeWithLock: exports.DEFAULT_USE_CONSUME_WITH_LOCK,
-    auditContext: null,
-    enableRabbitTrace: false,
-};

package/dist/lib/rabbitError.d.ts

@@ -1,3 +0,0 @@
-export default class RabbitError extends Error {
-    constructor(message: string);
-}

package/dist/lib/rabbitError.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class RabbitError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'RabbitError';
-    }
-}
-exports.default = RabbitError;

package/dist/lib/redis.d.ts

@@ -1,7 +0,0 @@
-export type RedisConfig = {
-    host: string;
-    port: number | undefined;
-    prefix?: string;
-};
-declare const getRedisInstance: (config: RedisConfig) => any;
-export default getRedisInstance;

package/dist/lib/redis.js

@@ -1,11 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const bluebird_1 = __importDefault(require("bluebird"));
-const redis = require('redis');
-bluebird_1.default.promisifyAll(redis.RedisClient.prototype);
-bluebird_1.default.promisifyAll(redis.Multi.prototype);
-const getRedisInstance = (config) => redis.createClient(config);
-exports.default = getRedisInstance;

package/dist/lib/types.d.ts

@@ -1,43 +0,0 @@
-import { ConsumeMessage, Options, Replies } from 'amqplib';
-export interface ExchangesCache {
-    [key: string]: any;
-}
-export interface QueuesCache {
-    [key: string]: any;
-}
-export interface QueueSetupPromisesDictionary {
-    [key: string]: Promise<Replies.AssertQueue> | undefined;
-}
-export interface AssertExchangePromisesDictionary {
-    [key: string]: Promise<Replies.AssertExchange> | undefined;
-}
-export type CustomMessageHeaders = {
-    redisTimestampValidationKey?: string;
-};
-export type RedisLockType = (args0?: string, arg1?: number) => Promise<any>;
-export type ConsumeMessageOrNull = ConsumeMessage | null;
-export interface ConsumeOptions {
-    retries?: number;
-    deadMessageTtl?: number;
-    messageTtl?: number;
-    limit?: number;
-    lockTimeout?: number;
-    useConsumeWithLock?: boolean;
-    auditContext?: any;
-    enableRabbitTrace?: boolean;
-}
-export type CallbackFunction = (msg: ConsumeMessage, ack: any, nack: any) => Promise<any>;
-export type newChannelOpts = {
-    name?: string;
-    onClose?: null | ((args: any | null) => void);
-};
-export type assertChannelOpts = {
-    channelName?: string;
-    force?: boolean;
-};
-export type AfConsumer = {
-    queue: string;
-    callback: CallbackFunction;
-    options: ConsumeOptions | undefined;
-};
-export declare const CONSUMER_DEFAULT_OPTIONS: Options.Consume;

package/dist/lib/types.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONSUMER_DEFAULT_OPTIONS = void 0;
-const HA_PROMOTE_ON_FAILURE = 'ha-promote-on-failure';
-const HA_PROMOTE_ON_SHUTDOWN = 'ha-promote-on-shutdown';
-exports.CONSUMER_DEFAULT_OPTIONS = {
-    arguments: {
-        [HA_PROMOTE_ON_FAILURE]: 'always',
-        [HA_PROMOTE_ON_SHUTDOWN]: 'always',
-    },
-};

package/dist/lib/utils.d.ts

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

package/dist/lib/utils.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rand = exports.wrapSetImmediate = exports.assertExchangeFanout = void 0;
-const assertExchangeFanout = async (c, exchangeName) => c.assertExchange(exchangeName, 'fanout');
-exports.assertExchangeFanout = assertExchangeFanout;
-const wrapSetImmediate = (callback) => new Promise((resolve, reject) => {
-    setImmediate(async () => {
-        try {
-            const value = await callback();
-            resolve(value);
-        }
-        catch (error) {
-            reject(error);
-        }
-    });
-});
-exports.wrapSetImmediate = wrapSetImmediate;
-const rand = () => Math.floor(Math.random() * 100000);
-exports.rand = rand;

package/dist/logger.d.ts

@@ -1,2 +0,0 @@
-declare const logger: import("@autofleet/logger").LoggerInstanceManager;
-export default logger;

package/dist/logger.js

@@ -1,8 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const logger_1 = __importDefault(require("@autofleet/logger"));
-const logger = (0, logger_1.default)();
-exports.default = logger;

package/dist/mock.d.ts

@@ -1,14 +0,0 @@
-import 'jest';
-import { IAfRabbitMq } from './index';
-declare class RabbitMq implements IAfRabbitMq {
-    ack: any;
-    nack: any;
-    assertChannel: any;
-    assertExchange: any;
-    assertQueue: any;
-    consume: any;
-    consumeFromExchange: any;
-    publish: any;
-    sendToQueue: any;
-}
-export default RabbitMq;

package/dist/mock.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// eslint-disable-next-line import/no-extraneous-dependencies
-require("jest");
-class RabbitMq {
-    constructor() {
-        this.ack = jest.fn();
-        this.nack = jest.fn();
-        this.assertChannel = jest.fn();
-        this.assertExchange = jest.fn();
-        this.assertQueue = jest.fn();
-        this.consume = jest.fn();
-        this.consumeFromExchange = jest.fn();
-        this.publish = jest.fn();
-        this.sendToQueue = jest.fn();
-    }
-}
-exports.default = RabbitMq;