@autofleet/rabbit 1.5.3 → 1.5.4

package/dist/index.d.ts

@@ -1,11 +1,10 @@
 /// <reference types="node" />
 import { AmqpConnectionManager, ChannelWrapper } from 'amqp-connection-manager';
 import { EventEmitter } from 'events';
-import RabbitWrapperInterface from './interfaces/RabbitWrapperInterface';
 interface ExchangesCache {
     [key: string]: any;
 }
-declare class RabbitMq implements RabbitWrapperInterface {
+declare class RabbitMq {
     static parseMsg(msg: any): any;
     static validateName(type: string, name: string): void;
     PUBLISH_TIMEOUT: number;
@@ -16,12 +15,7 @@ declare class RabbitMq implements RabbitWrapperInterface {
     em: EventEmitter;
     creatingConnection: boolean;
     exchanges: ExchangesCache;
-    isTestEnv: boolean;
-    constructor({ isTestEnv }?: {
-        isTestEnv?: boolean | undefined;
-    });
-    private getConnectFunc;
-    private connect;
+    constructor();
     ack: (msg: any) => Promise<void>;
     nack: (queue: string) => (msg: any, retries: number) => Promise<void>;
     getConnection(): Promise<AmqpConnectionManager>;

package/dist/index.js

@@ -14,17 +14,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const bluebird = require("bluebird");
 const amqp_connection_manager_1 = require("amqp-connection-manager");
 const events_1 = require("events");
-const mockImpl_1 = require("./mockImpl");
 const rabbitError_1 = require("./rabbitError");
 const assertExchangeFanout = (c, exchangeName) => c.assertExchange(exchangeName, 'fanout');
 const connectionCreatedConst = 'connectionCreated';
 class RabbitMq {
-    constructor({ isTestEnv = false } = {}) {
+    constructor() {
         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.getConnectFunc = () => (this.isTestEnv ? mockImpl_1.connect : amqp_connection_manager_1.connect);
-        this.connect = (urls = []) => this.getConnectFunc()(urls);
         this.ack = (msg) => __awaiter(this, void 0, void 0, function* () {
             if (this.channel) {
                 yield this.channel.ack(msg);
@@ -49,7 +46,6 @@ class RabbitMq {
         this.connection = null;
         this.creatingConnection = false;
         this.exchanges = {};
-        this.isTestEnv = isTestEnv;
     }
     static parseMsg(msg) {
         let { content } = msg;
@@ -77,7 +73,7 @@ class RabbitMq {
                 }
                 this.creatingConnection = true;
                 const host = process.env.RABBITMQ_SERVICE_HOST || '';
-                const connection = yield this.connect([`amqp://${host}`]);
+                const connection = yield amqp_connection_manager_1.connect([`amqp://${host}`]);
                 this.connection = connection;
                 this.connection.on('disconnect', ({ err }) => console.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`));
                 this.creatingConnection = false;
@@ -95,7 +91,7 @@ class RabbitMq {
                 const connection = yield this.getConnection();
                 try {
                     if (this.channel === null) {
-                        this.channel = yield connection.createChannel({});
+                        this.channel = connection.createChannel({});
                     }
                     resolve(this.channel);
                 }

package/package.json

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

package/src/index.ts

@@ -2,13 +2,8 @@
 // eslint-disable-next-line max-classes-per-file
 import * as bluebird from 'bluebird';
 import { ConfirmChannel } from 'amqplib';
-import {
-  AmqpConnectionManager, ChannelWrapper,
-  connect as connectAmqp,
-} from 'amqp-connection-manager';
+import { AmqpConnectionManager, ChannelWrapper, connect } from 'amqp-connection-manager';
 import { EventEmitter } from 'events';
-import { connect as connectMock } from './mockImpl';
-import RabbitWrapperInterface from './interfaces/RabbitWrapperInterface';
 import RabbitError from './rabbitError';
 
 interface ExchangesCache {
@@ -18,7 +13,7 @@ interface ExchangesCache {
 const assertExchangeFanout = (c: any, exchangeName: string) => c.assertExchange(exchangeName, 'fanout');
 
 const connectionCreatedConst = 'connectionCreated';
-class RabbitMq implements RabbitWrapperInterface {
+class RabbitMq {
   static parseMsg(msg: any) {
     let { content } = msg;
     content = content.toString();
@@ -55,21 +50,14 @@ class RabbitMq implements RabbitWrapperInterface {
 
   exchanges: ExchangesCache;
 
-  isTestEnv: boolean;
-
-  constructor({ isTestEnv = false } = {}) {
+  constructor() {
     this.em = new EventEmitter();
     this.channel = null;
     this.connection = null;
     this.creatingConnection = false;
     this.exchanges = {};
-    this.isTestEnv = isTestEnv;
   }
 
-  private getConnectFunc = () => (this.isTestEnv ? connectMock : connectAmqp)
-
-  private connect = (urls:any[] = []) => this.getConnectFunc()(urls);
-
   public ack = async (msg: any) => {
     if (this.channel) {
       await this.channel.ack(msg);
@@ -101,7 +89,7 @@ class RabbitMq implements RabbitWrapperInterface {
       }
       this.creatingConnection = true;
       const host: string = process.env.RABBITMQ_SERVICE_HOST || '';
-      const connection: AmqpConnectionManager = await this.connect([`amqp://${host}`]);
+      const connection: AmqpConnectionManager = await connect([`amqp://${host}`]);
       this.connection = connection;
       this.connection.on('disconnect',
         ({ err }) => console.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`));
@@ -121,7 +109,7 @@ class RabbitMq implements RabbitWrapperInterface {
 
       try {
         if (this.channel === null) {
-          this.channel = await connection.createChannel({});
+          this.channel = connection.createChannel({});
         }
         resolve(this.channel);
       } catch (e) {

package/dist/interfaces/RabbitWrapperInterface.d.ts

@@ -1,15 +0,0 @@
-interface RabbitWrapperInterface {
-    ack: any;
-    nack: any;
-    getConnection: any;
-    assertChannel: any;
-    assertExchange: any;
-    getQueueLength: any;
-    bindQueue: any;
-    assertQueue: any;
-    consume: any;
-    consumeFromExchange: any;
-    publish: any;
-    sendToQueue: any;
-}
-export default RabbitWrapperInterface;

package/dist/interfaces/RabbitWrapperInterface.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/mockImpl/index.d.ts

@@ -1,25 +0,0 @@
-export interface channel {
-    assertQueue: any;
-    assertExchange: any;
-    bindQueue: any;
-    publish: any;
-    consume: any;
-    deleteQueue: any;
-    ack: any;
-    nack: any;
-    prefetch: any;
-    on: any;
-    once: any;
-    close: any;
-    addSetup: any;
-    checkQueue: any;
-    sendToQueue: any;
-}
-export interface connection {
-    createChannel: any;
-    createConfirmChannel: any;
-    on: any;
-    once: any;
-    close: any;
-}
-export declare const connect: () => any;

package/dist/mockImpl/index.js

@@ -1,98 +0,0 @@
-"use strict";
-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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.connect = void 0;
-const Bluebird = require("bluebird");
-let exchanges = {};
-let queues = {};
-const setIfUndef = (object, prop, value) => {
-    if (!object[prop]) {
-        // eslint-disable-next-line no-param-reassign
-        object[prop] = value;
-    }
-};
-class ChannelImpl {
-    constructor() {
-        this.assertQueue = (queue, qOptions) => new Bluebird((resolve) => {
-            setIfUndef(queues, queue, { messages: [], subscribers: [], options: qOptions });
-            return resolve();
-        });
-        this.assertExchange = (exchange, type, exchOptions = {}) => new Bluebird((resolve) => {
-            setIfUndef(exchanges, exchange, { bindings: [], options: exchOptions, type });
-            return resolve();
-        });
-        this.bindQueue = (queue, exchange, key) => new Bluebird((resolve, reject) => {
-            if (!exchanges[exchange])
-                return reject(`Bind to non-existing exchange ${exchange}`);
-            const re = `^${key.replace('.', '\\.').replace('#', '(\\w|\\.)+').replace('*', '\\w+')}$`;
-            exchanges[exchange].bindings.push({ regex: new RegExp(re), queueName: queue });
-            return resolve();
-        });
-        this.publish = (exchange, routingKey, content, props) => new Bluebird((resolve, reject) => {
-            if (!exchanges[exchange])
-                return reject(`Publish to non-existing exchange ${exchange}`);
-            const { bindings } = exchanges[exchange];
-            const matchingBindings = bindings.filter((b) => b.regex.test(routingKey));
-            matchingBindings.forEach((binding) => {
-                const subscribers = queues[binding.queueName] ? queues[binding.queueName].subscribers : [];
-                subscribers.forEach((sub) => {
-                    const message = { fields: { routingKey }, properties: props, content };
-                    sub(message);
-                });
-            });
-            return resolve();
-        });
-        this.consume = (queue, handler) => {
-            queues[queue].subscribers.push(handler);
-        };
-        this.sendToQueue = (queue, content, routingKey = '', props = {}) => {
-            const subscribers = queues[queue] ? queues[queue].subscribers : [];
-            subscribers.forEach((sub) => {
-                const message = { fields: { routingKey }, properties: props, content };
-                sub(message);
-            });
-        };
-        this.deleteQueue = (queue) => {
-            setImmediate(() => {
-                delete queues[queue];
-            });
-        };
-        this.checkQueue = () => ({ messageCount: 0 });
-        this.ack = () => null;
-        this.nack = () => null;
-        this.prefetch = () => null;
-        this.on = () => null;
-        this.once = () => null;
-        this.close = () => Bluebird.resolve();
-    }
-    addSetup(funcToRun) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const val = yield funcToRun(this);
-            return val;
-        });
-    }
-}
-const createChannel = () => new Bluebird((resolve) => resolve(new ChannelImpl()));
-exports.connect = () => new Bluebird((resolve) => {
-    const connectionImpl = {
-        createChannel,
-        createConfirmChannel: createChannel,
-        on: () => null,
-        once: () => null,
-        close: () => Bluebird.resolve(),
-    };
-    return resolve(connectionImpl);
-});
-const resetMock = () => {
-    queues = {};
-    exchanges = {};
-};
-module.exports = { connect: exports.connect, resetMock };

package/dist/mockImpl/index.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/mockImpl/index.test.js

@@ -1,67 +0,0 @@
-"use strict";
-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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable @typescript-eslint/ban-ts-comment,@typescript-eslint/no-unused-vars */
-const index_1 = require("../index");
-jest.setTimeout(120000);
-const rabbit = new index_1.default({ isTestEnv: true });
-describe('RabbitMQ', () => {
-    it('check exchange', () => __awaiter(void 0, void 0, void 0, function* () {
-        const callback = (msg, ack) => {
-            expect(msg.content).toEqual('hey');
-            ack(msg);
-        };
-        const mockFn = jest.fn(callback);
-        yield rabbit.consumeFromExchange('test-q2', 'test-e', mockFn);
-        yield rabbit.publish('test-e', 'hey');
-        expect(mockFn).toBeCalled();
-    }));
-    it('check queue', () => __awaiter(void 0, void 0, void 0, function* () {
-        const callback = (msg, ack) => {
-            expect(msg.content).toEqual('hey-q');
-            ack(msg);
-        };
-        const mockFn = jest.fn(callback);
-        yield rabbit.consume('test-q-2', mockFn);
-        yield rabbit.sendToQueue('test-q-2', 'hey-q');
-        expect(mockFn).toBeCalled();
-    }));
-    it('cant publish to unknown exchange', () => __awaiter(void 0, void 0, void 0, function* () {
-        let err;
-        try {
-            yield rabbit.publish('', 'hey');
-        }
-        catch (e) {
-            err = e;
-        }
-        expect(err).toBeDefined();
-    }));
-    it('get queue length', () => __awaiter(void 0, void 0, void 0, function* () {
-        const queueName = 'test-queue-length';
-        const exchangeName = 'test-e2';
-        yield rabbit.assertQueue(queueName);
-        yield rabbit.assertExchange(exchangeName);
-        yield rabbit.bindQueue(queueName, exchangeName);
-        yield rabbit.publish(exchangeName, 'hey');
-        let messageCount;
-        ({ messageCount } = yield rabbit.getQueueLength(queueName));
-        expect(messageCount).toEqual(0);
-        yield rabbit.publish(exchangeName, 'hey');
-        ({ messageCount } = yield rabbit.getQueueLength(queueName));
-        expect(messageCount).toEqual(0);
-        yield rabbit.consumeFromExchange(queueName, exchangeName, (msg, ack) => __awaiter(void 0, void 0, void 0, function* () {
-            expect(msg.content).toEqual('hey');
-            ack(msg);
-        }));
-        ({ messageCount } = yield rabbit.getQueueLength(queueName));
-        expect(messageCount).toEqual(0);
-    }));
-});

package/src/interfaces/RabbitWrapperInterface.ts

@@ -1,17 +0,0 @@
-interface RabbitWrapperInterface {
-    ack:any;
-    nack: any;
-    getConnection: any;
-    assertChannel: any;
-    assertExchange: any;
-    getQueueLength: any;
-    bindQueue: any;
-    assertQueue: any;
-    consume: any;
-    consumeFromExchange: any;
-    publish: any;
-    sendToQueue: any;
-
-}
-
-export default RabbitWrapperInterface;

package/src/mockImpl/index.test.ts

@@ -1,63 +0,0 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment,@typescript-eslint/no-unused-vars */
-import RabbitMq from '../index';
-
-jest.setTimeout(120000);
-
-const rabbit = new RabbitMq({ isTestEnv: true });
-
-describe('RabbitMQ', () => {
-  it('check exchange', async () => {
-    const callback = (msg: any, ack: any) => {
-      expect(msg.content).toEqual('hey');
-      ack(msg);
-    };
-    const mockFn = jest.fn(callback);
-    await rabbit.consumeFromExchange('test-q2', 'test-e', mockFn);
-    await rabbit.publish('test-e', 'hey');
-    expect(mockFn).toBeCalled();
-  });
-
-  it('check queue', async () => {
-    const callback = (msg: any, ack: any) => {
-      expect(msg.content).toEqual('hey-q');
-      ack(msg);
-    };
-    const mockFn = jest.fn(callback);
-    await rabbit.consume('test-q-2', mockFn);
-    await rabbit.sendToQueue('test-q-2', 'hey-q');
-    expect(mockFn).toBeCalled();
-  });
-
-  it('cant publish to unknown exchange', async () => {
-    let err;
-    try {
-      await rabbit.publish('', 'hey');
-    } catch (e) {
-      err = e;
-    }
-    expect(err).toBeDefined();
-  });
-
-  it('get queue length', async () => {
-    const queueName = 'test-queue-length';
-    const exchangeName = 'test-e2';
-
-    await rabbit.assertQueue(queueName);
-    await rabbit.assertExchange(exchangeName);
-    await rabbit.bindQueue(queueName, exchangeName);
-
-    await rabbit.publish(exchangeName, 'hey');
-    let messageCount: any;
-    ({ messageCount } = await rabbit.getQueueLength(queueName));
-    expect(messageCount).toEqual(0);
-    await rabbit.publish(exchangeName, 'hey');
-    ({ messageCount } = await rabbit.getQueueLength(queueName));
-    expect(messageCount).toEqual(0);
-    await rabbit.consumeFromExchange(queueName, exchangeName, async (msg: any, ack: any) => {
-      expect(msg.content).toEqual('hey');
-      ack(msg);
-    });
-    ({ messageCount } = await rabbit.getQueueLength(queueName));
-    expect(messageCount).toEqual(0);
-  });
-});

package/src/mockImpl/index.ts

@@ -1,132 +0,0 @@
-import * as Bluebird from 'bluebird';
-
-let exchanges: any = {};
-let queues: any = {};
-
-export interface channel {
-  assertQueue: any;
-  assertExchange: any;
-  bindQueue: any;
-  publish: any;
-  consume: any;
-  deleteQueue: any;
-  ack: any;
-  nack: any;
-  prefetch: any;
-  on: any;
-  once: any;
-  close: any;
-  addSetup: any;
-  checkQueue: any;
-  sendToQueue: any;
-}
-export interface connection {
-  createChannel: any;
-  createConfirmChannel: any;
-  on: any;
-  once: any;
-  close: any;
-}
-
-const setIfUndef = (object: any, prop: any, value: any) => {
-  if (!object[prop]) {
-    // eslint-disable-next-line no-param-reassign
-    object[prop] = value;
-  }
-};
-
-class ChannelImpl implements channel {
-  public assertQueue = (queue: any, qOptions: any) => new Bluebird((resolve: () => any) => {
-    setIfUndef(queues, queue, { messages: [], subscribers: [], options: qOptions });
-    return resolve();
-  });
-
-  public assertExchange = (exchange: any, type: any, exchOptions: any = {}) => new Bluebird((resolve: () => any) => {
-    setIfUndef(exchanges, exchange, { bindings: [], options: exchOptions, type });
-
-    return resolve();
-  });
-
-  public bindQueue = (queue: any, exchange: string, key: string) => new Bluebird((resolve: () => any, reject: (arg0: string) => any) => {
-    if (!exchanges[exchange]) return reject(`Bind to non-existing exchange ${exchange}`);
-
-    const re = `^${key.replace('.', '\\.').replace('#', '(\\w|\\.)+').replace('*', '\\w+')}$`;
-    exchanges[exchange].bindings.push({ regex: new RegExp(re), queueName: queue });
-
-    return resolve();
-  });
-
-  public publish = (exchange: string, routingKey: any, content: any, props: any) => new Bluebird((resolve: () => any, reject: (arg0: string) => any) => {
-    if (!exchanges[exchange]) return reject(`Publish to non-existing exchange ${exchange}`);
-
-    const { bindings } = exchanges[exchange];
-    const matchingBindings = bindings.filter((b: any) => b.regex.test(routingKey));
-
-    matchingBindings.forEach((binding: { queueName: string | number; }) => {
-      const subscribers = queues[binding.queueName] ? queues[binding.queueName].subscribers : [];
-      subscribers.forEach((sub: (arg0: { fields: { routingKey: any; }; properties: any; content: any; }) => void) => {
-        const message = { fields: { routingKey }, properties: props, content };
-        sub(message);
-      });
-    });
-
-    return resolve();
-  });
-
-  public consume = (queue: string | number, handler: any) => {
-    queues[queue].subscribers.push(handler);
-  };
-
-  public sendToQueue = (queue: string, content: any, routingKey = '', props: any = {}) => {
-    const subscribers = queues[queue] ? queues[queue].subscribers : [];
-    subscribers.forEach((sub: (arg0: { fields: { routingKey: any; }; properties: any; content: any; }) => void) => {
-      const message = { fields: { routingKey }, properties: props, content };
-      sub(message);
-    });
-  };
-
-  public deleteQueue = (queue: string | number) => {
-    setImmediate(() => {
-      delete queues[queue];
-    });
-  };
-
-  public async addSetup(funcToRun: any) {
-    const val = await funcToRun(this);
-    return val;
-  }
-
-  public checkQueue = () => ({ messageCount: 0 });
-
-  public ack = () => null;
-
-  public nack = () => null;
-
-  public prefetch = () => null;
-
-  public on = () => null;
-
-  public once = () => null;
-
-  public close = () => Bluebird.resolve();
-}
-
-const createChannel = () => new Bluebird((resolve: any) => resolve(new ChannelImpl()));
-export const connect = (): any => new Bluebird((resolve: any) => {
-  const connectionImpl: connection = {
-    createChannel,
-    createConfirmChannel: createChannel,
-    on: () => null,
-    once: () => null,
-    close: () => Bluebird.resolve(),
-  };
-
-  return resolve(connectionImpl);
-});
-
-const resetMock = () => {
-  queues = {};
-  exchanges = {};
-};
-
-module.exports = { connect, resetMock };