@autofleet/rabbit 2.1.8-beta10 → 2.1.8-beta3

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,22 +21,19 @@ 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>;
     assertExchange(exchangeName: string, options?: any): Promise<any>;
-    getQueueLength(queue: string): Promise<import("amqplib").Replies.AssertQueue>;
-    bindQueue(queue: string, exchange: string): Promise<void>;
+    getQueueLength(queue: string): Promise<any>;
+    bindQueue(queue: string, exchange: string): Promise<any>;
     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<boolean>;
-    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,49 +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");
-// import { newTrace, traceTypes } from '@autofleet/outbreak';
-const logger_1 = __importDefault(require("./logger"));
+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);
-                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.ack = (msg) => __awaiter(this, void 0, void 0, function* () {
+            if (this.channel) {
+                yield this.channel.ack(msg);
             }
         });
-        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)) {
@@ -88,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();
@@ -97,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;
@@ -113,27 +94,19 @@ 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.once(connectionCreatedConst, resolve);
+                    this.em.on(connectionCreatedConst, resolve);
                     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;
@@ -163,8 +136,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({});
                     }
@@ -221,21 +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);
-                        // 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 });
-                        }
-                    })),
+                    c.consume(queue, (msg) => {
+                        outbreak_1.newTrace(outbreak_1.traceTypes.RABBIT);
+                        callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
+                    }),
                 ]);
             }));
         });
@@ -254,49 +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);
-                        // 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 }));
-                    })),
+                    c.consume(queue, (msg) => {
+                        outbreak_1.newTrace(outbreak_1.traceTypes.RABBIT);
+                        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);
-            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();
+            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.8-beta10",
+  "version": "2.1.8-beta3",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/index.ts

@@ -259,15 +259,7 @@ class RabbitMq implements IAfRabbitMq {
             if (!shouldConsume) {
               return this.ack(channel)(msg);
             }
-            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 });
-            }
+            callback(parsedMessage, this.ack(channel, true), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
           },
         ),
       ]);

package/dist/logger.d.ts

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

package/dist/logger.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const Logger = require('@autofleet/logger');
-const logger = Logger();
-exports.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;