@autofleet/rabbit 1.5.7 → 1.6.1

package/dist/index.d.ts

@@ -5,24 +5,25 @@ import { EventEmitter } from 'events';
 interface ExchangesCache {
     [key: string]: any;
 }
+export interface AfRabbitOptions {
+    reconnect: boolean;
+}
 declare class RabbitMq {
     static parseMsg(msg: any): any;
     static validateName(type: string, name: string): void;
-    static consumeOptions(options?: any): {
-        limit: number;
-        deadMessageTtl: number;
-    };
     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;
-    constructor();
+    options: AfRabbitOptions | undefined;
+    constructor(options?: AfRabbitOptions);
     ack: (msg: any) => Promise<void>;
-    nack: (queue: string, options?: Options.AssertQueue | undefined) => (msg: any, retries: number) => Promise<void>;
+    nack: (queue: string, options: any, deadQueueOptions: Options.AssertQueue) => (msg: any) => Promise<void>;
     getConnection(): Promise<AmqpConnectionManager>;
     assertChannel(): Promise<ChannelWrapper>;
     assertExchange(exchangeName: string, options?: any): Promise<any>;
@@ -32,6 +33,6 @@ declare class RabbitMq {
     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): Promise<void>;
+    sendToQueue(queue: string, content: any, options?: any): Promise<void>;
 }
 export default RabbitMq;

package/dist/index.js

@@ -38,28 +38,35 @@ 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 connectionCreatedConst = 'connectionCreated';
 class RabbitMq {
-    constructor() {
+    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 = (msg) => __awaiter(this, void 0, void 0, function* () {
             if (this.channel) {
                 yield this.channel.ack(msg);
             }
         });
-        this.nack = (queue, options) => (msg, retries) => __awaiter(this, void 0, void 0, function* () {
+        this.nack = (queue, options, deadQueueOptions) => (msg) => __awaiter(this, void 0, void 0, function* () {
             if (this.channel) {
-                if (!msg.content['x-retry-count'] || msg.content['x-retry-count'] <= retries) {
+                if (!msg.content['x-retry-count'] || msg.content['x-retry-count'] < options.retries) {
                     msg.content['x-retry-count'] = msg.content['x-retry-count'] ? msg.content['x-retry-count'] + 1 : 1;
                     yield this.sendToQueue(queue, msg.content);
                 }
                 else {
                     const deadQueue = `${queue}-dead`;
-                    yield this.assertQueue(deadQueue, options);
-                    yield this.sendToQueue(deadQueue, msg.content);
+                    yield this.assertQueue(deadQueue, deadQueueOptions);
+                    yield this.sendToQueue(deadQueue, msg.content, deadQueueOptions);
                 }
                 yield this.channel.ack(msg);
             }
@@ -69,6 +76,7 @@ class RabbitMq {
         this.connection = null;
         this.creatingConnection = false;
         this.exchanges = {};
+        this.options = options;
     }
     static parseMsg(msg) {
         let { content } = msg;
@@ -84,9 +92,6 @@ class RabbitMq {
             throw new rabbitError_1.default(`error while using ${type} with no name`);
         }
     }
-    static consumeOptions(options) {
-        return Object.assign({ limit: 1, deadMessageTtl: null }, options);
-    }
     getConnection() {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
@@ -101,7 +106,16 @@ class RabbitMq {
                 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.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);
@@ -164,8 +178,9 @@ class RabbitMq {
     }
     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 } = RabbitMq.consumeOptions(options);
+            const { limit, deadMessageTtl } = optionsWithDefaults;
             const channel = yield this.assertChannel();
             return channel.addSetup((c) => __awaiter(this, void 0, void 0, function* () {
                 yield c.assertQueue(queue);
@@ -173,7 +188,7 @@ class RabbitMq {
                 return Promise.all([
                     c.consume(queue, (msg) => {
                         outbreak_1.newTrace(outbreak_1.traceTypes.RABBIT);
-                        callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, { messageTtl: deadMessageTtl }));
+                        callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
                     }),
                 ]);
             }));
@@ -181,9 +196,10 @@ class RabbitMq {
     }
     consumeFromExchange(queue, exchange, callback, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            RabbitMq.validateName('queue', queue);
+            const optionsWithDefaults = Object.assign(Object.assign({}, defaultOptions), options);
             RabbitMq.validateName('exchange', exchange);
-            const { limit, deadMessageTtl } = RabbitMq.consumeOptions(options);
+            RabbitMq.validateName('queue', queue);
+            const { limit, deadMessageTtl } = optionsWithDefaults;
             const channel = yield this.assertChannel();
             return channel.addSetup((c) => __awaiter(this, void 0, void 0, function* () {
                 const assertExchange = yield assertExchangeFanout(c, exchange);
@@ -194,7 +210,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, { messageTtl: deadMessageTtl }));
+                        callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
                     }),
                 ]);
             }));
@@ -211,11 +227,11 @@ class RabbitMq {
             })).timeout(this.PUBLISH_TIMEOUT, `${this.PUBLISH_ERROR_MSG}${exchange}`);
         });
     }
-    sendToQueue(queue, content) {
+    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);
+            yield this.assertQueue(queue, options);
             return channel.sendToQueue(queue, Buffer.from(JSON.stringify(content)));
         });
     }

package/dist/index.test.js

@@ -16,30 +16,48 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const index_1 = __importDefault(require("./index"));
 jest.setTimeout(120000);
 const rabbit = new index_1.default();
-const delay = () => new Promise((resolve) => setTimeout(() => resolve(), 500));
+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 = () => (msg, ack, nack) => {
+    console.log('msg', msg.content);
+    expect(msg.content.ttt).toEqual('hey-q');
+    nack(msg);
+};
 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);
+        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 callback = (msg, ack) => {
-            expect(msg.content).toEqual('hey-q');
-            ack(msg);
-        };
-        const mockFn = jest.fn(callback);
+        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 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 {
@@ -76,10 +94,7 @@ describe('RabbitMQ', () => {
         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 rabbit.consumeFromExchange(queueName, exchangeName, callback());
         yield delay();
         ({ messageCount } = yield rabbit.getQueueLength(queueName));
         expect(messageCount).toEqual(0);

package/package.json

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

package/src/index.test.ts

@@ -5,15 +5,22 @@ jest.setTimeout(120000);
 
 const rabbit = new RabbitMq();
 
-const delay = () => new Promise((resolve) => setTimeout(() => resolve(), 500));
+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 = () => (msg: any, ack: any, nack: any) => {
+  console.log('msg', msg.content);
+  expect(msg.content.ttt).toEqual('hey-q');
+  nack(msg);
+};
 
 describe('RabbitMQ', () => {
   it('check exchange', async () => {
-    const callback = (msg: any, ack: any) => {
-      expect(msg.content).toEqual('hey');
-      ack(msg);
-    };
-    const mockFn = jest.fn(callback);
+    const mockFn = jest.fn(callback());
     await rabbit.consumeFromExchange('test-q2', 'test-e', mockFn);
     await rabbit.publish('test-e', 'hey');
     await delay();
@@ -21,17 +28,32 @@ describe('RabbitMQ', () => {
   });
 
   it('check queue', async () => {
-    const callback = (msg: any, ack: any) => {
-      expect(msg.content).toEqual('hey-q');
-      ack(msg);
-    };
-    const mockFn = jest.fn(callback);
+    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 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 {
@@ -71,10 +93,7 @@ describe('RabbitMQ', () => {
     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 rabbit.consumeFromExchange(queueName, exchangeName, callback());
     await delay();
     ({ messageCount } = await rabbit.getQueueLength(queueName));
     expect(messageCount).toEqual(0);

package/src/index.ts

@@ -11,6 +11,18 @@ interface ExchangesCache {
   [key: string]: any
 }
 
+export interface AfRabbitOptions {
+  reconnect: boolean
+}
+
+const DEFAULT_DEAD_TTL_TWO_DAYS = 60000 * 60 * 48;
+
+const defaultOptions = {
+  limit: 1,
+  retries: 1,
+  deadMessageTtl: DEFAULT_DEAD_TTL_TWO_DAYS,
+};
+
 const assertExchangeFanout = (c: any, exchangeName: string) => c.assertExchange(exchangeName, 'fanout');
 
 const connectionCreatedConst = 'connectionCreated';
@@ -35,20 +47,14 @@ class RabbitMq {
     }
   }
 
-  static consumeOptions(options?: any): {limit: number, deadMessageTtl: number} {
-    return {
-      limit: 1,
-      deadMessageTtl: null,
-      ...options,
-    };
-  }
-
   PUBLISH_TIMEOUT = Number(process.env.RABBITMQ_PUBLISH_TIMEOUT) || 60000;
 
   PUBLISH_ERROR_MSG = `rabbit: publish timeout(${this.PUBLISH_TIMEOUT}ms) has pass, exchange: `;
 
   DISCONNECT_MSG = 'rabbit: connection disconnect';
 
+  RESCONNECT_MSG = 'rabbit: reconnecting';
+
   channel: ChannelWrapper | null;
 
   connection: AmqpConnectionManager | null;
@@ -59,12 +65,15 @@ class RabbitMq {
 
   exchanges: ExchangesCache;
 
-  constructor() {
+  options: AfRabbitOptions | undefined;
+
+  constructor(options?: AfRabbitOptions) {
     this.em = new EventEmitter();
     this.channel = null;
     this.connection = null;
     this.creatingConnection = false;
     this.exchanges = {};
+    this.options = options;
   }
 
   public ack = async (msg: any) => {
@@ -73,15 +82,15 @@ class RabbitMq {
     }
   }
 
-  public nack = (queue: string, options?: Options.AssertQueue) => async (msg: any, retries: number) => {
+  public nack = (queue: string, options: any, deadQueueOptions: Options.AssertQueue) => async (msg: any) => {
     if (this.channel) {
-      if (!msg.content['x-retry-count'] || msg.content['x-retry-count'] <= retries) {
+      if (!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;
         await this.sendToQueue(queue, msg.content);
       } else {
         const deadQueue = `${queue}-dead`;
-        await this.assertQueue(deadQueue, options);
-        await this.sendToQueue(deadQueue, msg.content);
+        await this.assertQueue(deadQueue, deadQueueOptions);
+        await this.sendToQueue(deadQueue, msg.content, deadQueueOptions);
       }
       await this.channel.ack(msg);
     }
@@ -101,7 +110,14 @@ class RabbitMq {
       const connection: AmqpConnectionManager = await connect([`amqp://${host}`]);
       this.connection = connection;
       this.connection.on('disconnect',
-        ({ err }) => console.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`));
+        ({ err }) => {
+          if (this.options?.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);
@@ -159,8 +175,9 @@ class RabbitMq {
   }
 
   async consume(queue: string, callback: (msg: any, ack: Function, nack: Function) => any, options?: any) {
+    const optionsWithDefaults = { ...defaultOptions, ...options };
     RabbitMq.validateName('queue', queue);
-    const { limit, deadMessageTtl } = RabbitMq.consumeOptions(options);
+    const { limit, deadMessageTtl } = optionsWithDefaults;
     const channel: ChannelWrapper = await this.assertChannel();
     return channel.addSetup(async (c: ConfirmChannel) => {
       await c.assertQueue(queue);
@@ -170,7 +187,7 @@ class RabbitMq {
           queue,
           (msg: any) => {
             newTrace(traceTypes.RABBIT);
-            callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, { messageTtl: deadMessageTtl }));
+            callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
           },
         ),
       ]);
@@ -178,9 +195,10 @@ class RabbitMq {
   }
 
   async consumeFromExchange(queue: string, exchange: string, callback: (msg: any, ack: Function, nack: Function) => any, options?: any) {
-    RabbitMq.validateName('queue', queue);
+    const optionsWithDefaults = { ...defaultOptions, ...options };
     RabbitMq.validateName('exchange', exchange);
-    const { limit, deadMessageTtl } = RabbitMq.consumeOptions(options);
+    RabbitMq.validateName('queue', queue);
+    const { limit, deadMessageTtl } = optionsWithDefaults;
     const channel: ChannelWrapper = await this.assertChannel();
 
     return channel.addSetup(async (c: ConfirmChannel) => {
@@ -194,7 +212,7 @@ class RabbitMq {
           queue,
           (msg: any) => {
             newTrace(traceTypes.RABBIT);
-            callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, { messageTtl: deadMessageTtl }));
+            callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
           },
         ),
       ]);
@@ -211,10 +229,10 @@ class RabbitMq {
     }).timeout(this.PUBLISH_TIMEOUT, `${this.PUBLISH_ERROR_MSG}${exchange}`);
   }
 
-  async sendToQueue(queue: string, content: any) {
+  async sendToQueue(queue: string, content: any, options?: any) {
     RabbitMq.validateName('queue', queue);
     const channel: ChannelWrapper = await this.assertChannel();
-    await this.assertQueue(queue);
+    await this.assertQueue(queue, options);
     return channel.sendToQueue(queue, Buffer.from(JSON.stringify(content)));
   }
 }