@autofleet/rabbit 2.1.0 → 2.1.2

package/dist/index.d.ts

@@ -2,6 +2,7 @@
 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;
@@ -12,18 +13,23 @@ export interface IAfRabbitMq {
     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 implements IAfRabbitMq {
     static parseMsg(msg: any): any;
     static validateName(type: string, name: string): void;
-    static getPublishOptions(): {
+    static getPublishOptions(customHeaders?: CustomMessageHeaders): {
         timestamp: number;
+        headers: CustomMessageHeaders;
     };
     PUBLISH_TIMEOUT: number;
     PUBLISH_ERROR_MSG: string;
@@ -35,8 +41,10 @@ declare class RabbitMq implements IAfRabbitMq {
     creatingConnection: boolean;
     exchanges: ExchangesCache;
     options: AfRabbitOptions | undefined;
-    constructor(options?: AfRabbitOptions);
-    ack: (channel: ChannelWrapper) => (msg: 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>;
@@ -47,7 +55,7 @@ declare class RabbitMq implements IAfRabbitMq {
     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<void>;
 }
 export default RabbitMq;

package/dist/index.js

@@ -39,22 +39,37 @@ const amqp_connection_manager_1 = require("amqp-connection-manager");
 const events_1 = require("events");
 const outbreak_1 = require("@autofleet/outbreak");
 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 = (channel) => (msg) => __awaiter(this, void 0, void 0, function* () {
+        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);
+                return !lastMessageTimestamp || !moment_1.default(parseInt(lastMessageTimestamp, 10) * SECONDS_TO_MILLISECONDS).isAfter(moment_1.default(timestamp * SECONDS_TO_MILLISECONDS));
+            }
+            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);
+            }
         });
         this.nack = (channel, queue, options, deadQueueOptions) => (msg, { skipRetry = false, } = {}) => __awaiter(this, void 0, void 0, function* () {
             if (channel) {
@@ -78,6 +93,7 @@ class RabbitMq {
         this.creatingConnection = false;
         this.exchanges = {};
         this.options = options;
+        this.redisClient = redisConfig && redis_1.default(redisConfig);
     }
     static parseMsg(msg) {
         let { content } = msg;
@@ -93,9 +109,10 @@ class RabbitMq {
             throw new rabbitError_1.default(`error while using ${type} with no name`);
         }
     }
-    static getPublishOptions() {
+    static getPublishOptions(customHeaders = {}) {
         return {
-            timestamp: moment_1.default().unix() * 1000,
+            timestamp: moment_1.default().unix(),
+            headers: customHeaders,
         };
     }
     getConnection() {
@@ -200,10 +217,16 @@ class RabbitMq {
                 yield c.assertQueue(queue);
                 yield c.prefetch(limit, true);
                 return Promise.all([
-                    c.consume(queue, (msg) => {
+                    c.consume(queue, (msg) => __awaiter(this, void 0, void 0, function* () {
+                        const parsedMessage = RabbitMq.parseMsg(msg);
                         outbreak_1.newTrace(outbreak_1.traceTypes.RABBIT);
-                        callback(RabbitMq.parseMsg(msg), this.ack(channel), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
-                    }),
+                        const shouldConsume = yield this.shouldConsumeMessageByTimestamp(parsedMessage);
+                        if (!shouldConsume) {
+                            this.ack(channel);
+                            return;
+                        }
+                        callback(parsedMessage, this.ack(channel, true), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
+                    })),
                 ]);
             }));
         });
@@ -222,22 +245,28 @@ class RabbitMq {
                 yield c.prefetch(limit, true);
                 return Promise.all([
                     c.bindQueue(queue, exchange, ''),
-                    c.consume(queue, (msg) => {
+                    c.consume(queue, (msg) => __awaiter(this, void 0, void 0, function* () {
+                        const parsedMessage = RabbitMq.parseMsg(msg);
                         outbreak_1.newTrace(outbreak_1.traceTypes.RABBIT);
-                        callback(RabbitMq.parseMsg(msg), this.ack(channel), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
-                    }),
+                        const shouldConsume = yield this.shouldConsumeMessageByTimestamp(parsedMessage);
+                        if (!shouldConsume) {
+                            this.ack(channel);
+                            return;
+                        }
+                        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, reject) => __awaiter(this, void 0, void 0, function* () {
                 try {
-                    yield channel.publish(exchange, '', Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions());
+                    yield channel.publish(exchange, '', Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
                     return resolve();
                 }
                 catch (e) {
@@ -246,12 +275,12 @@ class RabbitMq {
             })).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)), RabbitMq.getPublishOptions());
+            return channel.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
         });
     }
 }

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 redis_1 = __importDefault(require("redis"));
+const bluebird_1 = __importDefault(require("bluebird"));
+bluebird_1.default.promisifyAll(redis_1.default.RedisClient.prototype);
+bluebird_1.default.promisifyAll(redis_1.default.Multi.prototype);
+const getRedisInstance = (config) => redis_1.default.createClient(config);
+exports.default = getRedisInstance;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -17,10 +17,14 @@
   "dependencies": {
     "@types/amqp-connection-manager": "^2.0.10",
     "@types/amqplib": "^0.5.16",
+    "@types/redis": "^2.8.32",
+    "@types/uuid": "^8.3.3",
     "amqp-connection-manager": "^3.2.1",
     "amqplib": "^0.6.0",
     "bluebird": "^3.7.2",
-    "moment": "^2.29.1"
+    "moment": "^2.29.1",
+    "redis": "^3.1.2",
+    "uuid": "^8.3.2"
   },
   "devDependencies": {
     "@autofleet/outbreak": "*",

package/src/index.ts

@@ -6,7 +6,9 @@ import { ConfirmChannel, Options } from 'amqplib';
 import { AmqpConnectionManager, ChannelWrapper, connect } from 'amqp-connection-manager';
 import { EventEmitter } from 'events';
 import { newTrace, traceTypes } from '@autofleet/outbreak';
+import { RedisClient } from 'redis';
 import RabbitError from './rabbitError';
+import getRedisInstance, { RedisConfig } from './redis';
 
 export interface IAfRabbitMq {
   ack: any;
@@ -18,14 +20,19 @@ export interface IAfRabbitMq {
   consumeFromExchange: any;
   publish: any;
   sendToQueue: any;
+  redisClient?: any;
 }
 
 interface ExchangesCache {
   [key: string]: any
 }
 
+type CustomMessageHeaders = {
+  redisTimestampValidationKey?: string;
+}
+
 export interface AfRabbitOptions {
-  reconnect: boolean
+  reconnect: boolean;
 }
 
 const DEFAULT_DEAD_TTL_TWO_DAYS = 60000 * 60 * 48;
@@ -35,6 +42,7 @@ const defaultOptions = {
   retries: 1,
   deadMessageTtl: DEFAULT_DEAD_TTL_TWO_DAYS,
 };
+const SECONDS_TO_MILLISECONDS = 1000;
 
 const assertExchangeFanout = (c: any, exchangeName: string) => c.assertExchange(exchangeName, 'fanout');
 
@@ -60,9 +68,10 @@ class RabbitMq implements IAfRabbitMq {
     }
   }
 
-  static getPublishOptions() {
+  static getPublishOptions(customHeaders: CustomMessageHeaders = {}) {
     return {
-      timestamp: moment().unix() * 1000,
+      timestamp: moment().unix(),
+      headers: customHeaders,
     };
   }
 
@@ -86,17 +95,34 @@ class RabbitMq implements IAfRabbitMq {
 
   options: AfRabbitOptions | undefined;
 
-  constructor(options?: AfRabbitOptions) {
+  redisClient: any;
+
+  constructor(options?: AfRabbitOptions, redisConfig?: RedisConfig) {
     this.em = new EventEmitter();
     this.channel = null;
     this.connection = null;
     this.creatingConnection = false;
     this.exchanges = {};
     this.options = options;
+    this.redisClient = redisConfig && getRedisInstance(redisConfig);
   }
 
-  public ack = (channel: ChannelWrapper) => async (msg: any) => {
+  private shouldConsumeMessageByTimestamp = async (msg: any) => {
+    const { properties: { timestamp, headers } } = msg;
+    if (timestamp && headers?.redisTimestampValidationKey && this.redisClient) {
+      const lastMessageTimestamp = await this.redisClient.getAsync(headers.redisTimestampValidationKey);
+      return !lastMessageTimestamp || !moment(parseInt(lastMessageTimestamp, 10) * SECONDS_TO_MILLISECONDS).isAfter(moment(timestamp * SECONDS_TO_MILLISECONDS));
+    }
+    return true;
+  }
+
+  public ack = (channel: ChannelWrapper, shouldUpdateRedisTimestamp = false) => async (msg: any) => {
     await channel.ack(msg);
+    const { properties: { timestamp, headers } } = msg;
+    if (shouldUpdateRedisTimestamp && timestamp && headers?.redisTimestampValidationKey && this.redisClient) {
+      const parsedTimestamp = parseInt(timestamp, 10);
+      await this.redisClient.setAsync(headers.redisTimestampValidationKey, parsedTimestamp);
+    }
   }
 
   public nack = (
@@ -223,9 +249,15 @@ class RabbitMq implements IAfRabbitMq {
       return Promise.all([
         c.consume(
           queue,
-          (msg: any) => {
+          async (msg: any) => {
+            const parsedMessage = RabbitMq.parseMsg(msg);
             newTrace(traceTypes.RABBIT);
-            callback(RabbitMq.parseMsg(msg), this.ack(channel), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
+            const shouldConsume = await this.shouldConsumeMessageByTimestamp(parsedMessage);
+            if (!shouldConsume) {
+              this.ack(channel);
+              return;
+            }
+            callback(parsedMessage, this.ack(channel, true), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
           },
         ),
       ]);
@@ -248,22 +280,30 @@ class RabbitMq implements IAfRabbitMq {
         c.bindQueue(queue, exchange, ''),
         c.consume(
           queue,
-          (msg: any) => {
+          async (msg: any) => {
+            const parsedMessage = RabbitMq.parseMsg(msg);
             newTrace(traceTypes.RABBIT);
-            callback(RabbitMq.parseMsg(msg), this.ack(channel), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
+            const shouldConsume = await this.shouldConsumeMessageByTimestamp(parsedMessage);
+            if (!shouldConsume) {
+              this.ack(channel);
+              return;
+            }
+            callback(parsedMessage, this.ack(channel, true), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
           },
         ),
       ]);
     });
   }
 
-  async publish(exchange: string, content: any) {
+  async publish(exchange: string, content: any, customHeaders?: any) {
     RabbitMq.validateName('exchange', exchange);
     const channel: ChannelWrapper = await this.assertChannel();
     await this.assertExchange(exchange);
     return new bluebird.Promise(async (resolve, reject) => {
       try {
-        await channel.publish(exchange, '', Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions());
+        await channel.publish(exchange, '',
+          Buffer.from(JSON.stringify(content)),
+          RabbitMq.getPublishOptions(customHeaders));
         return resolve();
       } catch (e) {
         reject(e);
@@ -271,11 +311,13 @@ class RabbitMq implements IAfRabbitMq {
     }).timeout(this.PUBLISH_TIMEOUT, `${this.PUBLISH_ERROR_MSG}${exchange}`);
   }
 
-  async sendToQueue(queue: string, content: any, options?: any) {
+  async sendToQueue(queue: string, content: any, options?: any, customHeaders?: any) {
     RabbitMq.validateName('queue', queue);
     const channel: ChannelWrapper = await this.assertChannel();
     await this.assertQueue(queue, options);
-    return channel.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions());
+    return channel.sendToQueue(queue,
+      Buffer.from(JSON.stringify(content)),
+      RabbitMq.getPublishOptions(customHeaders));
   }
 }
 

package/src/redis.ts

@@ -0,0 +1,15 @@
+import redis from 'redis';
+import bluebird from 'bluebird';
+
+bluebird.promisifyAll(redis.RedisClient.prototype);
+bluebird.promisifyAll(redis.Multi.prototype);
+
+export type RedisConfig = {
+  host: string;
+  port: number | undefined;
+  prefix?: string;
+}
+
+const getRedisInstance = (config: RedisConfig): any => redis.createClient(config);
+
+export default getRedisInstance;