@autofleet/rabbit 1.5.0 → 1.5.2

package/dist/example.js

@@ -1,24 +1,34 @@
 "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 });
 const index_1 = require("./index");
-// process.env.RABBITMQ_SERVICE_HOST="34.76.223.229:5672";
-const init = async () => {
+process.env.RABBITMQ_SERVICE_HOST = '34.76.123.137:5672';
+const init = () => __awaiter(void 0, void 0, void 0, function* () {
     const rabbit = new index_1.default();
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    await rabbit.consumeFromExchange('test-q2', 'test-e', (msg, ack) => {
-        console.log('msg2', msg.content);
-        // ack(msg);
+    yield rabbit.consumeFromExchange('test-q2', 'test-e', (msg, ack) => {
+        console.log('consumeFromExchange: msg2', msg.content);
+        ack(msg);
     });
-    await rabbit.consumeFromExchange('test-q', 'test-e', (msg, ack) => {
-        console.log('msg', msg.content);
+    yield rabbit.consumeFromExchange('test-q', 'test-e', (msg, ack) => {
+        console.log('consumeFromExchange: msg', msg.content);
         ack(msg);
     });
-    await rabbit.publish('test-e', 'hey');
-    await rabbit.publish('test-e', 'hey1');
-    await rabbit.consume('test-q-2', (msg, ack) => {
-        console.log('msg-q', msg.content);
+    yield rabbit.publish('test-e', 'hey');
+    yield rabbit.publish('test-e', 'hey1');
+    yield rabbit.consume('test-q-2', (msg, ack) => {
+        console.log('consume: msg-q', msg.content);
         ack(msg);
     });
-    await rabbit.sendToQueue('test-q-2', 'hey-q');
-};
+    yield rabbit.sendToQueue('test-q-2', 'hey-q');
+    const getQueueLength = yield rabbit.getQueueLength('test-q2');
+    console.log(`getQueueLength:${getQueueLength}`);
+});
 init();

package/dist/index.d.ts

@@ -21,6 +21,8 @@ declare class RabbitMq {
     getConnection(): Promise<AmqpConnectionManager>;
     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?: any): 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>;

package/dist/index.js

@@ -1,36 +1,46 @@
 "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/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 = require("bluebird");
 const amqp_connection_manager_1 = require("amqp-connection-manager");
 const events_1 = require("events");
 const rabbitError_1 = require("./rabbitError");
+const assertExchangeFanout = (c, exchangeName) => c.assertExchange(exchangeName, 'fanout');
 const connectionCreatedConst = 'connectionCreated';
 class RabbitMq {
     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.ack = async (msg) => {
+        this.ack = (msg) => __awaiter(this, void 0, void 0, function* () {
             if (this.channel) {
-                await this.channel.ack(msg);
+                yield this.channel.ack(msg);
             }
-        };
-        this.nack = (queue) => async (msg, retries) => {
+        });
+        this.nack = (queue) => (msg, retries) => __awaiter(this, void 0, void 0, function* () {
             if (this.channel) {
                 if (!msg.content['x-retry-count'] || msg.content['x-retry-count'] <= retries) {
-                    // eslint-disable-next-line no-param-reassign
                     msg.content['x-retry-count'] = msg.content['x-retry-count'] ? msg.content['x-retry-count'] + 1 : 1;
-                    await this.sendToQueue(queue, msg.content);
+                    yield this.sendToQueue(queue, msg.content);
                 }
                 else {
                     const deadQueue = `${queue}-dead`;
-                    await this.assertQueue(deadQueue);
-                    await this.sendToQueue(deadQueue, msg.content);
+                    yield this.assertQueue(deadQueue);
+                    yield this.sendToQueue(deadQueue, msg.content);
                 }
-                await this.channel.ack(msg);
+                yield this.channel.ack(msg);
             }
-        };
+        });
         this.em = new events_1.EventEmitter();
         this.channel = null;
         this.connection = null;
@@ -43,7 +53,7 @@ class RabbitMq {
         try {
             content = JSON.parse(content);
         }
-        catch (e) { } // eslint-disable-line no-empty
+        catch (e) { }
         return Object.assign(Object.assign({}, msg), { content });
     }
     static validateName(type, name) {
@@ -51,108 +61,131 @@ class RabbitMq {
             throw new rabbitError_1.default(`error while using ${type} with no name`);
         }
     }
-    async getConnection() {
-        // eslint-disable-next-line no-async-promise-executor
-        return new Promise(async (resolve) => {
-            if (this.creatingConnection) {
-                this.em.on(connectionCreatedConst, resolve);
-                return;
-            }
-            if (this.connection !== null) {
-                // eslint-disable-next-line consistent-return
-                return this.connection;
-            }
-            this.creatingConnection = true;
-            const host = process.env.RABBITMQ_SERVICE_HOST || '';
-            const connection = await 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;
-            this.em.emit(connectionCreatedConst, connection);
-            resolve(connection);
+    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 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 }) => console.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`));
+                this.creatingConnection = false;
+                this.em.emit(connectionCreatedConst, connection);
+                resolve(connection);
+            }));
         });
     }
-    async assertChannel() {
-        // eslint-disable-next-line no-async-promise-executor,consistent-return
-        return new Promise(async (resolve, reject) => {
-            if (this.channel) {
-                return resolve(this.channel);
-            }
-            const connection = await this.getConnection();
-            try {
-                if (this.channel === null) {
-                    this.channel = 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);
                 }
-                resolve(this.channel);
-            }
-            catch (e) {
-                reject(e);
+                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;
+            }));
         });
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async assertExchange(exchangeName, options) {
-        const channel = await this.assertChannel();
-        if (this.exchanges[exchangeName]) {
-            return this.exchanges[exchangeName];
-        }
-        return channel.addSetup(async (c) => {
-            const exchange = await c.assertExchange(exchangeName, 'fanout');
-            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);
         });
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async assertQueue(queue, options) {
-        RabbitMq.validateName('queue', queue);
-        const channel = await this.assertChannel();
-        return channel.addSetup((c) => c.assertQueue(queue));
+    bindQueue(queue, exchange) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const channel = yield this.assertChannel();
+            // @ts-ignore
+            return channel.bindQueue(queue, exchange, '');
+        });
     }
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    async consume(queue, callback, options) {
-        RabbitMq.validateName('queue', queue);
-        const { limit } = (options && options.limit) ? options : { limit: 1 };
-        const channel = await this.assertChannel();
-        await this.assertQueue(queue);
-        return channel.addSetup(async (c) => {
-            await c.prefetch(limit, true);
-            return Promise.all([
-                c.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue))),
-            ]);
+    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));
         });
     }
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    async consumeFromExchange(queue, exchange, callback, options) {
-        RabbitMq.validateName('queue', queue);
-        RabbitMq.validateName('exchange', exchange);
-        const { limit } = (options && options.limit) ? options : { limit: 1 };
-        const channel = await this.assertChannel();
-        await Promise.all([
-            this.assertExchange(exchange),
-            this.assertQueue(queue),
-        ]);
-        return channel.addSetup(async (c) => {
-            await c.prefetch(limit, true);
-            return Promise.all([
-                c.bindQueue(queue, exchange, ''),
-                c.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue))),
-            ]);
+    consume(queue, callback, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            RabbitMq.validateName('queue', queue);
+            const { limit } = (options && options.limit) ? options : { limit: 1 };
+            const channel = yield this.assertChannel();
+            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) => callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue))),
+                ]);
+            }));
         });
     }
-    async publish(exchange, content) {
-        RabbitMq.validateName('exchange', exchange);
-        const channel = await this.assertChannel();
-        await this.assertExchange(exchange);
-        return new bluebird.Promise(async (resolve) => {
-            await channel.publish(exchange, '', Buffer.from(JSON.stringify(content)));
-            return resolve();
-        }).timeout(this.PUBLISH_TIMEOUT, `${this.PUBLISH_ERROR_MSG}${exchange}`);
+    consumeFromExchange(queue, exchange, callback, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            RabbitMq.validateName('queue', queue);
+            RabbitMq.validateName('exchange', exchange);
+            const { limit } = (options && options.limit) ? options : { limit: 1 };
+            const channel = yield this.assertChannel();
+            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) => callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue))),
+                ]);
+            }));
+        });
+    }
+    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) => __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}`);
+        });
     }
-    async sendToQueue(queue, content) {
-        RabbitMq.validateName('queue', queue);
-        const channel = await this.assertChannel();
-        await this.assertQueue(queue);
-        return channel.sendToQueue(queue, Buffer.from(JSON.stringify(content)));
+    sendToQueue(queue, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            RabbitMq.validateName('queue', queue);
+            const channel = yield this.assertChannel();
+            yield this.assertQueue(queue);
+            return channel.sendToQueue(queue, Buffer.from(JSON.stringify(content)));
+        });
     }
 }
 exports.default = RabbitMq;

package/dist/index.test.js

@@ -1,55 +1,84 @@
 "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");
-// import RabbitError from './rabbitError';
 jest.setTimeout(120000);
 const rabbit = new index_1.default();
 const delay = () => new Promise((resolve) => setTimeout(() => resolve(), 500));
 describe('RabbitMQ', () => {
-    it('check exchange', async () => {
+    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);
-        await rabbit.consumeFromExchange('test-q2', 'test-e', mockFn);
-        await rabbit.publish('test-e', 'hey');
-        await delay();
+        yield rabbit.consumeFromExchange('test-q2', 'test-e', mockFn);
+        yield rabbit.publish('test-e', 'hey');
+        yield delay();
         expect(mockFn).toBeCalled();
-    });
-    it('check queue', async () => {
+    }));
+    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);
-        await rabbit.consume('test-q-2', mockFn);
-        await rabbit.sendToQueue('test-q-2', 'hey-q');
-        await delay();
+        yield rabbit.consume('test-q-2', mockFn);
+        yield rabbit.sendToQueue('test-q-2', 'hey-q');
+        yield delay();
         expect(mockFn).toBeCalled();
-    });
-    it('cant publish to unknown exchange', async () => {
+    }));
+    it('cant publish to unknown exchange', () => __awaiter(void 0, void 0, void 0, function* () {
         let err;
         try {
-            await rabbit.publish('', 'hey');
+            yield rabbit.publish('', 'hey');
         }
         catch (e) {
             err = e;
         }
         expect(err).toBeDefined();
-    });
-    it('cant publish due timeout', async () => {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    }));
+    it('cant publish due timeout', () => __awaiter(void 0, void 0, void 0, function* () {
         // @ts-ignore
         process.env.RABBITMQ_PUBLISH_TIMEOUT = 1;
         const rabbit2 = new index_1.default();
         let err;
         try {
-            await rabbit2.publish('test-e', 'hey');
+            yield rabbit2.publish('test-e', '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(1);
+        yield rabbit.publish(exchangeName, 'hey');
+        ({ messageCount } = yield rabbit.getQueueLength(queueName));
+        expect(messageCount).toEqual(2);
+        yield rabbit.consumeFromExchange(queueName, exchangeName, (msg, ack) => __awaiter(void 0, void 0, void 0, function* () {
+            expect(msg.content).toEqual('hey');
+            ack(msg);
+        }));
+        yield delay();
+        ({ messageCount } = yield rabbit.getQueueLength(queueName));
+        expect(messageCount).toEqual(0);
+    }));
 });

package/dist/mock.d.ts

@@ -1,13 +1,13 @@
 import 'jest';
 declare class RabbitMq {
-    ack: jest.Mock<any, any>;
-    nack: jest.Mock<any, any>;
-    assertChannel: jest.Mock<any, any>;
-    assertExchange: jest.Mock<any, any>;
-    assertQueue: jest.Mock<any, any>;
-    consume: jest.Mock<any, any>;
-    consumeFromExchange: jest.Mock<any, any>;
-    publish: jest.Mock<any, any>;
-    sendToQueue: jest.Mock<any, any>;
+    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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -9,27 +9,27 @@
     "prepublish": "tsc",
     "linter": "./node_modules/.bin/eslint .",
     "test": "jest --forceExit",
-    "test-local": "RABBITMQ_SERVICE_HOST=34.76.223.229:5672 jest --forceExit",
+    "test-local": "RABBITMQ_SERVICE_HOST=34.76.123.137:5672 jest --forceExit",
     "coverage": "jest --coverage --forceExit --runInBand && rm -rf ./coverage",
     "dev": "nodemon"
   },
   "dependencies": {
-    "@types/amqp-connection-manager": "^2.0.2",
-    "@types/amqplib": "^0.5.9",
-    "@types/jest": "^23.3.10",
+    "@types/amqp-connection-manager": "^2.0.10",
+    "@types/amqplib": "^0.5.16",
+    "@types/jest": "^22.0.0",
     "amqp-connection-manager": "^3.2.1",
     "amqplib": "^0.6.0",
     "bluebird": "^3.7.2",
-    "jest": "^26.6.3",
-    "ts-jest": "^26.4.4"
+    "jest": "^22.4.4"
   },
   "devDependencies": {
-    "ts-node": "^7.0.1",
-    "typescript": "^3.2.1",
     "@typescript-eslint/eslint-plugin": "^4.8.1",
     "eslint": "^7.13.0",
     "eslint-config-airbnb-typescript": "^12.0.0",
-    "eslint-plugin-import": "^2.22.1"
+    "eslint-plugin-import": "^2.22.1",
+    "ts-jest": "^25.4.0",
+    "ts-node": "^8.6.2",
+    "typescript": "^3.8.3"
   },
   "author": "",
   "license": "ISC"

package/src/example.ts

@@ -1,27 +1,31 @@
 import RabbitMq from './index';
 
-// process.env.RABBITMQ_SERVICE_HOST="34.76.223.229:5672";
+process.env.RABBITMQ_SERVICE_HOST = '34.76.123.137:5672';
 
 const init = async () => {
   const rabbit = new RabbitMq();
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
   await rabbit.consumeFromExchange('test-q2', 'test-e', (msg, ack) => {
-    console.log('msg2', msg.content);
-    // ack(msg);
+    console.log('consumeFromExchange: msg2', msg.content);
+    ack(msg);
   });
 
   await rabbit.consumeFromExchange('test-q', 'test-e', (msg, ack) => {
-    console.log('msg', msg.content);
+    console.log('consumeFromExchange: msg', msg.content);
     ack(msg);
   });
   await rabbit.publish('test-e', 'hey');
   await rabbit.publish('test-e', 'hey1');
 
   await rabbit.consume('test-q-2', (msg, ack) => {
-    console.log('msg-q', msg.content);
+    console.log('consume: msg-q', msg.content);
     ack(msg);
   });
+
   await rabbit.sendToQueue('test-q-2', 'hey-q');
+
+  const getQueueLength = await rabbit.getQueueLength('test-q2');
+  console.log(`getQueueLength:${getQueueLength}`);
 };
 
 init();

package/src/index.test.ts

@@ -1,5 +1,5 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment,@typescript-eslint/no-unused-vars */
 import RabbitMq from './index';
-// import RabbitError from './rabbitError';
 
 jest.setTimeout(120000);
 
@@ -43,7 +43,6 @@ describe('RabbitMQ', () => {
   });
 
   it('cant publish due timeout', async () => {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
     process.env.RABBITMQ_PUBLISH_TIMEOUT = 1;
     const rabbit2 = new RabbitMq();
@@ -56,4 +55,28 @@ describe('RabbitMQ', () => {
     }
     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(1);
+    await rabbit.publish(exchangeName, 'hey');
+    ({ messageCount } = await rabbit.getQueueLength(queueName));
+    expect(messageCount).toEqual(2);
+    await rabbit.consumeFromExchange(queueName, exchangeName, async (msg: any, ack: any) => {
+      expect(msg.content).toEqual('hey');
+      ack(msg);
+    });
+    await delay();
+    ({ messageCount } = await rabbit.getQueueLength(queueName));
+    expect(messageCount).toEqual(0);
+  });
 });

package/src/index.ts

@@ -1,3 +1,4 @@
+/* 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
 import * as bluebird from 'bluebird';
 import { ConfirmChannel } from 'amqplib';
@@ -9,6 +10,8 @@ interface ExchangesCache {
   [key: string]: any
 }
 
+const assertExchangeFanout = (c: any, exchangeName: string) => c.assertExchange(exchangeName, 'fanout');
+
 const connectionCreatedConst = 'connectionCreated';
 class RabbitMq {
   static parseMsg(msg: any) {
@@ -17,7 +20,7 @@ class RabbitMq {
 
     try {
       content = JSON.parse(content);
-    } catch (e) { } // eslint-disable-line no-empty
+    } catch (e) { }
 
     return {
       ...msg,
@@ -64,7 +67,6 @@ class RabbitMq {
   public nack = (queue: string) => async (msg: any, retries: number) => {
     if (this.channel) {
       if (!msg.content['x-retry-count'] || msg.content['x-retry-count'] <= retries) {
-        // eslint-disable-next-line no-param-reassign
         msg.content['x-retry-count'] = msg.content['x-retry-count'] ? msg.content['x-retry-count'] + 1 : 1;
         await this.sendToQueue(queue, msg.content);
       } else {
@@ -77,14 +79,12 @@ class RabbitMq {
   }
 
   async getConnection() {
-    // eslint-disable-next-line no-async-promise-executor
     return new Promise<AmqpConnectionManager>(async (resolve) => {
       if (this.creatingConnection) {
         this.em.on(connectionCreatedConst, resolve);
         return;
       }
       if (this.connection !== null) {
-        // eslint-disable-next-line consistent-return
         return this.connection;
       }
       this.creatingConnection = true;
@@ -100,7 +100,6 @@ class RabbitMq {
   }
 
   async assertChannel() {
-    // eslint-disable-next-line no-async-promise-executor,consistent-return
     return new Promise<ChannelWrapper>(async (resolve, reject) => {
       if (this.channel) {
         return resolve(this.channel);
@@ -119,33 +118,43 @@ class RabbitMq {
     });
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async assertExchange(exchangeName: string, options?: any) {
     const channel: ChannelWrapper = await this.assertChannel();
     if (this.exchanges[exchangeName]) {
       return this.exchanges[exchangeName];
     }
     return channel.addSetup(async (c: ConfirmChannel) => {
-      const exchange = await c.assertExchange(exchangeName, 'fanout');
+      const exchange = await assertExchangeFanout(c, exchangeName);
       this.exchanges[exchangeName] = exchange;
       return exchange;
     });
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async getQueueLength(queue: string) {
+    RabbitMq.validateName('queue', queue);
+    const channel: ChannelWrapper = await this.assertChannel();
+    // @ts-ignore
+    return channel.checkQueue(queue);
+  }
+
+  async bindQueue(queue: string, exchange: string) {
+    const channel: ChannelWrapper = await this.assertChannel();
+    // @ts-ignore
+    return channel.bindQueue(queue, exchange, '');
+  }
+
   async assertQueue(queue: string, options?: any) {
     RabbitMq.validateName('queue', queue);
     const channel: ChannelWrapper = await this.assertChannel();
     return channel.addSetup((c: ConfirmChannel) => c.assertQueue(queue));
   }
 
-  // eslint-disable-next-line @typescript-eslint/ban-types
   async consume(queue: string, callback: (msg: any, ack: Function, nack: Function) => any, options?: any) {
     RabbitMq.validateName('queue', queue);
     const { limit } = (options && options.limit) ? options : { limit: 1 };
     const channel: ChannelWrapper = await this.assertChannel();
-    await this.assertQueue(queue);
     return channel.addSetup(async (c: ConfirmChannel) => {
+      await c.assertQueue(queue);
       await c.prefetch(limit, true);
       return Promise.all([
         c.consume(queue, (msg: any) => callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue))),
@@ -153,18 +162,16 @@ class RabbitMq {
     });
   }
 
-  // eslint-disable-next-line @typescript-eslint/ban-types
   async consumeFromExchange(queue: string, exchange: string, callback: (msg: any, ack: Function, nack: Function) => any, options?: any) {
     RabbitMq.validateName('queue', queue);
     RabbitMq.validateName('exchange', exchange);
     const { limit } = (options && options.limit) ? options : { limit: 1 };
     const channel: ChannelWrapper = await this.assertChannel();
-    await Promise.all([
-      this.assertExchange(exchange),
-      this.assertQueue(queue),
-    ]);
 
     return channel.addSetup(async (c: ConfirmChannel) => {
+      const assertExchange = await assertExchangeFanout(c, exchange);
+      await c.assertQueue(queue);
+      this.exchanges[exchange] = assertExchange;
       await c.prefetch(limit, true);
       return Promise.all([
         c.bindQueue(queue, exchange, ''),

package/tsconfig.json

@@ -1,12 +1,9 @@
 {
   "compilerOptions": {
-    "target": "es2017",
+    "target": "es6",
     "module": "commonjs",
-    "lib": [
-      "es2017"
-    ],
     "declaration": true,
     "outDir": "./dist",
     "strict": true
   }
-}
+}