@autofleet/rabbit 1.0.6 → 1.0.8

package/dist/index.d.ts

@@ -7,12 +7,13 @@ declare class RabbitMq {
     creatingChannel: boolean;
     static parseMsg(msg: any): any;
     constructor();
-    ack: (msg: any) => void;
+    ack: (msg: any) => Promise<void>;
+    nack: (msg: any, queue: string, deadQueue: string, retries: number) => Promise<void>;
     assertChannel(): Promise<Channel>;
     assertExchange(exchange: string, options?: any): Promise<import("amqplib").Replies.AssertExchange>;
     assertQueue(queue: string, options?: any): Promise<import("amqplib").Replies.AssertQueue>;
-    consume(queue: string, callback: (msg: any, ack: Function) => any): Promise<import("amqplib").Replies.Consume>;
-    consumeFromExchange(queue: string, exchange: string, callback: (msg: any, ack: Function) => any): Promise<import("amqplib").Replies.Consume>;
+    consume(queue: string, callback: (msg: any, ack: Function, nack: Function) => any): Promise<import("amqplib").Replies.Consume>;
+    consumeFromExchange(queue: string, exchange: string, callback: (msg: any, ack: Function, nack: Function) => any): Promise<import("amqplib").Replies.Consume>;
     publish(exchange: string, content: any): Promise<boolean>;
     sendToQueue(queue: string, content: any): Promise<boolean>;
 }

package/dist/index.js

@@ -5,9 +5,21 @@ const events_1 = require("events");
 const channelCreatedConst = 'channelCreated';
 class RabbitMq {
     constructor() {
-        this.ack = (msg) => {
+        this.ack = async (msg) => {
             if (this.channel) {
-                this.channel.ack(msg);
+                await this.channel.ack(msg);
+            }
+        };
+        this.nack = async (msg, queue, deadQueue, retries) => {
+            if (this.channel) {
+                await this.channel.ack(msg);
+                if (!msg.content['x-retry-count'] || msg.content['x-retry-count'] <= retries) {
+                    msg.content['x-retry-count'] = msg.content['x-retry-count'] ? msg.content['x-retry-count'] + 1 : 1;
+                    await this.sendToQueue(queue, Buffer.from(JSON.stringify(msg.content)));
+                }
+                else {
+                    await this.sendToQueue(deadQueue, Buffer.from(JSON.stringify(msg.content)));
+                }
             }
         };
         this.creatingChannel = false;
@@ -64,7 +76,7 @@ class RabbitMq {
     async consume(queue, callback) {
         const channel = await this.assertChannel();
         await this.assertQueue(queue);
-        return channel.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack));
+        return channel.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack, this.nack));
     }
     async consumeFromExchange(queue, exchange, callback) {
         const channel = await this.assertChannel();
@@ -73,17 +85,17 @@ class RabbitMq {
             this.assertQueue(queue),
         ]);
         await channel.bindQueue(queue, exchange, '');
-        return channel.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack));
+        return channel.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack, this.nack));
     }
     async publish(exchange, content) {
         const channel = await this.assertChannel();
         await this.assertExchange(exchange);
-        return channel.publish(exchange, '', Buffer.from(content));
+        return channel.publish(exchange, '', Buffer.from(JSON.stringify(content)));
     }
     async sendToQueue(queue, content) {
         const channel = await this.assertChannel();
         await this.assertQueue(queue);
-        return channel.sendToQueue(queue, Buffer.from(content));
+        return channel.sendToQueue(queue, Buffer.from(JSON.stringify(content)));
     }
 }
 exports.default = RabbitMq;

package/package.json

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

package/src/index.ts

@@ -35,9 +35,21 @@ class RabbitMq {
     });
   }
 
-  public ack = (msg: any) => {
+  public ack = async (msg: any) => {
     if (this.channel) {
-      this.channel.ack(msg);
+      await this.channel.ack(msg);
+    }
+  }
+
+  public nack = async (msg: any, queue: string, deadQueue: string, retries: number) => {
+    if (this.channel) {
+      await this.channel.ack(msg);
+      if (!msg.content['x-retry-count'] || msg.content['x-retry-count'] <= retries) {
+        msg.content['x-retry-count'] = msg.content['x-retry-count'] ? msg.content['x-retry-count'] + 1 : 1;
+        await this.sendToQueue(queue, Buffer.from(JSON.stringify(msg.content)));
+      } else {
+        await this.sendToQueue(deadQueue, Buffer.from(JSON.stringify(msg.content)));
+      }
     }
   }
 
@@ -76,32 +88,32 @@ class RabbitMq {
     return channel.assertQueue(queue);
   }
 
-  async consume(queue: string, callback: (msg: any, ack: Function) => any) {
+  async consume(queue: string, callback: (msg: any, ack: Function, nack: Function) => any) {
     const channel: Channel = await this.assertChannel();
     await this.assertQueue(queue);
-    return channel.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack));
+    return channel.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack, this.nack));
   }
 
-  async consumeFromExchange(queue: string, exchange: string, callback: (msg: any, ack: Function) => any) {
+  async consumeFromExchange(queue: string, exchange: string, callback: (msg: any, ack: Function, nack: Function) => any) {
     const channel: Channel = await this.assertChannel();
     await Promise.all([
       this.assertExchange(exchange),
       this.assertQueue(queue),
     ]);
     await channel.bindQueue(queue, exchange, '');
-    return channel.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack));
+    return channel.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack, this.nack));
   }
 
   async publish(exchange: string, content: any) {
     const channel: Channel = await this.assertChannel();
     await this.assertExchange(exchange);
-    return channel.publish(exchange, '', Buffer.from(content));
+    return channel.publish(exchange, '', Buffer.from(JSON.stringify(content)));
   }
 
   async sendToQueue(queue: string, content: any) {
     const channel: Channel = await this.assertChannel();
     await this.assertQueue(queue);
-    return channel.sendToQueue(queue, Buffer.from(content));
+    return channel.sendToQueue(queue, Buffer.from(JSON.stringify(content)));
   }
 }