@autofleet/rabbit 2.0.4-beta2 → 2.0.4-beta3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "2.0.4-beta2",
+  "version": "2.0.4-beta3",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/index.ts

@@ -44,6 +44,7 @@ const callbackWithTimeout = async (callback: any, args: any[], timeout: number,
     new Promise((resolve, reject) => {
       setTimeout(() => {
         callbackPromise.cancel();
+        console.log('callbackPromise', callbackPromise.isCancelled());
         reject(timeoutMessage);
       }, timeout);
     }),

package/dist/index.d.ts

@@ -1,50 +0,0 @@
-/// <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;
-    constructor(options?: AfRabbitOptions);
-    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

@@ -1,278 +0,0 @@
-"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* () {
-    const callbackPromise = new bluebird.Promise(callback(...args));
-    Promise.race([
-        callbackPromise,
-        new Promise((resolve, reject) => {
-            setTimeout(() => {
-                callbackPromise.cancel();
-                reject(timeoutMessage);
-            }, timeout);
-        }),
-    ]);
-});
-const connectionCreatedConst = 'connectionCreated';
-class RabbitMq {
-    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.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;
-                    // msg.content.nackCount = msg.content.nackCount ? msg.content.nackCount + 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;
-    }
-    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* () {
-                        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) {
-                                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

@@ -1,14 +0,0 @@
-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

@@ -1,18 +0,0 @@
-"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

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

package/dist/rabbitError.js

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