@autofleet/rabbit 2.0.4-beta3 → 2.0.4-beta5

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="node" />
+import { Options } from 'amqplib';
+import { AmqpConnectionManager, ChannelWrapper } from 'amqp-connection-manager';
+import { EventEmitter } from 'events';
+export interface IAfRabbitMq {
+    ack: any;
+    nack: any;
+    assertChannel: any;
+    assertExchange: any;
+    assertQueue: any;
+    consume: any;
+    consumeFromExchange: any;
+    publish: any;
+    sendToQueue: any;
+}
+interface ExchangesCache {
+    [key: string]: any;
+}
+export interface AfRabbitOptions {
+    reconnect: boolean;
+}
+declare class RabbitMq implements IAfRabbitMq {
+    static parseMsg(msg: any): any;
+    static validateName(type: string, name: string): void;
+    PUBLISH_TIMEOUT: number;
+    PUBLISH_ERROR_MSG: string;
+    DISCONNECT_MSG: string;
+    RESCONNECT_MSG: string;
+    channel: ChannelWrapper | null;
+    connection: AmqpConnectionManager | null;
+    em: EventEmitter;
+    creatingConnection: boolean;
+    exchanges: ExchangesCache;
+    options: AfRabbitOptions | undefined;
+    logger: any;
+    constructor({ options, logger }?: {
+        options?: AfRabbitOptions;
+        logger?: any;
+    });
+    ack: (channel: ChannelWrapper) => (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>;
+    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>;
+}
+export default RabbitMq;

package/dist/index.js

@@ -0,0 +1,282 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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 bluebird = __importStar(require("bluebird"));
+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 DEFAULT_DEAD_TTL_TWO_DAYS = 60000 * 60 * 48;
+const defaultOptions = {
+    limit: 1,
+    retries: 1,
+    deadMessageTtl: DEFAULT_DEAD_TTL_TWO_DAYS,
+};
+const assertExchangeFanout = (c, exchangeName) => c.assertExchange(exchangeName, 'fanout');
+const callbackWithTimeout = (callback, args, timeout, timeoutMessage = 'Timeout while ack message') => __awaiter(void 0, void 0, void 0, function* () {
+    yield new bluebird.Promise((resolve, reject) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            yield callback(...args);
+            return resolve();
+        }
+        catch (e) {
+            return reject(e);
+        }
+    })).timeout(timeout, timeoutMessage);
+});
+const connectionCreatedConst = 'connectionCreated';
+class RabbitMq {
+    constructor({ options, logger } = {}) {
+        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* () {
+            yield channel.ack(msg);
+        });
+        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)) {
+                    msg.content['x-retry-count'] = msg.content['x-retry-count'] ? msg.content['x-retry-count'] + 1 : 1;
+                    yield this.sendToQueue(queue, msg.content);
+                }
+                else {
+                    const deadQueue = `${queue}-dead`;
+                    yield this.assertQueue(deadQueue, deadQueueOptions);
+                    yield this.sendToQueue(deadQueue, msg.content, deadQueueOptions);
+                }
+                yield channel.ack(msg);
+            }
+        });
+        this.em = new events_1.EventEmitter();
+        this.channel = null;
+        this.connection = null;
+        this.creatingConnection = false;
+        this.exchanges = {};
+        this.options = options;
+        this.logger = logger;
+    }
+    static parseMsg(msg) {
+        let { content } = msg;
+        content = content.toString();
+        try {
+            content = JSON.parse(content);
+        }
+        catch (e) { }
+        return Object.assign(Object.assign({}, msg), { content });
+    }
+    static validateName(type, name) {
+        if (!name || name === '') {
+            throw new rabbitError_1.default(`error while using ${type} with no name`);
+        }
+    }
+    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);
+                    return;
+                }
+                if (this.connection !== null) {
+                    return resolve(this.connection);
+                }
+                this.creatingConnection = true;
+                const host = process.env.RABBITMQ_SERVICE_HOST || '';
+                const connection = yield amqp_connection_manager_1.connect([`amqp://${host}`]);
+                this.connection = connection;
+                this.connection.on('disconnect', ({ err }) => {
+                    var _a;
+                    if ((_a = this.options) === null || _a === void 0 ? void 0 : _a.reconnect) {
+                        console.error(`${this.RESCONNECT_MSG}${err && ` - ${err}`}`);
+                        this.connection = null;
+                    }
+                    else {
+                        console.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
+                    }
+                });
+                this.creatingConnection = false;
+                this.em.emit(connectionCreatedConst, connection);
+                resolve(connection);
+            }));
+        });
+    }
+    getNewChannel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connection = yield this.getConnection();
+            return connection.createChannel({});
+        });
+    }
+    assertChannel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                if (this.channel) {
+                    return resolve(this.channel);
+                }
+                const connection = yield this.getConnection();
+                try {
+                    if (this.channel === null) {
+                        this.channel = connection.createChannel({});
+                    }
+                    resolve(this.channel);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            }));
+        });
+    }
+    assertExchange(exchangeName, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const channel = yield this.assertChannel();
+            if (this.exchanges[exchangeName]) {
+                return this.exchanges[exchangeName];
+            }
+            return channel.addSetup((c) => __awaiter(this, void 0, void 0, function* () {
+                const exchange = yield assertExchangeFanout(c, exchangeName);
+                this.exchanges[exchangeName] = exchange;
+                return exchange;
+            }));
+        });
+    }
+    getQueueLength(queue) {
+        return __awaiter(this, void 0, void 0, function* () {
+            RabbitMq.validateName('queue', queue);
+            const channel = yield this.assertChannel();
+            // @ts-ignore
+            return channel.checkQueue(queue);
+        });
+    }
+    bindQueue(queue, exchange) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const channel = yield this.assertChannel();
+            // @ts-ignore
+            return channel.bindQueue(queue, exchange, '');
+        });
+    }
+    assertQueue(queue, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            RabbitMq.validateName('queue', queue);
+            const channel = yield this.assertChannel();
+            return channel.addSetup((c) => c.assertQueue(queue, options));
+        });
+    }
+    consume(queue, callback, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const optionsWithDefaults = Object.assign(Object.assign({}, defaultOptions), options);
+            RabbitMq.validateName('queue', queue);
+            const { limit, deadMessageTtl } = optionsWithDefaults;
+            const channel = yield this.getNewChannel();
+            return channel.addSetup((c) => __awaiter(this, void 0, void 0, function* () {
+                yield c.assertQueue(queue);
+                yield c.prefetch(limit, true);
+                return Promise.all([
+                    c.consume(queue, (msg) => __awaiter(this, void 0, void 0, function* () {
+                        var _a;
+                        outbreak_1.newTrace(outbreak_1.traceTypes.RABBIT);
+                        if (optionsWithDefaults.timeout) {
+                            const args = [
+                                RabbitMq.parseMsg(msg),
+                                this.ack(channel),
+                                this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }),
+                            ];
+                            try {
+                                yield callbackWithTimeout(callback, args, optionsWithDefaults.timeout, optionsWithDefaults.timeoutMessage);
+                            }
+                            catch (e) {
+                                (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error('message nacked because of error in callbackWithTimeout', {
+                                    error: e,
+                                    msg,
+                                });
+                                this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl });
+                            }
+                        }
+                        else {
+                            callback(RabbitMq.parseMsg(msg), this.ack(channel), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
+                        }
+                    })),
+                ]);
+            }));
+        });
+    }
+    consumeFromExchange(queue, exchange, callback, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const optionsWithDefaults = Object.assign(Object.assign({}, defaultOptions), options);
+            RabbitMq.validateName('exchange', exchange);
+            RabbitMq.validateName('queue', queue);
+            const { limit, deadMessageTtl } = optionsWithDefaults;
+            const channel = yield this.getNewChannel();
+            return channel.addSetup((c) => __awaiter(this, void 0, void 0, function* () {
+                const assertExchange = yield assertExchangeFanout(c, exchange);
+                yield c.assertQueue(queue);
+                this.exchanges[exchange] = assertExchange;
+                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(channel), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
+                    }),
+                ]);
+            }));
+        });
+    }
+    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)));
+                    return resolve();
+                }
+                catch (e) {
+                    reject(e);
+                }
+            })).timeout(this.PUBLISH_TIMEOUT, `${this.PUBLISH_ERROR_MSG}${exchange}`);
+        });
+    }
+    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)));
+        });
+    }
+}
+exports.default = RabbitMq;

package/dist/mock.d.ts

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

package/dist/mock.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line import/no-extraneous-dependencies
+require("jest");
+class RabbitMq {
+    constructor() {
+        this.ack = jest.fn();
+        this.nack = jest.fn();
+        this.assertChannel = jest.fn();
+        this.assertExchange = jest.fn();
+        this.assertQueue = jest.fn();
+        this.consume = jest.fn();
+        this.consumeFromExchange = jest.fn();
+        this.publish = jest.fn();
+        this.sendToQueue = jest.fn();
+    }
+}
+exports.default = RabbitMq;

package/dist/rabbitError.d.ts

@@ -0,0 +1,3 @@
+export default class RabbitError extends Error {
+    constructor(message: string);
+}

package/dist/rabbitError.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class RabbitError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'RabbitError';
+    }
+}
+exports.default = RabbitError;

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "2.0.4-beta3",
+  "version": "2.0.4-beta5",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
     "postinstall": "echo '\\033[0;31m\nWARNING: in case of migrating to new version of @autofleet/rabbit \nyou might have to delete existing queues or the deployment will fail.\\033[0m\n'",
     "start": "ts-node  src/index.ts",
     "example": "ts-node  src/example.ts",
-    "build": "tsc",
+    "build": "rm -rf dist && tsc",
+    "prepublish": "npm run build",
     "linter": "./node_modules/.bin/eslint .",
     "test": "jest --forceExit",
     "test-local": "RABBITMQ_SERVICE_HOST=10.132.0.98:5672 jest --forceExit",

package/src/index.ts

@@ -38,17 +38,14 @@ const defaultOptions = {
 const assertExchangeFanout = (c: any, exchangeName: string) => c.assertExchange(exchangeName, 'fanout');
 
 const callbackWithTimeout = async (callback: any, args: any[], timeout: number, timeoutMessage = 'Timeout while ack message') => {
-  const callbackPromise = new bluebird.Promise(callback(...args));
-  Promise.race([
-    callbackPromise,
-    new Promise((resolve, reject) => {
-      setTimeout(() => {
-        callbackPromise.cancel();
-        console.log('callbackPromise', callbackPromise.isCancelled());
-        reject(timeoutMessage);
-      }, timeout);
-    }),
-  ]);
+  await new bluebird.Promise(async (resolve, reject) => {
+    try {
+      await callback(...args);
+      return resolve();
+    } catch (e) {
+      return reject(e);
+    }
+  }).timeout(timeout, timeoutMessage);
 };
 
 const connectionCreatedConst = 'connectionCreated';
@@ -93,13 +90,16 @@ class RabbitMq implements IAfRabbitMq {
 
   options: AfRabbitOptions | undefined;
 
-  constructor(options?: AfRabbitOptions) {
+  logger: any;
+
+  constructor({ options, logger }: { options?: AfRabbitOptions, logger?: any} = {}) {
     this.em = new EventEmitter();
     this.channel = null;
     this.connection = null;
     this.creatingConnection = false;
     this.exchanges = {};
     this.options = options;
+    this.logger = logger;
   }
 
   public ack = (channel: ChannelWrapper) => async (msg: any) => {
@@ -124,7 +124,6 @@ class RabbitMq implements IAfRabbitMq {
         || msg.content['x-retry-count'] < options.retries)
       ) {
         msg.content['x-retry-count'] = msg.content['x-retry-count'] ? msg.content['x-retry-count'] + 1 : 1;
-        // msg.content.nackCount = msg.content.nackCount ? msg.content.nackCount + 1 : 1;
         await this.sendToQueue(queue, msg.content);
       } else {
         const deadQueue = `${queue}-dead`;
@@ -240,6 +239,10 @@ class RabbitMq implements IAfRabbitMq {
               try {
                 await callbackWithTimeout(callback, args, optionsWithDefaults.timeout, optionsWithDefaults.timeoutMessage);
               } catch (e) {
+                this.logger?.error('message nacked because of error in callbackWithTimeout', {
+                  error: e,
+                  msg,
+                });
                 this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl });
               }
             } else {