@autofleet/rabbit 2.5.4 → 3.0.0-alpha

package/.nvmrc

@@ -0,0 +1 @@
+v16

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 /// <reference types="node" />
-import { ConfirmChannel, Options, ConsumeMessage } from 'amqplib';
-import { AmqpConnectionManager, ChannelWrapper } from 'amqp-connection-manager';
 import { EventEmitter } from 'events';
-import { RedisConfig } from './redis';
+import { AmqpConnectionManager, ChannelWrapper } from 'amqp-connection-manager';
+import { ConfirmChannel, ConsumeMessage, Options, Replies } from 'amqplib';
+import { RedisConfig } from './lib/redis';
+import { TRACING_HEADER } from './lib/consts';
+import { CallbackFunction, ConsumeMessageOrNull, ConsumeOptions, CustomMessageHeaders, QueuesCache, RedisLockType, ExchangesCache } from './lib/types';
 export interface IAfRabbitMq {
     ack: any;
     nack: any;
@@ -15,29 +17,27 @@ export interface IAfRabbitMq {
     sendToQueue: any;
     redisClient?: any;
 }
-interface ExchangesCache {
-    [key: string]: any;
-}
-interface QueuesCache {
-    [key: string]: any;
-}
-declare type CustomMessageHeaders = {
-    redisTimestampValidationKey?: string;
-};
-declare type RedisLockType = (args0?: string, arg1?: number) => Promise<any>;
-declare type ConsumeMessageOrNull = ConsumeMessage | null;
-interface ConsumeOptions {
-    retries?: number;
-    deadMessageTtl?: number;
-    limit?: number;
-    lockTimeout?: number;
-    useConsumeWithLock?: boolean;
-}
-declare type CallbackFunction = (msg: ConsumeMessage, ack: Function, nack: Function) => Promise<any>;
 export interface AfRabbitOptions {
-    disableReconnect: boolean;
+    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;
 }
-declare const TRACING_HEADER = "x-trace-id";
+declare type newChannelOpts = {
+    name?: string;
+    onClose?: null | ((args: any | null) => void);
+};
+declare type assertChannelOpts = {
+    channelName?: string;
+    force?: boolean;
+};
 declare class RabbitMq implements IAfRabbitMq {
     static parseMsg(msg: any): any;
     static validateName(type: string, name: string): void;
@@ -49,12 +49,11 @@ declare class RabbitMq implements IAfRabbitMq {
             creationTimestamp: number;
         };
     };
-    PUBLISH_TIMEOUT: number;
-    PUBLISH_ERROR_MSG: string;
     DISCONNECT_MSG: string;
-    RESCONNECT_MSG: string;
+    RECONNECT_MSG: string;
     channel: ChannelWrapper | null;
-    connection: AmqpConnectionManager | null;
+    blockReconnect: boolean | null | undefined;
+    connection: AmqpConnectionManager | null | undefined;
     em: EventEmitter;
     creatingConnection: boolean;
     exchanges: ExchangesCache;
@@ -64,24 +63,28 @@ declare class RabbitMq implements IAfRabbitMq {
     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: ChannelWrapper, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp?: boolean, releaseLock?: null) => (userMsg: ConsumeMessage) => Promise<any>;
     nack: (channel: ChannelWrapper, queue: string, options: any, deadQueueOptions: Options.AssertQueue, msg: ConsumeMessageOrNull, releaseLock: any) => (userMsg: ConsumeMessageOrNull, { skipRetry, }?: any) => Promise<any>;
     getConnection(): Promise<AmqpConnectionManager>;
-    getNewChannel(): Promise<ChannelWrapper>;
-    assertChannel(): Promise<ChannelWrapper>;
+    getNewChannel({ name, onClose }?: newChannelOpts): Promise<ChannelWrapper>;
+    assertChannel({ force }?: assertChannelOpts): Promise<ChannelWrapper>;
     assertExchange(exchangeName: string, options?: any): Promise<any>;
-    getQueueLength(queue: string): Promise<import("amqplib").Replies.AssertQueue>;
+    getQueueLength(queue: string): Promise<Replies.AssertQueue>;
+    private deleteQueue;
     bindQueue(queue: string, exchange: string): Promise<void>;
     assertQueue(queueName: string, options?: Options.AssertQueue): Promise<any>;
+    private saveConsumer;
+    private loadConsumers;
     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>;
+    sendToQueue(queue: string, content: any, options?: any, customHeaders?: any, isBlocking?: boolean): Promise<boolean | undefined>;
     isConnected(): Promise<boolean>;
     gracefulShutdown(signal: string): Promise<void>;
 }

package/dist/index.js

@@ -1,50 +1,34 @@
 "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 });
-/* eslint-disable @typescript-eslint/ban-ts-comment,@typescript-eslint/ban-types,@typescript-eslint/no-unused-vars,consistent-return,no-async-promise-executor,no-param-reassign,no-empty */
-// eslint-disable-next-line max-classes-per-file
+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 events_1 = require("events");
-const util_1 = require("util");
 const outbreak_1 = require("@autofleet/outbreak");
 const logger_1 = __importDefault(require("./logger"));
-const rabbitError_1 = __importDefault(require("./rabbitError"));
-const redis_1 = __importDefault(require("./redis"));
-const DEFAULT_DEAD_TTL_TWO_DAYS = 60000 * 60 * 12;
-const DEFAULT_LOCK_TIMEOUT = 1000 * 5;
-const RETRY_HEADER = 'x-retry-count';
-const TRACING_HEADER = 'x-trace-id';
-const DEFAULT_USE_CONSUME_WITH_LOCK = false;
-const defaultOptions = {
-    limit: 1,
-    retries: 1,
-    deadMessageTtl: DEFAULT_DEAD_TTL_TWO_DAYS,
-    lockTimeout: DEFAULT_LOCK_TIMEOUT,
-    useConsumeWithLock: DEFAULT_USE_CONSUME_WITH_LOCK,
-};
-const assertExchangeFanout = async (c, exchangeName) => c.assertExchange(exchangeName, 'fanout');
-const connectionCreatedConst = 'connectionCreated';
-const wrapSetImmediate = (callback) => new Promise(async (resolve, reject) => {
-    setImmediate(async () => {
-        try {
-            const value = await callback();
-            resolve(value);
-        }
-        catch (error) {
-            reject(error);
-        }
-    });
-});
+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.info;
+const USERNAME = process.env.RABBITMQ_USERNAME || 'guest';
+const PASSWORD = process.env.RABBITMQ_PASSWORD || 'guest';
+const HOST = process.env.RABBITMQ_SERVICE_HOST || 'localhost';
+const HEARTBEAT = '60';
 class RabbitMq {
     constructor(options, redisConfig) {
-        this.PUBLISH_TIMEOUT = Number(process.env.RABBITMQ_PUBLISH_TIMEOUT) || 60000;
-        this.PUBLISH_ERROR_MSG = `rabbit: publish timeout(${this.PUBLISH_TIMEOUT}ms) has pass, exchange: `;
+        // PUBLISH_TIMEOUT = Number(process.env.RABBITMQ_PUBLISH_TIMEOUT) || 60000;
+        // PUBLISH_ERROR_MSG = `rabbit: publish timeout(${this.PUBLISH_TIMEOUT}ms) has pass, exchange: `;
         this.DISCONNECT_MSG = 'rabbit: connection disconnect';
-        this.RESCONNECT_MSG = 'rabbit: reconnecting';
+        this.RECONNECT_MSG = 'rabbit: connection disconnect - reconnecting';
+        this.consumers = [];
         this.shouldConsumeMessageByTimestamp = async (msg) => {
             if (msg) {
                 const { properties: { headers } } = msg;
@@ -73,12 +57,12 @@ class RabbitMq {
             await this.unlockRedisIfNeeded(releaseLock);
             if (channel && msg) {
                 if (!skipRetry
-                    && (!msg.properties.headers[RETRY_HEADER]
-                        || parseInt(msg.properties.headers[RETRY_HEADER], 10) < options.retries)) {
+                    && (!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,
-                        [RETRY_HEADER]: msg.properties.headers[RETRY_HEADER]
-                            ? msg.properties.headers[RETRY_HEADER] + 1
+                        [consts_1.RETRY_HEADER]: msg.properties.headers[consts_1.RETRY_HEADER]
+                            ? msg.properties.headers[consts_1.RETRY_HEADER] + 1
                             : 1,
                     });
                 }
@@ -86,8 +70,8 @@ class RabbitMq {
                     const deadQueue = `${queue}-dead`;
                     await this.sendToQueue(deadQueue, RabbitMq.parseMsg(msg).content, deadQueueOptions, {
                         ...msg.properties.headers,
-                        [RETRY_HEADER]: msg.properties.headers[RETRY_HEADER]
-                            ? msg.properties.headers[RETRY_HEADER] + 1
+                        [consts_1.RETRY_HEADER]: msg.properties.headers[consts_1.RETRY_HEADER]
+                            ? msg.properties.headers[consts_1.RETRY_HEADER] + 1
                             : 1,
                     });
                 }
@@ -113,12 +97,14 @@ class RabbitMq {
         }
         this.consumersTags = [];
         logger_1.default.info(`rabbit: [gracefully-shutdown] adding gracefully shutdown for process.pid ${process.pid}`);
-        process.on('SIGTERM', async () => {
-            await this.gracefulShutdown('SIGTERM');
-        });
-        process.on('SIGINT', async () => {
-            await this.gracefulShutdown('SIGINT');
-        });
+        if (!this.options?.dontGracefulShutdown) {
+            process.on('SIGTERM', async () => {
+                await this.gracefulShutdown('SIGTERM');
+            });
+            process.on('SIGINT', async () => {
+                await this.gracefulShutdown('SIGINT');
+            });
+        }
     }
     static parseMsg(msg) {
         let { content } = msg;
@@ -144,57 +130,91 @@ class RabbitMq {
             headers: {
                 creationTimestamp: moment_1.default().valueOf(),
                 ...customHeaders,
-                [TRACING_HEADER]: trace?.context?.get(TRACING_HEADER),
+                [consts_1.TRACING_HEADER]: trace?.context?.get(consts_1.TRACING_HEADER),
             },
         };
     }
     async getConnection() {
         return new Promise(async (resolve) => {
+            if (this.blockReconnect) {
+                debug('rabbit: block reconnect');
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                return resolve();
+            }
             if (this.connection !== null) {
-                return resolve(this.connection);
+                debug('rabbit: connection already exist');
+                if (this.options?.disableReconnect || this.connection?.isConnected()) {
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore
+                    return resolve(this.connection);
+                }
+                debug('rabbit: connection already exist - reconnecting');
             }
             if (this.creatingConnection) {
-                this.em.once(connectionCreatedConst, resolve);
+                debug('rabbit: creating connection emi');
+                this.em.once(consts_1.CONNECTION_CREATED_CONST, resolve);
                 return;
             }
             this.creatingConnection = true;
-            logger_1.default.info('rabbit: env username', { userName: (process.env.RABBITMQ_USERNAME || 'doesnt exist') });
-            const username = process.env.RABBITMQ_USERNAME || 'guest';
-            const password = process.env.RABBITMQ_PASSWORD || 'guest';
-            const host = process.env.RABBITMQ_SERVICE_HOST || '';
-            const connection = await amqp_connection_manager_1.connect([`amqp://${username}:${password}@${host}?heartbeat=60`]);
+            debug('rabbit: creating connection', { HOST, USERNAME, HEARTBEAT });
+            const connection = await amqp_connection_manager_1.connect([`amqp://${USERNAME}:${PASSWORD}@${HOST}?heartbeat=${HEARTBEAT}}`]);
             this.connection = connection;
             this.connection.on('disconnect', ({ err }) => {
+                debug('rabbit: connection closed');
                 this.exchanges = {};
                 this.queues = {};
+                this.connection = null;
+                this.channel = null;
                 if (this.options?.disableReconnect) {
                     logger_1.default.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
+                    this.blockReconnect = true;
                 }
                 else {
-                    logger_1.default.error(`${this.RESCONNECT_MSG}${err && ` - ${err}`}`);
-                    this.connection = null;
+                    logger_1.default.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
                 }
             });
-            this.creatingConnection = false;
-            this.em.emit(connectionCreatedConst, connection);
-            resolve(connection);
+            this.connection.once('connect', async () => {
+                debug('rabbit: connection established');
+                await this.loadConsumers();
+                this.creatingConnection = false;
+                this.em.emit(consts_1.CONNECTION_CREATED_CONST, connection);
+                resolve(connection);
+            });
         });
     }
-    async getNewChannel() {
-        const connection = await this.getConnection();
-        return connection.createChannel({});
+    async getNewChannel({ name = '', onClose = null } = {}) {
+        return new Promise(async (resolve, reject) => {
+            const connection = await this.getConnection();
+            const channel = connection.createChannel({});
+            channel.on('error', (err) => {
+                logger_1.default.error(`rabbit: channel ${name} error`, { err });
+            });
+            channel.on('close', (...args) => {
+                logger_1.default.error(`rabbit: channel ${name} closed`, { args });
+                if (onClose) {
+                    onClose(args);
+                }
+            });
+            channel.once('connect', () => {
+                debug(`rabbit: channel ${name} CONNECTED`);
+                resolve(channel);
+            });
+        });
     }
-    async assertChannel() {
+    async assertChannel({ force = false } = {}) {
         return new Promise(async (resolve, reject) => {
-            if (this.channel) {
+            if (this.channel && !force) {
                 return resolve(this.channel);
             }
             try {
-                const connection = await this.getConnection();
-                if (this.channel === null) {
-                    this.channel = await connection.createChannel({});
-                }
-                resolve(this.channel);
+                const channel = await this.getNewChannel({
+                    onClose: () => {
+                        this.channel = null;
+                    },
+                });
+                this.channel = channel;
+                resolve(channel);
             }
             catch (e) {
                 reject(e);
@@ -206,42 +226,88 @@ class RabbitMq {
         if (this.exchanges[exchangeName]) {
             return this.exchanges[exchangeName];
         }
-        const exchange = await assertExchangeFanout(channel, exchangeName);
+        const exchange = await utils_1.assertExchangeFanout(channel, exchangeName);
         this.exchanges[exchangeName] = exchange;
         return exchange;
     }
     async getQueueLength(queue) {
         RabbitMq.validateName('queue', queue);
         const channel = await this.assertChannel();
-        // @ts-ignore
+        debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
         return channel.checkQueue(queue);
     }
+    async deleteQueue(queue) {
+        return new Promise(async (resolve, reject) => {
+            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);
+            resolve(deleteQueueRes);
+        });
+    }
     async bindQueue(queue, exchange) {
         const channel = await this.assertChannel();
         await channel.addSetup((setupChannel) => setupChannel.bindQueue(queue, exchange, ''));
-        // @ts-ignore
         return channel.bindQueue(queue, exchange, '');
     }
     async assertQueue(queueName, options) {
+        let queue = null;
         RabbitMq.validateName('queue', queueName);
-        const channel = await this.assertChannel();
         if (this.queues[queueName]) {
             return this.queues[queueName];
         }
-        await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, options));
-        const queue = await channel.assertQueue(queueName, options);
+        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('1assertQueue->channel.addSetup', { queueName });
+                await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, options));
+                debug('1assertQueue->channel.assertQueue', { queueName });
+                queue = await channel.assertQueue(queueName, options);
+            }
+            else {
+                throw e;
+            }
+        }
         this.queues[queueName] = queueName;
         return queue;
     }
+    saveConsumer(queue, callback, options) {
+        this.consumers.push({
+            queue,
+            callback,
+            options,
+        });
+    }
+    async loadConsumers() {
+        debug('rabbit: loading consumers', { consumers: this.consumers.length });
+        if (this.consumers.length > 0) {
+            await Promise.all(this.consumers.map((consumer) => this
+                .consumeFromRabbit(consumer.queue, consumer.callback, consumer.options)));
+        }
+    }
     async consume(queue, callback, options) {
-        return this.consumeFromRabbit(queue, callback, options);
+        if (this.connection && !this.creatingConnection) {
+            this.consumeFromRabbit(queue, callback, options);
+        }
+        return this.saveConsumer(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 || DEFAULT_LOCK_TIMEOUT);
+            releaseLock = await this.redisLock(headers.redisTimestampValidationKey, options?.lockTimeout || consts_1.DEFAULT_LOCK_TIMEOUT);
         }
         return releaseLock;
     }
@@ -251,7 +317,7 @@ class RabbitMq {
         }
     }
     async consumeFromRabbit(queue, callback, options) {
-        const optionsWithDefaults = { ...defaultOptions, ...options };
+        const optionsWithDefaults = { ...consts_1.DEFAULT_OPTIONS, ...options };
         RabbitMq.validateName('queue', queue);
         const { limit, deadMessageTtl, useConsumeWithLock, lockTimeout, } = optionsWithDefaults;
         if (useConsumeWithLock) {
@@ -260,18 +326,18 @@ 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({ name: `consume-${queue}` });
         return channel.addSetup(async (c) => {
-            await c.assertQueue(queue);
+            await c.assertQueue(queue, options ? { messageTtl: options.messageTtl } : undefined);
             await c.prefetch(limit, true);
             const { consumerTag } = await c.consume(queue, async (msg) => {
                 if (!msg) {
                     return null;
                 }
-                const traceId = msg.properties.headers[TRACING_HEADER];
+                const traceId = msg.properties.headers[consts_1.TRACING_HEADER];
                 if (traceId) {
                     const trace = outbreak_1.newTrace(outbreak_1.traceTypes.RABBIT);
-                    trace?.context?.set(TRACING_HEADER, traceId);
+                    trace?.context?.set(consts_1.TRACING_HEADER, traceId);
                 }
                 const parsedMessage = RabbitMq.parseMsg(msg);
                 const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
@@ -286,7 +352,7 @@ class RabbitMq {
                 catch (e) {
                     await this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
                 }
-            });
+            }, types_1.CONSUMER_DEFAULT_OPTIONS);
             if (!consumerTag) {
                 logger_1.default.error(`rabbit: failed to consume from queue ${queue}`);
             }
@@ -297,13 +363,13 @@ class RabbitMq {
         });
     }
     async consumeFromExchange(queue, exchange, callback, options) {
-        const optionsWithDefaults = { ...defaultOptions, ...options };
+        const optionsWithDefaults = { ...consts_1.DEFAULT_OPTIONS, ...options };
         RabbitMq.validateName('exchange', exchange);
         RabbitMq.validateName('queue', queue);
         const { limit, deadMessageTtl } = optionsWithDefaults;
         const channel = await this.getNewChannel();
         return channel.addSetup(async (c) => {
-            const assertExchange = await assertExchangeFanout(c, exchange);
+            const assertExchange = await utils_1.assertExchangeFanout(c, exchange);
             await c.assertQueue(queue);
             this.exchanges[exchange] = assertExchange;
             await c.prefetch(limit, true);
@@ -314,20 +380,26 @@ class RabbitMq {
         });
     }
     async publish(exchange, content, customHeaders) {
-        return wrapSetImmediate(async () => {
+        return 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) {
-        return wrapSetImmediate(async () => {
+    async sendToQueue(queue, content, options, customHeaders, isBlocking) {
+        const callback = async () => {
             RabbitMq.validateName('queue', queue);
-            const channel = await this.assertChannel();
+            await this.assertChannel();
             await this.assertQueue(queue, options);
-            return channel.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
-        });
+            const res = await this.channel?.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
+            debug(`rabbit: sending to queue ${queue}`, { res });
+            return res;
+        };
+        if (isBlocking) {
+            return callback();
+        }
+        return utils_1.wrapSetImmediate(callback);
     }
     async isConnected() {
         const connection = await this.getConnection();

package/dist/lib/consts.d.ts

@@ -0,0 +1,13 @@
+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 DEFAULT_USE_CONSUME_WITH_LOCK = false;
+export declare const CONNECTION_CREATED_CONST = "connectionCreated";
+export declare const DEFAULT_OPTIONS: {
+    limit: number;
+    retries: number;
+    deadMessageTtl: number;
+    lockTimeout: number;
+    useConsumeWithLock: boolean;
+};

package/dist/lib/consts.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_OPTIONS = exports.CONNECTION_CREATED_CONST = exports.DEFAULT_USE_CONSUME_WITH_LOCK = 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.DEFAULT_USE_CONSUME_WITH_LOCK = false;
+exports.CONNECTION_CREATED_CONST = 'connectionCreated';
+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,
+};

package/dist/lib/types.d.ts

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

package/dist/lib/types.js

@@ -0,0 +1,11 @@
+"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

@@ -0,0 +1,4 @@
+import { ChannelWrapper } from 'amqp-connection-manager';
+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>;

package/dist/lib/utils.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "2.5.4",
+  "version": "3.0.0-alpha",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/index.ts

@@ -1,15 +1,37 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment,@typescript-eslint/ban-types,@typescript-eslint/no-unused-vars,consistent-return,no-async-promise-executor,no-param-reassign,no-empty */
-// eslint-disable-next-line max-classes-per-file
+/* eslint-disable no-empty,consistent-return,no-async-promise-executor,@typescript-eslint/no-unused-vars */
+
+import { EventEmitter } from 'events';
+import { promisify } from 'util';
 import moment from 'moment';
 import RedisLock from 'redis-lock';
-import { ConfirmChannel, Options, ConsumeMessage } from 'amqplib';
 import { AmqpConnectionManager, ChannelWrapper, connect } from 'amqp-connection-manager';
-import { EventEmitter } from 'events';
-import { promisify } from 'util';
-import { traceTypes, getCurrentContext, newTrace } from '@autofleet/outbreak';
+import {
+  ConfirmChannel, ConsumeMessage, Options, Replies,
+} from 'amqplib';
+import { getCurrentContext, newTrace, traceTypes } from '@autofleet/outbreak';
 import logger from './logger';
-import RabbitError from './rabbitError';
-import getRedisInstance, { RedisConfig } from './redis';
+import RabbitError from './lib/rabbitError';
+import getRedisInstance, { RedisConfig } from './lib/redis';
+import { assertExchangeFanout, wrapSetImmediate } from './lib/utils';
+import {
+  CONNECTION_CREATED_CONST,
+  DEFAULT_LOCK_TIMEOUT,
+  DEFAULT_OPTIONS,
+  RETRY_HEADER,
+  TRACING_HEADER,
+} from './lib/consts';
+import {
+  CallbackFunction,
+  ConsumeMessageOrNull,
+  ConsumeOptions,
+  CustomMessageHeaders,
+  QueuesCache,
+  RedisLockType,
+  ExchangesCache, CONSUMER_DEFAULT_OPTIONS,
+} from './lib/types';
+
+// const debug = nodeDebug('af-rabbitmq')
+const debug = logger.info;
 
 export interface IAfRabbitMq {
   ack: any;
@@ -24,62 +46,45 @@ export interface IAfRabbitMq {
   redisClient?: any;
 }
 
-interface ExchangesCache {
-  [key: string]: any
-}
-interface QueuesCache {
-  [key: string]: any
-}
-
-type CustomMessageHeaders = {
-  redisTimestampValidationKey?: string;
+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;
 }
 
-type RedisLockType = (args0?: string, arg1?: number) => Promise<any>
+type newChannelOpts = {
+  name?: string;
+  onClose?: null | ((args: any | null) => void);
+};
 
-type ConsumeMessageOrNull = ConsumeMessage | null;
-interface ConsumeOptions {
-  retries?: number;
-  deadMessageTtl?: number;
-  limit?: number;
-  lockTimeout?: number;
-  useConsumeWithLock?: boolean;
+type assertChannelOpts = {
+  channelName?: string;
+  force?: boolean;
 }
 
-type CallbackFunction = (msg: ConsumeMessage, ack: Function, nack: Function) => Promise<any>
-
-export interface AfRabbitOptions {
-  disableReconnect: boolean;
+type AfConsumer = {
+  queue: string;
+  callback: CallbackFunction;
+  options: ConsumeOptions | undefined;
 }
 
-const DEFAULT_DEAD_TTL_TWO_DAYS = 60000 * 60 * 12;
-const DEFAULT_LOCK_TIMEOUT = 1000 * 5;
-const RETRY_HEADER = 'x-retry-count';
-const TRACING_HEADER = 'x-trace-id';
-const DEFAULT_USE_CONSUME_WITH_LOCK = false;
-
-const defaultOptions = {
-  limit: 1,
-  retries: 1,
-  deadMessageTtl: DEFAULT_DEAD_TTL_TWO_DAYS,
-  lockTimeout: DEFAULT_LOCK_TIMEOUT,
-  useConsumeWithLock: DEFAULT_USE_CONSUME_WITH_LOCK,
-};
+const USERNAME: string = process.env.RABBITMQ_USERNAME || 'guest';
 
-const assertExchangeFanout = async (c: ChannelWrapper | ConfirmChannel, exchangeName: string) => c.assertExchange(exchangeName, 'fanout');
+const PASSWORD: string = process.env.RABBITMQ_PASSWORD || 'guest';
 
-const connectionCreatedConst = 'connectionCreated';
+const HOST: string = process.env.RABBITMQ_SERVICE_HOST || 'localhost';
 
-const wrapSetImmediate = (callback: () => any) => new Promise<any>(async (resolve, reject) => {
-  setImmediate(async () => {
-    try {
-      const value = await callback();
-      resolve(value);
-    } catch (error) {
-      reject(error);
-    }
-  });
-});
+const HEARTBEAT = '60';
 
 class RabbitMq implements IAfRabbitMq {
   static parseMsg(msg: any) : any {
@@ -114,17 +119,19 @@ class RabbitMq implements IAfRabbitMq {
     };
   }
 
-  PUBLISH_TIMEOUT = Number(process.env.RABBITMQ_PUBLISH_TIMEOUT) || 60000;
+  // PUBLISH_TIMEOUT = Number(process.env.RABBITMQ_PUBLISH_TIMEOUT) || 60000;
 
-  PUBLISH_ERROR_MSG = `rabbit: publish timeout(${this.PUBLISH_TIMEOUT}ms) has pass, exchange: `;
+  // PUBLISH_ERROR_MSG = `rabbit: publish timeout(${this.PUBLISH_TIMEOUT}ms) has pass, exchange: `;
 
   DISCONNECT_MSG = 'rabbit: connection disconnect';
 
-  RESCONNECT_MSG = 'rabbit: reconnecting';
+  RECONNECT_MSG = 'rabbit: connection disconnect - reconnecting';
 
   channel: ChannelWrapper | null;
 
-  connection: AmqpConnectionManager | null;
+  blockReconnect: boolean | null | undefined
+
+  connection: AmqpConnectionManager | null | undefined
 
   em: EventEmitter;
 
@@ -143,6 +150,8 @@ class RabbitMq implements IAfRabbitMq {
   /** Array of consumers tags used for canceling consumption */
   consumersTags: Array<[ConfirmChannel, string]>;
 
+  private consumers: Array<AfConsumer> = [];
+
   constructor(options?: AfRabbitOptions, redisConfig?: RedisConfig) {
     this.em = new EventEmitter();
     this.channel = null;
@@ -157,12 +166,14 @@ class RabbitMq implements IAfRabbitMq {
     }
     this.consumersTags = [];
     logger.info(`rabbit: [gracefully-shutdown] adding gracefully shutdown for process.pid ${process.pid}`);
-    process.on('SIGTERM', async () => {
-      await this.gracefulShutdown('SIGTERM');
-    });
-    process.on('SIGINT', async () => {
-      await this.gracefulShutdown('SIGINT');
-    });
+    if (!this.options?.dontGracefulShutdown) {
+      process.on('SIGTERM', async () => {
+        await this.gracefulShutdown('SIGTERM');
+      });
+      process.on('SIGINT', async () => {
+        await this.gracefulShutdown('SIGINT');
+      });
+    }
   }
 
   private shouldConsumeMessageByTimestamp = async (msg: ConsumeMessageOrNull) => {
@@ -241,54 +252,88 @@ class RabbitMq implements IAfRabbitMq {
 
   async getConnection() {
     return new Promise<AmqpConnectionManager>(async (resolve) => {
+      if (this.blockReconnect) {
+        debug('rabbit: block reconnect');
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        return resolve();
+      }
       if (this.connection !== null) {
-        return resolve(this.connection);
+        debug('rabbit: connection already exist');
+        if (this.options?.disableReconnect || this.connection?.isConnected()) {
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          return resolve(this.connection);
+        }
+        debug('rabbit: connection already exist - reconnecting');
       }
       if (this.creatingConnection) {
-        this.em.once(connectionCreatedConst, resolve);
+        debug('rabbit: creating connection emi');
+        this.em.once(CONNECTION_CREATED_CONST, resolve);
         return;
       }
       this.creatingConnection = true;
-      logger.info('rabbit: env username', { userName: (process.env.RABBITMQ_USERNAME || 'doesnt exist') });
-      const username: string = process.env.RABBITMQ_USERNAME || 'guest';
-      const password: string = process.env.RABBITMQ_PASSWORD || 'guest';
-      const host: string = process.env.RABBITMQ_SERVICE_HOST || '';
-      const connection: AmqpConnectionManager = await connect([`amqp://${username}:${password}@${host}?heartbeat=60`]);
+      debug('rabbit: creating connection', { HOST, USERNAME, HEARTBEAT });
+      const connection: AmqpConnectionManager = await connect([`amqp://${USERNAME}:${PASSWORD}@${HOST}?heartbeat=${HEARTBEAT}}`]);
       this.connection = connection;
-      this.connection.on('disconnect',
-        ({ err }) => {
-          this.exchanges = {};
-          this.queues = {};
-          if (this.options?.disableReconnect) {
-            logger.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
-          } else {
-            logger.error(`${this.RESCONNECT_MSG}${err && ` - ${err}`}`);
-            this.connection = null;
-          }
-        });
-      this.creatingConnection = false;
-      this.em.emit(connectionCreatedConst, connection);
-      resolve(connection);
+      this.connection.on('disconnect', ({ err }) => {
+        debug('rabbit: connection closed');
+        this.exchanges = {};
+        this.queues = {};
+        this.connection = null;
+        this.channel = null;
+        if (this.options?.disableReconnect) {
+          logger.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
+          this.blockReconnect = true;
+        } else {
+          logger.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
+        }
+      });
+      this.connection.once('connect', async () => {
+        debug('rabbit: connection established');
+        await this.loadConsumers();
+        this.creatingConnection = false;
+        this.em.emit(CONNECTION_CREATED_CONST, connection);
+        resolve(connection);
+      });
     });
   }
 
-  async getNewChannel() {
-    const connection: AmqpConnectionManager = await this.getConnection();
-    return connection.createChannel({});
+  async getNewChannel({ name = '', onClose = null }: newChannelOpts = {}) {
+    return new Promise<ChannelWrapper>(async (resolve, reject) => {
+      const connection: AmqpConnectionManager = await this.getConnection();
+      const channel = connection.createChannel({});
+
+      channel.on('error', (err) => {
+        logger.error(`rabbit: channel ${name} error`, { err });
+      });
+      channel.on('close', (...args) => {
+        logger.error(`rabbit: channel ${name} closed`, { args });
+        if (onClose) {
+          onClose(args);
+        }
+      });
+      channel.once('connect', () => {
+        debug(`rabbit: channel ${name} CONNECTED`);
+        resolve(channel);
+      });
+    });
   }
 
-  async assertChannel() {
+  async assertChannel({ force = false } : assertChannelOpts = {}): Promise<ChannelWrapper> {
     return new Promise<ChannelWrapper>(async (resolve, reject) => {
-      if (this.channel) {
+      if (this.channel && !force) {
         return resolve(this.channel);
       }
 
       try {
-        const connection: AmqpConnectionManager = await this.getConnection();
-        if (this.channel === null) {
-          this.channel = await connection.createChannel({});
-        }
-        resolve(this.channel);
+        const channel = await this.getNewChannel({
+          onClose: () => {
+            this.channel = null;
+          },
+        });
+        this.channel = channel;
+        resolve(channel);
       } catch (e) {
         reject(e);
       }
@@ -308,31 +353,82 @@ class RabbitMq implements IAfRabbitMq {
   async getQueueLength(queue: string) {
     RabbitMq.validateName('queue', queue);
     const channel: ChannelWrapper = await this.assertChannel();
-    // @ts-ignore
+    debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
     return channel.checkQueue(queue);
   }
 
+  private async deleteQueue(queue: string) {
+    return new Promise(async (resolve, reject) => {
+      RabbitMq.validateName('queue', queue);
+      const channel: ChannelWrapper = await this.assertChannel();
+      logger.info('rabbit: deleting queue', { queue });
+      const deleteQueueRes = await channel.deleteQueue(queue);
+      debug('queue deleted', deleteQueueRes);
+      resolve(deleteQueueRes);
+    });
+  }
+
   async bindQueue(queue: string, exchange: string) {
     const channel: ChannelWrapper = await this.assertChannel();
     await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.bindQueue(queue, exchange, ''));
-    // @ts-ignore
     return channel.bindQueue(queue, exchange, '');
   }
 
   async assertQueue(queueName: string, options?: Options.AssertQueue) {
+    let queue: Replies.AssertQueue | null = null;
     RabbitMq.validateName('queue', queueName);
-    const channel: ChannelWrapper = await this.assertChannel();
     if (this.queues[queueName]) {
       return this.queues[queueName];
     }
-    await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, options));
-    const queue = await channel.assertQueue(queueName, options);
+    try {
+      const channel: ChannelWrapper = await this.assertChannel();
+      debug('assertQueue->channel.addSetup', { queueName });
+      await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, options));
+      debug('assertQueue->channel.assertQueue', { queueName });
+      queue = await channel.assertQueue(queueName, options);
+    } catch (e) {
+      logger.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('1assertQueue->channel.addSetup', { queueName });
+        await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, options));
+        debug('1assertQueue->channel.assertQueue', { queueName });
+        queue = await channel.assertQueue(queueName, options);
+      } else {
+        throw e;
+      }
+    }
+
     this.queues[queueName] = queueName;
     return queue;
   }
 
+  private saveConsumer(queue: string, callback: CallbackFunction, options: ConsumeOptions | undefined) {
+    this.consumers.push({
+      queue,
+      callback,
+      options,
+    });
+  }
+
+  private async loadConsumers() {
+    debug('rabbit: loading consumers', { consumers: this.consumers.length });
+    if (this.consumers.length > 0) {
+      await Promise.all(
+        this.consumers.map((consumer) => this
+          .consumeFromRabbit(consumer.queue, consumer.callback, consumer.options)),
+      );
+    }
+  }
+
   async consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
-    return this.consumeFromRabbit(queue, callback, options);
+    if (this.connection && !this.creatingConnection) {
+      this.consumeFromRabbit(queue, callback, options);
+    }
+    return this.saveConsumer(queue, callback, options);
   }
 
   private async lockRedisIfNeeded(msg: any, options: any) {
@@ -356,7 +452,7 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   private async consumeFromRabbit(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
-    const optionsWithDefaults = { ...defaultOptions, ...options };
+    const optionsWithDefaults = { ...DEFAULT_OPTIONS, ...options };
     RabbitMq.validateName('queue', queue);
     const {
       limit, deadMessageTtl, useConsumeWithLock, lockTimeout,
@@ -367,9 +463,9 @@ class RabbitMq implements IAfRabbitMq {
       }
       logger.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
     }
-    const channel: ChannelWrapper = await this.getNewChannel();
+    const channel: ChannelWrapper = await this.getNewChannel({ name: `consume-${queue}` });
     return channel.addSetup(async (c: ConfirmChannel) => {
-      await c.assertQueue(queue);
+      await c.assertQueue(queue, options ? { messageTtl: options.messageTtl } : undefined);
       await c.prefetch(limit, true);
       const { consumerTag } = await c.consume(
         queue,
@@ -400,7 +496,7 @@ class RabbitMq implements IAfRabbitMq {
           } catch (e) {
             await this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
           }
-        },
+        }, CONSUMER_DEFAULT_OPTIONS,
       );
       if (!consumerTag) {
         logger.error(`rabbit: failed to consume from queue ${queue}`);
@@ -412,7 +508,7 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   async consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions) : Promise<any> {
-    const optionsWithDefaults = { ...defaultOptions, ...options };
+    const optionsWithDefaults = { ...DEFAULT_OPTIONS, ...options };
     RabbitMq.validateName('exchange', exchange);
     RabbitMq.validateName('queue', queue);
     const { limit, deadMessageTtl } = optionsWithDefaults;
@@ -445,15 +541,27 @@ class RabbitMq implements IAfRabbitMq {
     });
   }
 
-  async sendToQueue(queue: string, content: any, options?: any, customHeaders?: any) : Promise<boolean> {
-    return wrapSetImmediate(async () => {
+  async sendToQueue(
+    queue: string,
+    content: any,
+    options?: any,
+    customHeaders?: any,
+    isBlocking?: boolean,
+  ): Promise<boolean | undefined> {
+    const callback = async (): Promise<boolean | undefined> => {
       RabbitMq.validateName('queue', queue);
-      const channel: ChannelWrapper = await this.assertChannel();
+      await this.assertChannel();
       await this.assertQueue(queue, options);
-      return channel.sendToQueue(queue,
+      const res = await this.channel?.sendToQueue(queue,
         Buffer.from(JSON.stringify(content)),
         RabbitMq.getPublishOptions(customHeaders));
-    });
+      debug(`rabbit: sending to queue ${queue}`, { res });
+      return res;
+    };
+    if (isBlocking) {
+      return callback();
+    }
+    return wrapSetImmediate(callback);
   }
 
   async isConnected() : Promise<boolean> {

package/src/lib/consts.ts

@@ -0,0 +1,13 @@
+export const DEFAULT_DEAD_TTL_TWO_DAYS = 60000 * 60 * 12;
+export const DEFAULT_LOCK_TIMEOUT = 1000 * 5;
+export const RETRY_HEADER = 'x-retry-count';
+export const TRACING_HEADER = 'x-trace-id';
+export const DEFAULT_USE_CONSUME_WITH_LOCK = false;
+export const CONNECTION_CREATED_CONST = 'connectionCreated';
+export const DEFAULT_OPTIONS = {
+  limit: 1,
+  retries: 1,
+  deadMessageTtl: DEFAULT_DEAD_TTL_TWO_DAYS,
+  lockTimeout: DEFAULT_LOCK_TIMEOUT,
+  useConsumeWithLock: DEFAULT_USE_CONSUME_WITH_LOCK,
+};

package/src/lib/types.ts

@@ -0,0 +1,51 @@
+import { ConsumeMessage, Options } from 'amqplib';
+
+export interface ExchangesCache {
+  [key: string]: any
+}
+
+export interface QueuesCache {
+  [key: string]: any
+}
+
+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;
+}
+
+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;
+}
+
+const HA_PROMOTE_ON_FAILURE = 'ha-promote-on-failure';
+
+const HA_PROMOTE_ON_SHUTDOWN = 'ha-promote-on-shutdown';
+
+export const CONSUMER_DEFAULT_OPTIONS: Options.Consume = {
+  arguments: {
+    [HA_PROMOTE_ON_FAILURE]: 'always',
+    [HA_PROMOTE_ON_SHUTDOWN]: 'always',
+  },
+};

package/src/lib/utils.ts

@@ -0,0 +1,14 @@
+import { ChannelWrapper } from 'amqp-connection-manager';
+import { ConfirmChannel } from 'amqplib';
+
+export const assertExchangeFanout = async (c: ChannelWrapper | ConfirmChannel, exchangeName: string) => c.assertExchange(exchangeName, 'fanout');
+export const wrapSetImmediate = (callback: () => any) => new Promise<any>((resolve, reject) => {
+  setImmediate(async () => {
+    try {
+      const value = await callback();
+      resolve(value);
+    } catch (error) {
+      reject(error);
+    }
+  });
+});