@autofleet/rabbit 1.6.0 → 1.6.2

package/dist/index.d.ts

@@ -11,10 +11,6 @@ export interface AfRabbitOptions {
 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;
@@ -27,7 +23,7 @@ declare class RabbitMq {
     options: AfRabbitOptions | undefined;
     constructor(options?: AfRabbitOptions);
     ack: (msg: any) => Promise<void>;
-    nack: (queue: string, deadQueueOptions?: Options.AssertQueue | undefined) => (msg: any, retries: number) => Promise<void>;
+    nack: (queue: string, options: any, deadQueueOptions: Options.AssertQueue) => (msg: any, { skipRetry, }?: any) => Promise<void>;
     getConnection(): Promise<AmqpConnectionManager>;
     assertChannel(): Promise<ChannelWrapper>;
     assertExchange(exchangeName: string, options?: any): Promise<any>;

package/dist/index.js

@@ -38,6 +38,12 @@ 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 {
@@ -51,9 +57,11 @@ class RabbitMq {
                 yield this.channel.ack(msg);
             }
         });
-        this.nack = (queue, deadQueueOptions) => (msg, retries) => __awaiter(this, void 0, void 0, function* () {
+        this.nack = (queue, options, deadQueueOptions) => (msg, { skipRetry = false, } = {}) => __awaiter(this, void 0, void 0, function* () {
             if (this.channel) {
-                if (!msg.content['x-retry-count'] || msg.content['x-retry-count'] <= retries) {
+                if (!skipRetry
+                    && (!msg.content['x-retry-count']
+                        || msg.content['x-retry-count'] < options.retries)) {
                     msg.content['x-retry-count'] = msg.content['x-retry-count'] ? msg.content['x-retry-count'] + 1 : 1;
                     yield this.sendToQueue(queue, msg.content);
                 }
@@ -86,9 +94,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* () {
@@ -175,18 +180,17 @@ 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);
                 yield c.prefetch(limit, true);
                 return Promise.all([
                     c.consume(queue, (msg) => {
-                        setImmediate(() => {
-                            outbreak_1.newTrace(outbreak_1.traceTypes.RABBIT);
-                            callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, { messageTtl: deadMessageTtl }));
-                        });
+                        outbreak_1.newTrace(outbreak_1.traceTypes.RABBIT);
+                        callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
                     }),
                 ]);
             }));
@@ -194,9 +198,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);
@@ -206,10 +211,8 @@ class RabbitMq {
                 return Promise.all([
                     c.bindQueue(queue, exchange, ''),
                     c.consume(queue, (msg) => {
-                        setImmediate(() => {
-                            outbreak_1.newTrace(outbreak_1.traceTypes.RABBIT);
-                            callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, { messageTtl: deadMessageTtl }));
-                        });
+                        outbreak_1.newTrace(outbreak_1.traceTypes.RABBIT);
+                        callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
                     }),
                 ]);
             }));

package/dist/index.test.js

@@ -16,30 +16,60 @@ 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 = ({ 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 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 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 {
@@ -76,10 +106,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.6.0",
+  "version": "1.6.2",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/index.test.ts

@@ -5,15 +5,26 @@ 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 = ({ 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 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 +32,40 @@ 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 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 {
@@ -71,10 +105,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

@@ -15,6 +15,14 @@ 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';
@@ -39,14 +47,6 @@ 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: `;
@@ -82,9 +82,22 @@ class RabbitMq {
     }
   }
 
-  public nack = (queue: string, deadQueueOptions?: Options.AssertQueue) => async (msg: any, retries: number) => {
+  public nack = (
+    queue: string,
+    options: any,
+    deadQueueOptions: Options.AssertQueue,
+  ) => async (
+    msg: any,
+    {
+      skipRetry = false,
+    }: any = { },
+  ) => {
     if (this.channel) {
-      if (!msg.content['x-retry-count'] || msg.content['x-retry-count'] <= retries) {
+      if (
+        !skipRetry
+        && (!msg.content['x-retry-count']
+        || msg.content['x-retry-count'] < options.retries)
+      ) {
         msg.content['x-retry-count'] = msg.content['x-retry-count'] ? msg.content['x-retry-count'] + 1 : 1;
         await this.sendToQueue(queue, msg.content);
       } else {
@@ -175,8 +188,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);
@@ -185,10 +199,8 @@ class RabbitMq {
         c.consume(
           queue,
           (msg: any) => {
-            setImmediate(() => {
-              newTrace(traceTypes.RABBIT);
-              callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, { messageTtl: deadMessageTtl }));
-            })
+            newTrace(traceTypes.RABBIT);
+            callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
           },
         ),
       ]);
@@ -196,9 +208,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) => {
@@ -211,10 +224,8 @@ class RabbitMq {
         c.consume(
           queue,
           (msg: any) => {
-            setImmediate(() => {
-              newTrace(traceTypes.RABBIT);
-              callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, { messageTtl: deadMessageTtl }));
-            })
+            newTrace(traceTypes.RABBIT);
+            callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
           },
         ),
       ]);