@autofleet/rabbit 1.0.13 → 1.0.15

package/dist/index.d.ts

@@ -1,20 +1,20 @@
 /// <reference types="node" />
-import { Channel } from 'amqplib';
+import { AmqpConnectionManager, ChannelWrapper } from 'amqp-connection-manager';
 import { EventEmitter } from 'events';
 declare class RabbitMq {
-    channel: Channel | null;
+    channel: ChannelWrapper | null;
+    connection: AmqpConnectionManager | null;
     em: EventEmitter;
-    creatingChannel: boolean;
-    static parseMsg(msg: any): any;
     constructor();
     ack: (msg: any) => Promise<void>;
     nack: (queue: string) => (msg: any, 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, nack: Function) => any, options?: any): Promise<import("amqplib").Replies.Consume>;
-    consumeFromExchange(queue: string, exchange: string, callback: (msg: any, ack: Function, nack: Function) => any, options?: any): Promise<import("amqplib").Replies.Consume>;
-    publish(exchange: string, content: any): Promise<boolean>;
-    sendToQueue(queue: string, content: any): Promise<boolean>;
+    getConnection(): Promise<AmqpConnectionManager>;
+    assertChannel(): Promise<ChannelWrapper>;
+    assertExchange(exchange: string, options?: any): Promise<void>;
+    assertQueue(queue: string, options?: any): Promise<void>;
+    consume(queue: string, callback: (msg: any, ack: Function, nack: Function) => any, options?: any, isFirstTime?: boolean): Promise<void>;
+    consumeFromExchange(queue: string, exchange: string, callback: (msg: any, ack: Function, nack: Function) => any, options?: any, isFirstTime?: boolean): Promise<void>;
+    publish(exchange: string, content: any): Promise<void>;
+    sendToQueue(queue: string, content: any): Promise<void>;
 }
 export default RabbitMq;

package/dist/index.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const amqplib_1 = require("amqplib");
+const amqp_connection_manager_1 = require("amqp-connection-manager");
 const events_1 = require("events");
-const channelCreatedConst = 'channelCreated';
 class RabbitMq {
     constructor() {
         this.ack = async (msg) => {
@@ -24,9 +23,9 @@ class RabbitMq {
                 await this.channel.ack(msg);
             }
         };
-        this.creatingChannel = false;
         this.em = new events_1.EventEmitter;
         this.channel = null;
+        this.connection = null;
         process.once('SIGINT', () => {
             console.log('Removing channel');
             if (this.channel) {
@@ -34,41 +33,29 @@ class RabbitMq {
             }
         });
     }
-    static parseMsg(msg) {
-        let { content } = msg;
-        content = content.toString();
-        try {
-            content = JSON.parse(content);
+    async getConnection() {
+        if (this.connection !== null) {
+            return this.connection;
         }
-        catch (e) { }
-        return Object.assign({}, msg, { content });
+        let host = process.env.RABBITMQ_SERVICE_HOST || '35.240.13.28';
+        let connection = await amqp_connection_manager_1.connect([`amqp://${host}`]);
+        this.connection = connection;
+        return connection;
     }
     async assertChannel() {
         return new Promise(async (resolve, reject) => {
             if (this.channel) {
                 return resolve(this.channel);
             }
-            if (this.creatingChannel) {
-                return this.em.on(channelCreatedConst, resolve);
-            }
-            this.creatingChannel = true;
-            let connection, channel;
-            let host = process.env.RABBITMQ_SERVICE_HOST || '35.240.13.28';
+            let connection = await this.getConnection();
             try {
-                connection = await amqplib_1.connect(`amqp://${host}`);
-                channel = await connection.createChannel();
-                this.channel = channel;
-                channel.on('close', async () => {
-                    this.channel = null;
-                    await this.assertChannel();
-                });
-                connection.on('close', async () => {
-                    this.channel = null;
-                    await this.assertChannel();
-                });
-                this.creatingChannel = false;
-                this.em.emit(channelCreatedConst, channel);
-                resolve(channel);
+                connection = await this.getConnection();
+                if (this.channel === null) {
+                    this.channel = connection.createChannel({
+                        json: true,
+                    });
+                }
+                resolve(this.channel);
             }
             catch (e) {
                 reject(e);
@@ -77,39 +64,51 @@ class RabbitMq {
     }
     async assertExchange(exchange, options) {
         const channel = await this.assertChannel();
-        return channel.assertExchange(exchange, 'fanout');
+        return channel.addSetup((c) => c.assertExchange(exchange, 'fanout'));
     }
     async assertQueue(queue, options) {
         const channel = await this.assertChannel();
-        return channel.assertQueue(queue);
+        return channel.addSetup((c) => c.assertQueue(queue));
     }
-    async consume(queue, callback, options) {
+    async consume(queue, callback, options, isFirstTime = true) {
         const { limit } = options ? options : 1;
         const channel = await this.assertChannel();
         await this.assertQueue(queue);
-        channel.prefetch(limit, false);
-        return channel.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue)));
+        if (!isFirstTime) {
+            return channel.addSetup((c) => {
+                return Promise.all([
+                    c.prefetch(limit, false),
+                    c.consume(queue, (msg) => callback(msg, this.ack, this.nack(queue))),
+                ]);
+            });
+        }
     }
-    async consumeFromExchange(queue, exchange, callback, options) {
+    async consumeFromExchange(queue, exchange, callback, options, isFirstTime = true) {
         const { limit } = options ? options : 1;
         const channel = await this.assertChannel();
         await Promise.all([
             this.assertExchange(exchange),
             this.assertQueue(queue),
         ]);
-        channel.prefetch(limit, false);
-        await channel.bindQueue(queue, exchange, '');
-        return channel.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue)));
+        if (!isFirstTime) {
+            return channel.addSetup((c) => {
+                return Promise.all([
+                    c.prefetch(limit, false),
+                    c.bindQueue(queue, exchange, ''),
+                    c.consume(queue, (msg) => callback(msg, this.ack, this.nack(queue))),
+                ]);
+            });
+        }
     }
     async publish(exchange, content) {
         const channel = await this.assertChannel();
         await this.assertExchange(exchange);
-        return channel.publish(exchange, '', Buffer.from(JSON.stringify(content)));
+        return channel.publish(exchange, '', Buffer.from(content));
     }
     async sendToQueue(queue, content) {
         const channel = await this.assertChannel();
         await this.assertQueue(queue);
-        return channel.sendToQueue(queue, Buffer.from(JSON.stringify(content)));
+        return channel.sendToQueue(queue, Buffer.from(content));
     }
 }
 exports.default = RabbitMq;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -10,8 +10,10 @@
     "dev": "nodemon"
   },
   "dependencies": {
+    "@types/amqp-connection-manager": "^2.0.2",
     "@types/amqplib": "^0.5.9",
     "@types/jest": "^23.3.10",
+    "amqp-connection-manager": "^2.3.0",
     "amqplib": "^0.5.3",
     "jest": "^23.6.0"
   },

package/src/index.ts

@@ -1,31 +1,16 @@
-import { connect, Connection, Channel } from 'amqplib';
+import { ConfirmChannel } from 'amqplib';
+import { connect, AmqpConnectionManager, ChannelWrapper } from 'amqp-connection-manager';
 import { EventEmitter } from 'events';
 
-const channelCreatedConst: string = 'channelCreated';
 class RabbitMq {
-  channel: Channel | null;
+  channel: ChannelWrapper | null;
+  connection: AmqpConnectionManager | null;
   em: EventEmitter;
-  creatingChannel: boolean;
-
-  static parseMsg(msg: any) {
-    let { content } = msg;
-    content = content.toString();
-
-    try {
-      content = JSON.parse(content);
-    } catch(e) { }
-
-    return {
-      ...msg,
-      content,
-    }
-  }
 
   constructor() {
-    this.creatingChannel = false;
     this.em = new EventEmitter;
     this.channel = null;
-
+    this.connection = null;
     process.once('SIGINT', () => {
       console.log('Removing channel');
       if(this.channel) {
@@ -54,33 +39,33 @@ class RabbitMq {
     }
   }
 
+  async getConnection() {
+    if (this.connection !== null) {
+      return this.connection;
+    }
+
+    let host: string = process.env.RABBITMQ_SERVICE_HOST || '35.240.13.28';
+    let connection: AmqpConnectionManager = await connect([`amqp://${host}`]);
+    this.connection = connection;
+    return connection;
+  }
+
   async assertChannel() {
-    return new Promise<Channel>(async (resolve, reject) => {
+    return new Promise<ChannelWrapper>(async (resolve, reject) => {
       if(this.channel) {
         return resolve(this.channel);
-      } if (this.creatingChannel) {
-        return this.em.on(channelCreatedConst, resolve);
       }
 
-      this.creatingChannel = true;
-      let connection: Connection, channel: Channel;
-      let host: string = process.env.RABBITMQ_SERVICE_HOST || '35.240.13.28';
+      let connection: AmqpConnectionManager = await this.getConnection();
 
       try {
-        connection = await connect(`amqp://${host}`);
-        channel = await connection.createChannel();
-        this.channel = channel;
-        channel.on('close', async () => {
-          this.channel = null;
-          await this.assertChannel();
-        });
-        connection.on('close', async () => {
-          this.channel = null;
-          await this.assertChannel();
-        });
-        this.creatingChannel = false;
-        this.em.emit(channelCreatedConst, channel);
-        resolve(channel);
+        connection = await this.getConnection();
+        if (this.channel === null) {
+          this.channel = connection.createChannel({
+            json: true,
+          });
+        }
+        resolve(this.channel);
       } catch (e) {
         reject(e)
       }
@@ -88,45 +73,57 @@ class RabbitMq {
   }
 
   async assertExchange(exchange: string, options?: any) {
-    const channel: Channel = await this.assertChannel();
-    return channel.assertExchange(exchange, 'fanout')
+    const channel: ChannelWrapper = await this.assertChannel();
+    return channel.addSetup((c: ConfirmChannel) => c.assertExchange(exchange, 'fanout'));
   }
 
   async assertQueue(queue: string, options?: any) {
-    const channel: Channel = await this.assertChannel();
-    return channel.assertQueue(queue);
+    const channel: ChannelWrapper = await this.assertChannel();
+    return channel.addSetup((c: ConfirmChannel) => c.assertQueue(queue));
   }
 
-  async consume(queue: string, callback: (msg: any, ack: Function, nack: Function) => any, options?: any) {
+  async consume(queue: string, callback: (msg: any, ack: Function, nack: Function) => any, options?: any, isFirstTime: boolean = true) {
     const { limit } = options ? options : 1;
-    const channel: Channel = await this.assertChannel();
+    const channel: ChannelWrapper = await this.assertChannel();
     await this.assertQueue(queue);
-    channel.prefetch(limit, false);
-    return channel.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue)));
+    if (!isFirstTime) {
+      return channel.addSetup((c: ConfirmChannel) => {
+        return Promise.all([
+          c.prefetch(limit, false),
+          c.consume(queue, (msg : any) => callback(msg, this.ack, this.nack(queue))),
+        ]);
+      });
+    }
   }
 
-  async consumeFromExchange(queue: string, exchange: string, callback: (msg: any, ack: Function, nack: Function) => any, options?: any) {
+  async consumeFromExchange(queue: string, exchange: string, callback: (msg: any, ack: Function, nack: Function) => any, options?: any, isFirstTime: boolean = true) {
     const { limit } = options ? options : 1;
-    const channel: Channel = await this.assertChannel();
+    const channel: ChannelWrapper = await this.assertChannel();
     await Promise.all([
       this.assertExchange(exchange),
       this.assertQueue(queue),
     ]);
-    channel.prefetch(limit, false);
-    await channel.bindQueue(queue, exchange, '');
-    return channel.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack, this.nack(queue)));
+    if (!isFirstTime) {
+      return channel.addSetup((c: ConfirmChannel) => {
+        return Promise.all([
+          c.prefetch(limit, false),
+          c.bindQueue(queue, exchange, ''),
+          c.consume(queue, (msg : any) => callback(msg, this.ack, this.nack(queue))),
+        ])
+      })
+    }
   }
 
   async publish(exchange: string, content: any) {
-    const channel: Channel = await this.assertChannel();
+    const channel: ChannelWrapper = await this.assertChannel();
     await this.assertExchange(exchange);
-    return channel.publish(exchange, '', Buffer.from(JSON.stringify(content)));
+    return channel.publish(exchange, '', Buffer.from(content));
   }
 
   async sendToQueue(queue: string, content: any) {
-    const channel: Channel = await this.assertChannel();
+    const channel: ChannelWrapper = await this.assertChannel();
     await this.assertQueue(queue);
-    return channel.sendToQueue(queue, Buffer.from(JSON.stringify(content)));
+    return channel.sendToQueue(queue, Buffer.from(content));
   }
 }