@autofleet/rabbit 2.1.6 → 2.1.8-beta1

package/dist/index.d.ts

@@ -2,35 +2,15 @@
 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 implements IAfRabbitMq {
+declare class RabbitMq {
     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;
@@ -41,11 +21,9 @@ declare class RabbitMq implements IAfRabbitMq {
     creatingConnection: boolean;
     exchanges: ExchangesCache;
     options: AfRabbitOptions | undefined;
-    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>;
+    constructor(options?: AfRabbitOptions);
+    ack: (msg: any) => Promise<void>;
+    nack: (queue: string, options: any, deadQueueOptions: Options.AssertQueue) => (msg: any, { skipRetry, }?: any) => Promise<void>;
     getConnection(): Promise<AmqpConnectionManager>;
     getNewChannel(): Promise<ChannelWrapper>;
     assertChannel(): Promise<ChannelWrapper>;
@@ -55,8 +33,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, customHeaders?: any): Promise<unknown>;
-    sendToQueue(queue: string, content: any, options?: any, customHeaders?: any): Promise<void>;
-    isConnected(): Promise<boolean>;
+    publish(exchange: string, content: any): Promise<unknown>;
+    sendToQueue(queue: string, content: any, options?: any): Promise<void>;
 }
 export default RabbitMq;

package/dist/index.js

@@ -34,45 +34,31 @@ 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");
 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, redisConfig) {
+    constructor(options) {
         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.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).isBefore(moment_1.default(timestamp * SECONDS_TO_MILLISECONDS));
+        this.ack = (msg) => __awaiter(this, void 0, void 0, function* () {
+            if (this.channel) {
+                yield this.channel.ack(msg);
             }
-            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 = (channel, queue, options, deadQueueOptions) => (msg, { skipRetry = false, } = {}) => __awaiter(this, void 0, void 0, function* () {
-            if (channel) {
+        this.nack = (queue, options, deadQueueOptions) => (msg, { skipRetry = false, } = {}) => __awaiter(this, void 0, void 0, function* () {
+            if (this.channel) {
                 if (!skipRetry
                     && (!msg.content['x-retry-count']
                         || msg.content['x-retry-count'] < options.retries)) {
@@ -84,7 +70,7 @@ class RabbitMq {
                     yield this.assertQueue(deadQueue, deadQueueOptions);
                     yield this.sendToQueue(deadQueue, msg.content, deadQueueOptions);
                 }
-                yield channel.ack(msg);
+                yield this.channel.ack(msg);
             }
         });
         this.em = new events_1.EventEmitter();
@@ -93,7 +79,6 @@ class RabbitMq {
         this.creatingConnection = false;
         this.exchanges = {};
         this.options = options;
-        this.redisClient = redisConfig && redis_1.default(redisConfig);
     }
     static parseMsg(msg) {
         let { content } = msg;
@@ -109,12 +94,6 @@ 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* () {
@@ -123,13 +102,11 @@ class RabbitMq {
                     return;
                 }
                 if (this.connection !== null) {
-                    return resolve(this.connection);
+                    return 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://${username}:${password}@${host}`]);
+                const connection = yield amqp_connection_manager_1.connect([`amqp://${host}`]);
                 this.connection = connection;
                 this.connection.on('disconnect', ({ err }) => {
                     var _a;
@@ -217,15 +194,10 @@ class RabbitMq {
                 yield c.assertQueue(queue);
                 yield c.prefetch(limit, true);
                 return Promise.all([
-                    c.consume(queue, (msg) => __awaiter(this, void 0, void 0, function* () {
-                        const parsedMessage = RabbitMq.parseMsg(msg);
+                    c.consume(queue, (msg) => {
                         outbreak_1.newTrace(outbreak_1.traceTypes.RABBIT);
-                        const shouldConsume = yield this.shouldConsumeMessageByTimestamp(parsedMessage);
-                        if (!shouldConsume) {
-                            return this.ack(channel)(msg);
-                        }
-                        callback(parsedMessage, this.ack(channel, true), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
-                    })),
+                        callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
+                    }),
                 ]);
             }));
         });
@@ -244,47 +216,31 @@ class RabbitMq {
                 yield c.prefetch(limit, true);
                 return Promise.all([
                     c.bindQueue(queue, exchange, ''),
-                    c.consume(queue, (msg) => __awaiter(this, void 0, void 0, function* () {
-                        const parsedMessage = RabbitMq.parseMsg(msg);
+                    c.consume(queue, (msg) => {
                         outbreak_1.newTrace(outbreak_1.traceTypes.RABBIT);
-                        const shouldConsume = yield this.shouldConsumeMessageByTimestamp(parsedMessage);
-                        if (!shouldConsume) {
-                            return this.ack(channel)(msg);
-                        }
-                        callback(parsedMessage, this.ack(channel, true), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
-                    })),
+                        callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
+                    }),
                 ]);
             }));
         });
     }
-    publish(exchange, content, customHeaders) {
+    publish(exchange, content) {
         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(customHeaders));
-                    return resolve();
-                }
-                catch (e) {
-                    reject(e);
-                }
+            return new bluebird.Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                yield channel.publish(exchange, '', Buffer.from(JSON.stringify(content)));
+                return resolve();
             })).timeout(this.PUBLISH_TIMEOUT, `${this.PUBLISH_ERROR_MSG}${exchange}`);
         });
     }
-    sendToQueue(queue, content, options, customHeaders) {
+    sendToQueue(queue, content, options) {
         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(customHeaders));
-        });
-    }
-    isConnected() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const connection = yield this.getConnection();
-            return connection.isConnected();
+            return channel.sendToQueue(queue, Buffer.from(JSON.stringify(content)));
         });
     }
 }

package/dist/mock.d.ts

@@ -1,14 +1,13 @@
 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;
+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>;
 }
 export default RabbitMq;

package/dist/mock.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-// eslint-disable-next-line import/no-extraneous-dependencies
 require("jest");
 class RabbitMq {
     constructor() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "2.1.6",
+  "version": "2.1.8-beta1",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -15,6 +15,7 @@
     "dev": "nodemon"
   },
   "dependencies": {
+    "@autofleet/logger": "^1.2.8",
     "@types/amqp-connection-manager": "^2.0.10",
     "@types/amqplib": "^0.5.16",
     "@types/uuid": "^8.3.3",

package/src/index.ts

@@ -6,6 +6,7 @@ import { ConfirmChannel, Options } from 'amqplib';
 import { AmqpConnectionManager, ChannelWrapper, connect } from 'amqp-connection-manager';
 import { EventEmitter } from 'events';
 import { newTrace, traceTypes } from '@autofleet/outbreak';
+import logger from './logger';
 import RabbitError from './rabbitError';
 import getRedisInstance, { RedisConfig } from './redis';
 
@@ -110,7 +111,10 @@ class RabbitMq implements IAfRabbitMq {
     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).isBefore(moment(timestamp * SECONDS_TO_MILLISECONDS));
+      logger.info('rabbit: checking if should consume params', {
+        msg, timestamp, headers, lastMessageTimestamp,
+      });
+      return !lastMessageTimestamp || (parseInt(lastMessageTimestamp, 10) <= parseInt(timestamp, 10));
     }
     return true;
   }
@@ -155,7 +159,7 @@ class RabbitMq implements IAfRabbitMq {
   async getConnection() {
     return new Promise<AmqpConnectionManager>(async (resolve) => {
       if (this.creatingConnection) {
-        this.em.on(connectionCreatedConst, resolve);
+        this.em.once(connectionCreatedConst, resolve);
         return;
       }
       if (this.connection !== null) {
@@ -193,9 +197,8 @@ class RabbitMq implements IAfRabbitMq {
         return resolve(this.channel);
       }
 
-      const connection: AmqpConnectionManager = await this.getConnection();
-
       try {
+        const connection: AmqpConnectionManager = await this.getConnection();
         if (this.channel === null) {
           this.channel = connection.createChannel({});
         }
@@ -252,6 +255,7 @@ class RabbitMq implements IAfRabbitMq {
             const parsedMessage = RabbitMq.parseMsg(msg);
             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);
             }
@@ -282,6 +286,7 @@ class RabbitMq implements IAfRabbitMq {
             const parsedMessage = RabbitMq.parseMsg(msg);
             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);
             }
@@ -312,6 +317,7 @@ class RabbitMq implements IAfRabbitMq {
     RabbitMq.validateName('queue', queue);
     const channel: ChannelWrapper = await this.assertChannel();
     await this.assertQueue(queue, options);
+    logger.info('rabbit: sending to queue', { queue, content, customHeaders });
     return channel.sendToQueue(queue,
       Buffer.from(JSON.stringify(content)),
       RabbitMq.getPublishOptions(customHeaders));

package/src/logger.ts

@@ -0,0 +1,5 @@
+const Logger = require('@autofleet/logger');
+
+const logger = Logger();
+
+export default logger;

package/dist/redis.d.ts

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

package/dist/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;