@autofleet/rabbit 1.0.1

package/dist/example.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/example.js

@@ -0,0 +1,30 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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();
+    yield rabbit.consumeFromExchange('test-q2', 'test-e', (msg, ack) => {
+        console.log('msg2', msg.content);
+        // ack(msg);
+    });
+    yield rabbit.consumeFromExchange('test-q', 'test-e', (msg, ack) => {
+        console.log('msg', msg.content);
+        ack(msg);
+    });
+    yield rabbit.publish('test-e', 'hey');
+    yield rabbit.publish('test-e', 'hey1');
+    yield rabbit.consume('test-q-2', (msg, ack) => {
+        console.log('msg-q', msg.content);
+        ack(msg);
+    });
+    yield rabbit.sendToQueue('test-q-2', 'hey-q');
+});
+init();

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import { Channel } from 'amqplib';
+declare class RabbitMq {
+    channel: Channel;
+    static init(): Promise<RabbitMq>;
+    static parseMsg(msg: any): any;
+    constructor(channel: Channel);
+    ack: (msg: any) => void;
+    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>;
+    publish(exchange: string, content: any): Promise<boolean>;
+    sendToQueue(queue: string, content: any): Promise<boolean>;
+}
+export default RabbitMq;

package/dist/index.js

@@ -0,0 +1,83 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const amqplib_1 = require("amqplib");
+class RabbitMq {
+    constructor(channel) {
+        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();
+            }
+            catch (e) {
+                throw e;
+            }
+            process.once('SIGINT', function () {
+                console.log('Removing channel');
+                channel.close();
+            });
+            return new RabbitMq(channel);
+        });
+    }
+    static parseMsg(msg) {
+        let { content } = msg;
+        content = content.toString();
+        try {
+            content = JSON.parse(content);
+        }
+        catch (e) { }
+        return Object.assign({}, msg, { content });
+    }
+    assertExchange(exchange, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.channel.assertExchange(exchange, 'fanout');
+        });
+    }
+    assertQueue(queue, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.channel.assertQueue(queue);
+        });
+    }
+    consume(queue, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.assertQueue(queue);
+            return this.channel.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack));
+        });
+    }
+    consumeFromExchange(queue, exchange, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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));
+        });
+    }
+    publish(exchange, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.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));
+        });
+    }
+}
+exports.default = RabbitMq;

package/nodemon.json

@@ -0,0 +1,13 @@
+{
+  "ignore": [
+    "**/*.test.ts",
+    "**/*.spec.ts",
+    ".git",
+    "node_modules"
+  ],
+  "watch": [
+    "src"
+  ],
+  "exec": "npm start",
+  "ext": "ts"
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@autofleet/rabbit",
+  "version": "1.0.1",
+  "description": "",
+  "main": "dist/index.js",
+  "scripts": {
+    "start": "ts-node  src/index.ts",
+    "prepublish": "tsc",
+    "dev": "nodemon"
+  },
+  "dependencies": {
+    "@types/amqplib": "^0.5.9",
+    "amqplib": "^0.5.3"
+  },
+  "devDependencies": {
+    "ts-node": "^7.0.1",
+    "typescript": "^3.2.1"
+  },
+  "author": "",
+  "license": "ISC"
+}

package/src/example.ts

@@ -0,0 +1,25 @@
+import RabbitMq from './index';
+
+const init = async () => {
+  const rabbit = await RabbitMq.init();
+  await rabbit.consumeFromExchange('test-q2', 'test-e', (msg, ack) => {
+    console.log('msg2', msg.content);
+    // ack(msg);
+  });
+
+  await rabbit.consumeFromExchange('test-q', 'test-e', (msg, ack) => {
+    console.log('msg', msg.content);
+    ack(msg);
+  });
+  await rabbit.publish('test-e', 'hey')
+  await rabbit.publish('test-e', 'hey1')
+
+
+  await rabbit.consume('test-q-2', (msg, ack) => {
+    console.log('msg-q', msg.content);
+    ack(msg);
+  });
+  await rabbit.sendToQueue('test-q-2', 'hey-q')
+}
+
+init();

package/src/index.ts

@@ -0,0 +1,75 @@
+import { connect, Connection, Channel } from 'amqplib';
+
+class RabbitMq {
+  channel: Channel;
+
+  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();
+
+    try {
+      content = JSON.parse(content);
+    } catch(e) { }
+
+    return {
+      ...msg,
+      content,
+    }
+  }
+
+  constructor(channel: Channel) {
+    this.channel = channel;
+  }
+
+  public ack = (msg: any) => {
+    this.channel.ack(msg);
+  }
+
+  async assertExchange(exchange: string, options?: any) {
+    return this.channel.assertExchange(exchange, 'fanout')
+  }
+
+  async assertQueue(queue: string, options?: any) {
+    return this.channel.assertQueue(queue);
+  }
+
+  async consume(queue: string, callback: (msg: any, ack: Function) => any) {
+    await this.assertQueue(queue);
+    return this.channel.consume(queue, (msg) => callback(RabbitMq.parseMsg(msg), this.ack));
+  }
+
+  async consumeFromExchange(queue: string, exchange: string, callback: (msg: any, ack: Function) => any) {
+    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));
+  }
+
+  async publish(exchange: string, content: any) {
+    return this.channel.publish(exchange, '', Buffer.from(content));
+  }
+
+  async sendToQueue(queue: string, content: any) {
+    return this.channel.sendToQueue(queue, Buffer.from(content));
+  }
+}
+
+export default RabbitMq;

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true
+  }
+}