@autofleet/rabbit 1.6.2 → 2.0.0-1beta

package/dist/index.d.ts

@@ -2,13 +2,24 @@
 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 {
+declare class RabbitMq implements IAfRabbitMq {
     static parseMsg(msg: any): any;
     static validateName(type: string, name: string): void;
     PUBLISH_TIMEOUT: number;
@@ -22,9 +33,10 @@ declare class RabbitMq {
     exchanges: ExchangesCache;
     options: AfRabbitOptions | undefined;
     constructor(options?: AfRabbitOptions);
-    ack: (msg: any) => Promise<void>;
-    nack: (queue: string, options: any, deadQueueOptions: Options.AssertQueue) => (msg: any, { skipRetry, }?: any) => Promise<void>;
+    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>;

package/dist/index.js

@@ -52,13 +52,11 @@ class RabbitMq {
         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 = (msg) => __awaiter(this, void 0, void 0, function* () {
-            if (this.channel) {
-                yield this.channel.ack(msg);
-            }
+        this.ack = (channel) => (msg) => __awaiter(this, void 0, void 0, function* () {
+            yield channel.ack(msg);
         });
-        this.nack = (queue, options, deadQueueOptions) => (msg, { skipRetry = false, } = {}) => __awaiter(this, void 0, void 0, function* () {
-            if (this.channel) {
+        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)) {
@@ -70,7 +68,7 @@ class RabbitMq {
                     yield this.assertQueue(deadQueue, deadQueueOptions);
                     yield this.sendToQueue(deadQueue, msg.content, deadQueueOptions);
                 }
-                yield this.channel.ack(msg);
+                yield channel.ack(msg);
             }
         });
         this.em = new events_1.EventEmitter();
@@ -102,7 +100,7 @@ class RabbitMq {
                     return;
                 }
                 if (this.connection !== null) {
-                    return this.connection;
+                    return resolve(this.connection);
                 }
                 this.creatingConnection = true;
                 const host = process.env.RABBITMQ_SERVICE_HOST || '';
@@ -124,6 +122,12 @@ class RabbitMq {
             }));
         });
     }
+    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* () {
@@ -183,14 +187,14 @@ class RabbitMq {
             const optionsWithDefaults = Object.assign(Object.assign({}, defaultOptions), options);
             RabbitMq.validateName('queue', queue);
             const { limit, deadMessageTtl } = optionsWithDefaults;
-            const channel = yield this.assertChannel();
+            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) => {
                         outbreak_1.newTrace(outbreak_1.traceTypes.RABBIT);
-                        callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
+                        callback(RabbitMq.parseMsg(msg), this.ack(channel), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
                     }),
                 ]);
             }));
@@ -202,7 +206,7 @@ class RabbitMq {
             RabbitMq.validateName('exchange', exchange);
             RabbitMq.validateName('queue', queue);
             const { limit, deadMessageTtl } = optionsWithDefaults;
-            const channel = yield this.assertChannel();
+            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);
@@ -212,7 +216,7 @@ class RabbitMq {
                     c.bindQueue(queue, exchange, ''),
                     c.consume(queue, (msg) => {
                         outbreak_1.newTrace(outbreak_1.traceTypes.RABBIT);
-                        callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
+                        callback(RabbitMq.parseMsg(msg), this.ack(channel), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
                     }),
                 ]);
             }));
@@ -223,9 +227,14 @@ class RabbitMq {
             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();
+            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}`);
         });
     }

package/dist/mock.d.ts

@@ -1,13 +1,14 @@
 import 'jest';
-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>;
+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,5 +1,6 @@
 "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,34 +1,34 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "1.6.2",
+  "version": "2.0.0-1beta",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
     "start": "ts-node  src/index.ts",
     "example": "ts-node  src/example.ts",
-    "prepublish": "tsc",
+    "build": "tsc",
     "linter": "./node_modules/.bin/eslint .",
     "test": "jest --forceExit",
-    "test-local": "RABBITMQ_SERVICE_HOST=34.76.123.137:5672 jest --forceExit",
-    "coverage": "jest --coverage --forceExit --runInBand && rm -rf ./coverage",
+    "test-local": "RABBITMQ_SERVICE_HOST=10.132.0.98:5672 jest --forceExit",
+    "coverage": "jest --coverage --forceExit && rm -rf ./coverage",
     "dev": "nodemon"
   },
   "dependencies": {
     "@autofleet/outbreak": "0.0.6",
     "@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": "^22.4.4"
+    "bluebird": "^3.7.2"
   },
   "devDependencies": {
+    "@types/jest": "^26.0.23",
     "@typescript-eslint/eslint-plugin": "^4.8.1",
     "eslint": "^7.13.0",
     "eslint-config-airbnb-typescript": "^12.0.0",
     "eslint-plugin-import": "^2.22.1",
-    "ts-jest": "^25.4.0",
+    "jest": "^27.0.5",
+    "ts-jest": "^27.0.3",
     "ts-node": "^8.6.2",
     "typescript": "^3.8.3"
   },

package/src/index.ts

@@ -7,6 +7,18 @@ import { EventEmitter } from 'events';
 import { newTrace, traceTypes } from '@autofleet/outbreak';
 import RabbitError from './rabbitError';
 
+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
 }
@@ -26,7 +38,7 @@ const defaultOptions = {
 const assertExchangeFanout = (c: any, exchangeName: string) => c.assertExchange(exchangeName, 'fanout');
 
 const connectionCreatedConst = 'connectionCreated';
-class RabbitMq {
+class RabbitMq implements IAfRabbitMq {
   static parseMsg(msg: any) {
     let { content } = msg;
     content = content.toString();
@@ -76,13 +88,12 @@ class RabbitMq {
     this.options = options;
   }
 
-  public ack = async (msg: any) => {
-    if (this.channel) {
-      await this.channel.ack(msg);
-    }
+  public ack = (channel: ChannelWrapper) => async (msg: any) => {
+    await channel.ack(msg);
   }
 
   public nack = (
+    channel: ChannelWrapper,
     queue: string,
     options: any,
     deadQueueOptions: Options.AssertQueue,
@@ -92,7 +103,7 @@ class RabbitMq {
       skipRetry = false,
     }: any = { },
   ) => {
-    if (this.channel) {
+    if (channel) {
       if (
         !skipRetry
         && (!msg.content['x-retry-count']
@@ -105,7 +116,7 @@ class RabbitMq {
         await this.assertQueue(deadQueue, deadQueueOptions);
         await this.sendToQueue(deadQueue, msg.content, deadQueueOptions);
       }
-      await this.channel.ack(msg);
+      await channel.ack(msg);
     }
   }
 
@@ -116,7 +127,7 @@ class RabbitMq {
         return;
       }
       if (this.connection !== null) {
-        return this.connection;
+        return resolve(this.connection);
       }
       this.creatingConnection = true;
       const host: string = process.env.RABBITMQ_SERVICE_HOST || '';
@@ -137,6 +148,11 @@ class RabbitMq {
     });
   }
 
+  async getNewChannel() {
+    const connection: AmqpConnectionManager = await this.getConnection();
+    return connection.createChannel({});
+  }
+
   async assertChannel() {
     return new Promise<ChannelWrapper>(async (resolve, reject) => {
       if (this.channel) {
@@ -191,7 +207,7 @@ class RabbitMq {
     const optionsWithDefaults = { ...defaultOptions, ...options };
     RabbitMq.validateName('queue', queue);
     const { limit, deadMessageTtl } = optionsWithDefaults;
-    const channel: ChannelWrapper = await this.assertChannel();
+    const channel: ChannelWrapper = await this.getNewChannel();
     return channel.addSetup(async (c: ConfirmChannel) => {
       await c.assertQueue(queue);
       await c.prefetch(limit, true);
@@ -200,7 +216,7 @@ class RabbitMq {
           queue,
           (msg: any) => {
             newTrace(traceTypes.RABBIT);
-            callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
+            callback(RabbitMq.parseMsg(msg), this.ack(channel), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
           },
         ),
       ]);
@@ -212,7 +228,7 @@ class RabbitMq {
     RabbitMq.validateName('exchange', exchange);
     RabbitMq.validateName('queue', queue);
     const { limit, deadMessageTtl } = optionsWithDefaults;
-    const channel: ChannelWrapper = await this.assertChannel();
+    const channel: ChannelWrapper = await this.getNewChannel();
 
     return channel.addSetup(async (c: ConfirmChannel) => {
       const assertExchange = await assertExchangeFanout(c, exchange);
@@ -225,7 +241,7 @@ class RabbitMq {
           queue,
           (msg: any) => {
             newTrace(traceTypes.RABBIT);
-            callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
+            callback(RabbitMq.parseMsg(msg), this.ack(channel), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
           },
         ),
       ]);
@@ -236,9 +252,13 @@ class RabbitMq {
     RabbitMq.validateName('exchange', exchange);
     const channel: ChannelWrapper = await this.assertChannel();
     await this.assertExchange(exchange);
-    return new bluebird.Promise(async (resolve) => {
-      await channel.publish(exchange, '', Buffer.from(JSON.stringify(content)));
-      return resolve();
+    return new bluebird.Promise(async (resolve, reject) => {
+      try {
+        await channel.publish(exchange, '', Buffer.from(JSON.stringify(content)));
+        return resolve();
+      } catch (e) {
+        reject(e);
+      }
     }).timeout(this.PUBLISH_TIMEOUT, `${this.PUBLISH_ERROR_MSG}${exchange}`);
   }
 

package/src/mock.ts

@@ -1,23 +1,25 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
 import 'jest';
+import { IAfRabbitMq } from './index';
 
-class RabbitMq {
-  public ack = jest.fn();
+class RabbitMq implements IAfRabbitMq {
+  ack: any = jest.fn();
 
-  public nack = jest.fn();
+  nack: any = jest.fn();
 
-  public assertChannel = jest.fn();
+  assertChannel: any = jest.fn();
 
-  public assertExchange = jest.fn();
+  assertExchange: any = jest.fn();
 
-  public assertQueue = jest.fn();
+  assertQueue: any = jest.fn();
 
-  public consume = jest.fn();
+  consume: any = jest.fn();
 
-  public consumeFromExchange = jest.fn();
+  consumeFromExchange: any = jest.fn();
 
-  public publish = jest.fn();
+  publish: any = jest.fn();
 
-  public sendToQueue = jest.fn();
+  sendToQueue: any = jest.fn();
 }
 
 export default RabbitMq;

package/tsconfig.json

@@ -6,5 +6,6 @@
     "outDir": "./dist",
     "strict": true,
     "esModuleInterop": true
-  }
+  },
+  "exclude": ["node_modules", "**/*.test.ts"]
 }

package/.eslintrc.json

@@ -1,66 +0,0 @@
-{
-  "root": true,
-  "env": {
-    "node": true,
-    "jest": true
-  },
-  "extends": [
-    "airbnb-base",
-    "plugin:@typescript-eslint/recommended"
-  ],
-  "rules": {
-    "import/extensions": [
-      "error",
-      "ignorePackages",
-      {
-        "js": "never",
-        "jsx": "never",
-        "ts": "never",
-        "tsx": "never"
-      }
-    ],
-    "@typescript-eslint/no-unused-vars": ["error"],
-    "@typescript-eslint/no-var-requires": ["off"],
-    "@typescript-eslint/camelcase": ["off"],
-    "max-len": ["off"],
-    "@typescript-eslint/explicit-function-return-type": ["off"]
-  },
-  "overrides": [
-    {
-      // enable the rule specifically for TypeScript files
-      "files": ["src/**.js", "src/**.ts"],
-      "rules": {
-        "@typescript-eslint/explicit-function-return-type": ["off"],
-        "@typescript-eslint/no-var-requires": ["off"],
-        "@typescript-eslint/camelcase": ["off"]
-      }
-    }
-  ],
-  "parser": "@typescript-eslint/parser",
-  "parserOptions": {
-    "project": "./tsconfig.json",
-    "sourceType": "module"
-  },
-  "ignorePatterns": ["dist/*", "node_modules/", "jest.config.js", "migrations/*", "newrelic.js"],
-  "plugins": ["@typescript-eslint"],
-  "settings": {
-    "import/extensions": [
-      "error",
-      "ignorePackages",
-      {
-        "js": "never",
-        "jsx": "never",
-        "ts": "never",
-        "tsx": "never"
-      }
-    ],
-    "import/parsers": {
-      "@typescript-eslint/parser": [".ts",".tsx"]
-    },
-    "import/resolver": {
-      "node": {
-        "extensions": [".js",".jsx",".ts",".tsx", ".json"]
-      }
-    }
-  }
-}

package/dist/example.d.ts

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

package/dist/example.js

@@ -1,37 +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());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = __importDefault(require("./index"));
-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();
-    yield rabbit.consumeFromExchange('test-q2', 'test-e', (msg, ack) => {
-        console.log('consumeFromExchange: msg2', msg.content);
-        ack(msg);
-    });
-    yield rabbit.consumeFromExchange('test-q', 'test-e', (msg, ack) => {
-        console.log('consumeFromExchange: msg', msg.content);
-        ack(msg);
-    });
-    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);
-    });
-    yield rabbit.sendToQueue('test-q-2', 'hey-q');
-    const getQueueLength = yield rabbit.getQueueLength('test-q2');
-    console.log(`getQueueLength:${getQueueLength}`);
-});
-init();

package/dist/index.test.d.ts

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

package/dist/index.test.js

@@ -1,114 +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());
-    });
-};
-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/no-unused-vars */
-const index_1 = __importDefault(require("./index"));
-jest.setTimeout(120000);
-const rabbit = new index_1.default();
-const delay = (ms = 500) => new Promise((resolve) => setTimeout(() => resolve(), ms));
-const callback = (eq = 'hey') => (msg, ack) => {
-    expect(msg.content).toEqual(eq);
-    ack(msg);
-};
-const nackcallback = ({ skipRetry = false } = {}) => (msg, ack, nack) => {
-    console.log('msg', msg.content);
-    expect(msg.content.ttt).toEqual('hey-q');
-    if (skipRetry) {
-        nack(msg, { skipRetry });
-    }
-    else {
-        nack(msg);
-    }
-};
-describe('RabbitMQ', () => {
-    it('check exchange', () => __awaiter(void 0, void 0, void 0, function* () {
-        const mockFn = jest.fn(callback());
-        yield rabbit.consumeFromExchange('test-q2', 'test-e', mockFn);
-        yield rabbit.publish('test-e', 'hey');
-        yield delay();
-        expect(mockFn).toBeCalled();
-    }));
-    it('check queue', () => __awaiter(void 0, void 0, void 0, function* () {
-        const mockFn = jest.fn(callback('hey-q'));
-        yield rabbit.consume('test-q-2', mockFn);
-        yield rabbit.sendToQueue('test-q-2', 'hey-q');
-        yield delay();
-        expect(mockFn).toBeCalled();
-    }));
-    it('check retry', () => __awaiter(void 0, void 0, void 0, function* () {
-        const mockFn = jest.fn(nackcallback());
-        yield rabbit.consume('test-q-retry', mockFn, { retries: 3 });
-        yield rabbit.sendToQueue('test-q-retry', { ttt: 'hey-q' });
-        yield delay(1500);
-        expect(mockFn).toHaveBeenCalledTimes(4); // one run then 3 times retry
-    }));
-    it('check skip retry', () => __awaiter(void 0, void 0, void 0, function* () {
-        const mockFn = jest.fn(nackcallback({ skipRetry: true }));
-        yield rabbit.consume('test-q-skip-retry', mockFn, { retries: 3 });
-        yield rabbit.sendToQueue('test-q-skip-retry', { ttt: 'hey-q' });
-        yield delay(1500);
-        expect(mockFn).toHaveBeenCalledTimes(1);
-    }));
-    it('check nack and dead queue', () => __awaiter(void 0, void 0, void 0, function* () {
-        const mockFn = jest.fn(nackcallback());
-        yield rabbit.consume('test-q-nack', mockFn);
-        yield rabbit.sendToQueue('test-q-nack', { ttt: 'hey-q' });
-        yield delay(1000);
-        expect(mockFn).toHaveBeenCalledTimes(2); // one run then 1 time retry
-        yield delay();
-        const length = yield rabbit.getQueueLength('test-q-nack-dead');
-        expect(length.messageCount).toEqual(1);
-    }));
-    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('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 {
-            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, callback());
-        yield delay();
-        ({ messageCount } = yield rabbit.getQueueLength(queueName));
-        expect(messageCount).toEqual(0);
-    }));
-});

package/jest.config.js

@@ -1,14 +0,0 @@
-module.exports = {
-  testEnvironment: 'node',
-  roots: ['<rootDir>/src'],
-  transform: {
-    '^.+\\.tsx?$': 'ts-jest',
-  },
-  testRegex: '(/__tests__/.*|(\\.|/)(test|spec))\\.(tsx?$|jsx?$)',
-  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
-  coverageThreshold: {
-    global: {
-      lines: 75,
-    },
-  },
-}

package/nodemon.json

@@ -1,13 +0,0 @@
-{
-  "ignore": [
-    "**/*.test.ts",
-    "**/*.spec.ts",
-    ".git",
-    "node_modules"
-  ],
-  "watch": [
-    "src"
-  ],
-  "exec": "npm start",
-  "ext": "ts"
-}

package/src/example.ts

@@ -1,31 +0,0 @@
-import RabbitMq from './index';
-
-process.env.RABBITMQ_SERVICE_HOST = '34.76.123.137:5672';
-
-const init = async () => {
-  const rabbit = new RabbitMq();
-
-  await 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('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('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,113 +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();
-
-const delay = (ms = 500) => new Promise((resolve) => setTimeout(() => resolve(), ms));
-
-const callback = (eq = 'hey') => (msg: any, ack: any) => {
-  expect(msg.content).toEqual(eq);
-  ack(msg);
-};
-
-const nackcallback = ({ skipRetry = false } = { }) => (msg: any, ack: any, nack: any) => {
-  console.log('msg', msg.content);
-  expect(msg.content.ttt).toEqual('hey-q');
-  if (skipRetry) {
-    nack(msg, { skipRetry });
-  } else {
-    nack(msg);
-  }
-};
-
-describe('RabbitMQ', () => {
-  it('check exchange', async () => {
-    const mockFn = jest.fn(callback());
-    await rabbit.consumeFromExchange('test-q2', 'test-e', mockFn);
-    await rabbit.publish('test-e', 'hey');
-    await delay();
-    expect(mockFn).toBeCalled();
-  });
-
-  it('check queue', async () => {
-    const mockFn = jest.fn(callback('hey-q'));
-    await rabbit.consume('test-q-2', mockFn);
-    await rabbit.sendToQueue('test-q-2', 'hey-q');
-    await delay();
-    expect(mockFn).toBeCalled();
-  });
-
-  it('check retry', async () => {
-    const mockFn = jest.fn(nackcallback());
-    await rabbit.consume('test-q-retry', mockFn, { retries: 3 });
-    await rabbit.sendToQueue('test-q-retry', { ttt: 'hey-q' });
-    await delay(1500);
-    expect(mockFn).toHaveBeenCalledTimes(4); // one run then 3 times retry
-  });
-
-  it('check skip retry', async () => {
-    const mockFn = jest.fn(nackcallback({ skipRetry: true }));
-    await rabbit.consume('test-q-skip-retry', mockFn, { retries: 3 });
-    await rabbit.sendToQueue('test-q-skip-retry', { ttt: 'hey-q' });
-    await delay(1500);
-    expect(mockFn).toHaveBeenCalledTimes(1);
-  });
-
-  it('check nack and dead queue', async () => {
-    const mockFn = jest.fn(nackcallback());
-    await rabbit.consume('test-q-nack', mockFn);
-    await rabbit.sendToQueue('test-q-nack', { ttt: 'hey-q' });
-    await delay(1000);
-    expect(mockFn).toHaveBeenCalledTimes(2); // one run then 1 time retry
-    await delay();
-    const length = await rabbit.getQueueLength('test-q-nack-dead');
-    expect(length.messageCount).toEqual(1);
-  });
-
-  it('cant publish to unknown exchange', async () => {
-    let err;
-    try {
-      await rabbit.publish('', 'hey');
-    } catch (e) {
-      err = e;
-    }
-    expect(err).toBeDefined();
-  });
-
-  it('cant publish due timeout', async () => {
-    // @ts-ignore
-    process.env.RABBITMQ_PUBLISH_TIMEOUT = 1;
-    const rabbit2 = new RabbitMq();
-
-    let err;
-    try {
-      await rabbit2.publish('test-e', '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(1);
-    await rabbit.publish(exchangeName, 'hey');
-    ({ messageCount } = await rabbit.getQueueLength(queueName));
-    expect(messageCount).toEqual(2);
-    await rabbit.consumeFromExchange(queueName, exchangeName, callback());
-    await delay();
-    ({ messageCount } = await rabbit.getQueueLength(queueName));
-    expect(messageCount).toEqual(0);
-  });
-});