@autofleet/rabbit 2.1.8-beta1 → 2.1.8-beta10

package/dist/index.d.ts

@@ -2,15 +2,35 @@
 import { Options } from 'amqplib';
 import { AmqpConnectionManager, ChannelWrapper } from 'amqp-connection-manager';
 import { EventEmitter } from 'events';
+import { RedisConfig } from './redis';
+export interface IAfRabbitMq {
+    ack: any;
+    nack: any;
+    assertChannel: any;
+    assertExchange: any;
+    assertQueue: any;
+    consume: any;
+    consumeFromExchange: any;
+    publish: any;
+    sendToQueue: any;
+    redisClient?: any;
+}
 interface ExchangesCache {
     [key: string]: any;
 }
+declare type CustomMessageHeaders = {
+    redisTimestampValidationKey?: string;
+};
 export interface AfRabbitOptions {
     reconnect: boolean;
 }
-declare class RabbitMq {
+declare class RabbitMq implements IAfRabbitMq {
     static parseMsg(msg: any): any;
     static validateName(type: string, name: string): void;
+    static getPublishOptions(customHeaders?: CustomMessageHeaders): {
+        timestamp: number;
+        headers: CustomMessageHeaders;
+    };
     PUBLISH_TIMEOUT: number;
     PUBLISH_ERROR_MSG: string;
     DISCONNECT_MSG: string;
@@ -21,19 +41,22 @@ declare class RabbitMq {
     creatingConnection: boolean;
     exchanges: ExchangesCache;
     options: AfRabbitOptions | undefined;
-    constructor(options?: AfRabbitOptions);
-    ack: (msg: any) => Promise<void>;
-    nack: (queue: string, options: any, deadQueueOptions: Options.AssertQueue) => (msg: any, { skipRetry, }?: any) => Promise<void>;
+    redisClient: any;
+    constructor(options?: AfRabbitOptions, redisConfig?: RedisConfig);
+    private shouldConsumeMessageByTimestamp;
+    ack: (channel: ChannelWrapper, shouldUpdateRedisTimestamp?: boolean) => (msg: any) => Promise<void>;
+    nack: (channel: ChannelWrapper, queue: string, options: any, deadQueueOptions: Options.AssertQueue) => (msg: any, { skipRetry, }?: any) => Promise<void>;
     getConnection(): Promise<AmqpConnectionManager>;
     getNewChannel(): Promise<ChannelWrapper>;
     assertChannel(): Promise<ChannelWrapper>;
     assertExchange(exchangeName: string, options?: any): Promise<any>;
-    getQueueLength(queue: string): Promise<any>;
-    bindQueue(queue: string, exchange: string): Promise<any>;
+    getQueueLength(queue: string): Promise<import("amqplib").Replies.AssertQueue>;
+    bindQueue(queue: string, exchange: string): Promise<void>;
     assertQueue(queue: string, options?: Options.AssertQueue): Promise<void>;
     consume(queue: string, callback: (msg: any, ack: Function, nack: Function) => any, options?: any): Promise<void>;
     consumeFromExchange(queue: string, exchange: string, callback: (msg: any, ack: Function, nack: Function) => any, options?: any): Promise<void>;
-    publish(exchange: string, content: any): Promise<unknown>;
-    sendToQueue(queue: string, content: any, options?: any): Promise<void>;
+    publish(exchange: string, content: any, customHeaders?: any): Promise<unknown>;
+    sendToQueue(queue: string, content: any, options?: any, customHeaders?: any): Promise<boolean>;
+    isConnected(): Promise<boolean>;
 }
 export default RabbitMq;

package/dist/index.js

@@ -34,31 +34,49 @@ 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 bluebird = __importStar(require("bluebird"));
+const moment_1 = __importDefault(require("moment"));
 const amqp_connection_manager_1 = require("amqp-connection-manager");
 const events_1 = require("events");
-const outbreak_1 = require("@autofleet/outbreak");
+// import { newTrace, traceTypes } from '@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 * 48;
 const defaultOptions = {
     limit: 1,
     retries: 1,
     deadMessageTtl: DEFAULT_DEAD_TTL_TWO_DAYS,
 };
+const SECONDS_TO_MILLISECONDS = 1000;
 const assertExchangeFanout = (c, exchangeName) => c.assertExchange(exchangeName, 'fanout');
 const connectionCreatedConst = 'connectionCreated';
 class RabbitMq {
-    constructor(options) {
+    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: `;
         this.DISCONNECT_MSG = 'rabbit: connection disconnect';
         this.RESCONNECT_MSG = 'rabbit: reconnecting';
-        this.ack = (msg) => __awaiter(this, void 0, void 0, function* () {
-            if (this.channel) {
-                yield this.channel.ack(msg);
+        this.shouldConsumeMessageByTimestamp = (msg) => __awaiter(this, void 0, void 0, function* () {
+            const { properties: { timestamp, headers } } = msg;
+            if (timestamp && (headers === null || headers === void 0 ? void 0 : headers.redisTimestampValidationKey) && this.redisClient) {
+                const lastMessageTimestamp = yield this.redisClient.getAsync(headers.redisTimestampValidationKey);
+                logger_1.default.info('rabbit: checking if should consume params', {
+                    msg, timestamp, headers, lastMessageTimestamp,
+                });
+                return !lastMessageTimestamp || (parseInt(lastMessageTimestamp, 10) <= parseInt(timestamp, 10));
+            }
+            return true;
+        });
+        this.ack = (channel, shouldUpdateRedisTimestamp = false) => (msg) => __awaiter(this, void 0, void 0, function* () {
+            yield channel.ack(msg);
+            const { properties: { timestamp, headers } } = msg;
+            if (shouldUpdateRedisTimestamp && timestamp && (headers === null || headers === void 0 ? void 0 : headers.redisTimestampValidationKey) && this.redisClient) {
+                const parsedTimestamp = parseInt(timestamp, 10);
+                yield this.redisClient.setAsync(headers.redisTimestampValidationKey, parsedTimestamp, 'EX', 3600);
             }
         });
-        this.nack = (queue, options, deadQueueOptions) => (msg, { skipRetry = false, } = {}) => __awaiter(this, void 0, void 0, function* () {
-            if (this.channel) {
+        this.nack = (channel, queue, options, deadQueueOptions) => (msg, { skipRetry = false, } = {}) => __awaiter(this, void 0, void 0, function* () {
+            if (channel) {
                 if (!skipRetry
                     && (!msg.content['x-retry-count']
                         || msg.content['x-retry-count'] < options.retries)) {
@@ -70,7 +88,7 @@ class RabbitMq {
                     yield this.assertQueue(deadQueue, deadQueueOptions);
                     yield this.sendToQueue(deadQueue, msg.content, deadQueueOptions);
                 }
-                yield this.channel.ack(msg);
+                yield channel.ack(msg);
             }
         });
         this.em = new events_1.EventEmitter();
@@ -79,6 +97,7 @@ class RabbitMq {
         this.creatingConnection = false;
         this.exchanges = {};
         this.options = options;
+        this.redisClient = redisConfig && redis_1.default(redisConfig);
     }
     static parseMsg(msg) {
         let { content } = msg;
@@ -94,19 +113,27 @@ class RabbitMq {
             throw new rabbitError_1.default(`error while using ${type} with no name`);
         }
     }
+    static getPublishOptions(customHeaders = {}) {
+        return {
+            timestamp: moment_1.default().unix(),
+            headers: customHeaders,
+        };
+    }
     getConnection() {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
                 if (this.creatingConnection) {
-                    this.em.on(connectionCreatedConst, resolve);
+                    this.em.once(connectionCreatedConst, resolve);
                     return;
                 }
                 if (this.connection !== null) {
-                    return this.connection;
+                    return resolve(this.connection);
                 }
                 this.creatingConnection = true;
+                const username = process.env.RABBITMQ_USERNAME || 'guest';
+                const password = process.env.RABBITMQ_PASSWORD || 'guest';
                 const host = process.env.RABBITMQ_SERVICE_HOST || '';
-                const connection = yield amqp_connection_manager_1.connect([`amqp://${host}`]);
+                const connection = yield amqp_connection_manager_1.connect([`amqp://${username}:${password}@${host}`]);
                 this.connection = connection;
                 this.connection.on('disconnect', ({ err }) => {
                     var _a;
@@ -136,8 +163,8 @@ class RabbitMq {
                 if (this.channel) {
                     return resolve(this.channel);
                 }
-                const connection = yield this.getConnection();
                 try {
+                    const connection = yield this.getConnection();
                     if (this.channel === null) {
                         this.channel = connection.createChannel({});
                     }
@@ -194,10 +221,21 @@ class RabbitMq {
                 yield c.assertQueue(queue);
                 yield c.prefetch(limit, true);
                 return Promise.all([
-                    c.consume(queue, (msg) => {
-                        outbreak_1.newTrace(outbreak_1.traceTypes.RABBIT);
-                        callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
-                    }),
+                    c.consume(queue, (msg) => __awaiter(this, void 0, void 0, function* () {
+                        const parsedMessage = RabbitMq.parseMsg(msg);
+                        // newTrace(traceTypes.RABBIT);
+                        const shouldConsume = yield this.shouldConsumeMessageByTimestamp(parsedMessage);
+                        logger_1.default.info('rabbit: trying to consume', { queue, shouldConsume, msg });
+                        if (!shouldConsume) {
+                            return this.ack(channel)(msg);
+                        }
+                        try {
+                            yield callback(parsedMessage, this.ack(channel, true), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
+                        }
+                        catch (e) {
+                            yield this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl });
+                        }
+                    })),
                 ]);
             }));
         });
@@ -216,31 +254,49 @@ class RabbitMq {
                 yield c.prefetch(limit, true);
                 return Promise.all([
                     c.bindQueue(queue, exchange, ''),
-                    c.consume(queue, (msg) => {
-                        outbreak_1.newTrace(outbreak_1.traceTypes.RABBIT);
-                        callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
-                    }),
+                    c.consume(queue, (msg) => __awaiter(this, void 0, void 0, function* () {
+                        const parsedMessage = RabbitMq.parseMsg(msg);
+                        // newTrace(traceTypes.RABBIT);
+                        const shouldConsume = yield this.shouldConsumeMessageByTimestamp(parsedMessage);
+                        logger_1.default.info('rabbit: trying to consume', { queue, shouldConsume, msg });
+                        if (!shouldConsume) {
+                            return this.ack(channel)(msg);
+                        }
+                        callback(parsedMessage, this.ack(channel, true), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
+                    })),
                 ]);
             }));
         });
     }
-    publish(exchange, content) {
+    publish(exchange, content, customHeaders) {
         return __awaiter(this, void 0, void 0, function* () {
             RabbitMq.validateName('exchange', exchange);
             const channel = yield this.assertChannel();
             yield this.assertExchange(exchange);
-            return new bluebird.Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
-                yield channel.publish(exchange, '', Buffer.from(JSON.stringify(content)));
-                return resolve();
+            return new bluebird.Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield channel.publish(exchange, '', Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
+                    return resolve();
+                }
+                catch (e) {
+                    reject(e);
+                }
             })).timeout(this.PUBLISH_TIMEOUT, `${this.PUBLISH_ERROR_MSG}${exchange}`);
         });
     }
-    sendToQueue(queue, content, options) {
+    sendToQueue(queue, content, options, customHeaders) {
         return __awaiter(this, void 0, void 0, function* () {
             RabbitMq.validateName('queue', queue);
             const channel = yield this.assertChannel();
             yield this.assertQueue(queue, options);
-            return channel.sendToQueue(queue, Buffer.from(JSON.stringify(content)));
+            logger_1.default.info('rabbit: sending to queue', { queue, content, customHeaders });
+            return channel.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
+        });
+    }
+    isConnected() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connection = yield this.getConnection();
+            return connection.isConnected();
         });
     }
 }

package/dist/logger.d.ts

@@ -0,0 +1,2 @@
+declare const logger: any;
+export default logger;

package/dist/logger.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Logger = require('@autofleet/logger');
+const logger = Logger();
+exports.default = logger;

package/dist/mock.d.ts

@@ -1,13 +1,14 @@
 import 'jest';
-declare class RabbitMq {
-    ack: jest.Mock<unknown>;
-    nack: jest.Mock<unknown>;
-    assertChannel: jest.Mock<unknown>;
-    assertExchange: jest.Mock<unknown>;
-    assertQueue: jest.Mock<unknown>;
-    consume: jest.Mock<unknown>;
-    consumeFromExchange: jest.Mock<unknown>;
-    publish: jest.Mock<unknown>;
-    sendToQueue: jest.Mock<unknown>;
+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,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line import/no-extraneous-dependencies
 require("jest");
 class RabbitMq {
     constructor() {

package/dist/redis.d.ts

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

package/dist/redis.js

@@ -0,0 +1,11 @@
+"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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "2.1.8-beta1",
+  "version": "2.1.8-beta10",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/index.ts

@@ -5,7 +5,7 @@ import moment from 'moment';
 import { ConfirmChannel, Options } from 'amqplib';
 import { AmqpConnectionManager, ChannelWrapper, connect } from 'amqp-connection-manager';
 import { EventEmitter } from 'events';
-import { newTrace, traceTypes } from '@autofleet/outbreak';
+// import { newTrace, traceTypes } from '@autofleet/outbreak';
 import logger from './logger';
 import RabbitError from './rabbitError';
 import getRedisInstance, { RedisConfig } from './redis';
@@ -253,13 +253,21 @@ class RabbitMq implements IAfRabbitMq {
           queue,
           async (msg: any) => {
             const parsedMessage = RabbitMq.parseMsg(msg);
-            newTrace(traceTypes.RABBIT);
+            // newTrace(traceTypes.RABBIT);
             const shouldConsume = await this.shouldConsumeMessageByTimestamp(parsedMessage);
             logger.info('rabbit: trying to consume', { queue, shouldConsume, msg });
             if (!shouldConsume) {
               return this.ack(channel)(msg);
             }
-            callback(parsedMessage, this.ack(channel, true), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
+            try {
+              await callback(
+                parsedMessage,
+                this.ack(channel, true),
+                this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }),
+              );
+            } catch (e) {
+              await this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl });
+            }
           },
         ),
       ]);
@@ -284,7 +292,7 @@ class RabbitMq implements IAfRabbitMq {
           queue,
           async (msg: any) => {
             const parsedMessage = RabbitMq.parseMsg(msg);
-            newTrace(traceTypes.RABBIT);
+            // newTrace(traceTypes.RABBIT);
             const shouldConsume = await this.shouldConsumeMessageByTimestamp(parsedMessage);
             logger.info('rabbit: trying to consume', { queue, shouldConsume, msg });
             if (!shouldConsume) {