@autofleet/rabbit 1.0.1 → 1.0.2

package/dist/example.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_1 = require("./index");
 const init = () => __awaiter(this, void 0, void 0, function* () {
-    const rabbit = yield index_1.default.init();
+    const rabbit = new index_1.default();
     yield rabbit.consumeFromExchange('test-q2', 'test-e', (msg, ack) => {
         console.log('msg2', msg.content);
         // ack(msg);

package/dist/index.d.ts

@@ -1,10 +1,14 @@
+/// <reference types="node" />
 import { Channel } from 'amqplib';
+import { EventEmitter } from 'events';
 declare class RabbitMq {
-    channel: Channel;
-    static init(): Promise<RabbitMq>;
+    channel: Channel | null;
+    em: EventEmitter;
+    creatingChannel: boolean;
     static parseMsg(msg: any): any;
-    constructor(channel: Channel);
+    constructor();
     ack: (msg: any) => 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>;

package/dist/index.js

@@ -9,29 +9,23 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const amqplib_1 = require("amqplib");
+const events_1 = require("events");
+const channelCreatedConst = 'channelCreated';
 class RabbitMq {
-    constructor(channel) {
+    constructor() {
         this.ack = (msg) => {
-            this.channel.ack(msg);
-        };
-        this.channel = channel;
-    }
-    static init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let connection, channel;
-            let host = process.env.RABBITMQ_SERVICE_HOST || '104.155.17.91';
-            try {
-                connection = yield amqplib_1.connect(`amqp://${host}`);
-                channel = yield connection.createChannel();
+            if (this.channel) {
+                this.channel.ack(msg);
             }
-            catch (e) {
-                throw e;
+        };
+        this.creatingChannel = false;
+        this.em = new events_1.EventEmitter;
+        this.channel = null;
+        process.once('SIGINT', () => {
+            console.log('Removing channel');
+            if (this.channel) {
+                this.channel.close();
             }
-            process.once('SIGINT', function () {
-                console.log('Removing channel');
-                channel.close();
-            });
-            return new RabbitMq(channel);
         });
     }
     static parseMsg(msg) {
@@ -43,40 +37,72 @@ class RabbitMq {
         catch (e) { }
         return Object.assign({}, msg, { content });
     }
+    assertChannel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                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';
+                try {
+                    connection = yield amqplib_1.connect(`amqp://${host}`);
+                    channel = yield connection.createChannel();
+                    this.channel = channel;
+                    this.creatingChannel = false;
+                    this.em.emit(channelCreatedConst, channel);
+                    resolve(channel);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            }));
+        });
+    }
     assertExchange(exchange, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.channel.assertExchange(exchange, 'fanout');
+            const channel = yield this.assertChannel();
+            return channel.assertExchange(exchange, 'fanout');
         });
     }
     assertQueue(queue, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.channel.assertQueue(queue);
+            const channel = yield this.assertChannel();
+            return channel.assertQueue(queue);
         });
     }
     consume(queue, callback) {
         return __awaiter(this, void 0, void 0, function* () {
+            const channel = yield this.assertChannel();
             yield this.assertQueue(queue);
-            return this.channel.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack));
+            return channel.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack));
         });
     }
     consumeFromExchange(queue, exchange, callback) {
         return __awaiter(this, void 0, void 0, function* () {
+            const channel = yield this.assertChannel();
             yield Promise.all([
                 this.assertExchange(exchange),
                 this.assertQueue(queue),
             ]);
-            yield this.channel.bindQueue(queue, exchange, '');
-            return this.channel.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack));
+            yield channel.bindQueue(queue, exchange, '');
+            return channel.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack));
         });
     }
     publish(exchange, content) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.channel.publish(exchange, '', Buffer.from(content));
+            const channel = yield this.assertChannel();
+            return channel.publish(exchange, '', Buffer.from(content));
         });
     }
     sendToQueue(queue, content) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.channel.sendToQueue(queue, Buffer.from(content));
+            const channel = yield this.assertChannel();
+            return channel.sendToQueue(queue, Buffer.from(content));
         });
     }
 }

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
     "start": "ts-node  src/index.ts",
+    "example": "ts-node  src/example.ts",
     "prepublish": "tsc",
     "dev": "nodemon"
   },

package/src/example.ts

@@ -1,7 +1,7 @@
 import RabbitMq from './index';
 
 const init = async () => {
-  const rabbit = await RabbitMq.init();
+  const rabbit = new RabbitMq();
   await rabbit.consumeFromExchange('test-q2', 'test-e', (msg, ack) => {
     console.log('msg2', msg.content);
     // ack(msg);

package/src/index.ts

@@ -1,24 +1,13 @@
 import { connect, Connection, Channel } from 'amqplib';
+import { EventEmitter } from 'events';
+import { reject } from 'bluebird';
 
+const channelCreatedConst: string = 'channelCreated';
 class RabbitMq {
-  channel: Channel;
+  channel: Channel | null;
+  em: EventEmitter;
+  creatingChannel: boolean;
 
-  static async init() {
-    let connection: Connection, channel: Channel;
-    let host: string = process.env.RABBITMQ_SERVICE_HOST || '104.155.17.91';
-    try {
-      connection = await connect(`amqp://${host}`);
-      channel = await connection.createChannel();
-    } catch(e) {
-      throw e;
-    }
-    process.once('SIGINT', function () {
-      console.log('Removing channel');
-      channel.close();
-    });
-
-    return new RabbitMq(channel);
-  }
   static parseMsg(msg: any) {
     let { content } = msg;
     content = content.toString();
@@ -33,42 +22,84 @@ class RabbitMq {
     }
   }
 
-  constructor(channel: Channel) {
-    this.channel = channel;
+  constructor() {
+    this.creatingChannel = false;
+    this.em = new EventEmitter;
+    this.channel = null;
+
+    process.once('SIGINT', () => {
+      console.log('Removing channel');
+      if(this.channel) {
+        this.channel.close();
+      }
+    });
   }
 
   public ack = (msg: any) => {
-    this.channel.ack(msg);
+    if (this.channel) {
+      this.channel.ack(msg);
+    }
+  }
+
+  async assertChannel() {
+    return new Promise<Channel>(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';
+
+      try {
+        connection = await connect(`amqp://${host}`);
+        channel = await connection.createChannel();
+        this.channel = channel;
+        this.creatingChannel = false;
+        this.em.emit(channelCreatedConst, channel);
+        resolve(channel);
+      } catch (e) {
+        reject(e)
+      }
+    })
   }
 
   async assertExchange(exchange: string, options?: any) {
-    return this.channel.assertExchange(exchange, 'fanout')
+    const channel: Channel = await this.assertChannel();
+    return channel.assertExchange(exchange, 'fanout')
   }
 
   async assertQueue(queue: string, options?: any) {
-    return this.channel.assertQueue(queue);
+    const channel: Channel = await this.assertChannel();
+    return channel.assertQueue(queue);
   }
 
   async consume(queue: string, callback: (msg: any, ack: Function) => any) {
+    const channel: Channel = await this.assertChannel();
     await this.assertQueue(queue);
-    return this.channel.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack));
+    return channel.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack));
   }
 
   async consumeFromExchange(queue: string, exchange: string, callback: (msg: any, ack: Function) => any) {
+    const channel: Channel = await this.assertChannel();
     await Promise.all([
       this.assertExchange(exchange),
       this.assertQueue(queue),
     ]);
-    await this.channel.bindQueue(queue, exchange, '');
-    return this.channel.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack));
+    await channel.bindQueue(queue, exchange, '');
+    return channel.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack));
   }
 
   async publish(exchange: string, content: any) {
-    return this.channel.publish(exchange, '', Buffer.from(content));
+    const channel: Channel = await this.assertChannel();
+    return channel.publish(exchange, '', Buffer.from(content));
   }
 
   async sendToQueue(queue: string, content: any) {
-    return this.channel.sendToQueue(queue, Buffer.from(content));
+    const channel: Channel = await this.assertChannel();
+    return channel.sendToQueue(queue, Buffer.from(content));
   }
 }