sb-rabbitmq-provider 1.0.13 → 1.0.16

package/dist/index.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Connection event,
+ * if all connections are established then ready event will get triggered
+ */
+import { Connection as RabbitmqClientConnection, Channel as RabbitMQChannel, Options } from 'amqplib';
+interface rabbitMQConfig {
+    protocol?: string | undefined;
+    hostname?: string | undefined;
+    port?: number | undefined;
+    username?: string | undefined;
+    password?: string | undefined;
+    locale?: string | undefined;
+    frameMax?: number | undefined;
+    heartbeat?: number | undefined;
+    vhost?: string | undefined;
+    exchangeName?: string;
+    exchangeType: string;
+}
+type MyCallback = (data: any) => any;
+declare class RabbitMqConnection {
+    config: rabbitMQConfig;
+    exchange: string;
+    exchangeType: string;
+    connection: any;
+    /**
+     * constructor for initialising url, exchange name, exchange type
+     * @param url rabbitmq url
+     * @param exchange rabbitmq exchange name
+     * @param exchangeType type of exchange
+     */
+    constructor(config: rabbitMQConfig);
+    /**
+     * creates the rabbitmq connection
+     * connection must be single, with multiple channel
+     * @returns connection object
+     */
+    createConnection(): Promise<RabbitmqClientConnection>;
+    /**
+     * single connection can have multiple channel like publishChannel and consumeChannel
+     * @returns channel object
+     */
+    createChannel(): Promise<RabbitMQChannel>;
+    /**
+     * it will publish the data into a specific queue
+     * @param channel channel object
+     * @param queueName queue name
+     * @param message object
+     * @returns
+     */
+    publish(channel: RabbitMQChannel, queueName: string, message: object): Promise<{
+        status: boolean;
+        message: string;
+    }>;
+    /**
+     * must be called once
+     * it will starting consuming/listening the data from the queue
+     * if callback is passed then data will be sent to the callback
+     * @param channel channel object
+     * @param queueName queue name
+     * @param callback function for handling the data
+     * @returns
+     */
+    consume(channel: RabbitMQChannel, queueName: string, onMessage: MyCallback, options: Options.Consume): Promise<{
+        status: boolean;
+        message: string;
+    }>;
+}
+export default RabbitMqConnection;
+export type Connection = RabbitmqClientConnection;
+export type Channel = RabbitMQChannel;

package/dist/index.js

@@ -0,0 +1,117 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Connection event,
+ * if all connections are established then ready event will get triggered
+ */
+const amqplib_1 = __importDefault(require("amqplib"));
+class RabbitMqConnection {
+    /**
+     * constructor for initialising url, exchange name, exchange type
+     * @param url rabbitmq url
+     * @param exchange rabbitmq exchange name
+     * @param exchangeType type of exchange
+     */
+    constructor(config) {
+        this.exchange = 'EXCHANGE';
+        this.exchangeType = 'direct';
+        if (config.exchangeName && typeof config.exchangeName === 'string') {
+            this.exchange = config.exchangeName;
+        }
+        if (config.exchangeType && typeof config.exchangeType === 'string') {
+            this.exchangeType = config.exchangeType;
+        }
+        this.config = config;
+    }
+    /**
+     * creates the rabbitmq connection
+     * connection must be single, with multiple channel
+     * @returns connection object
+     */
+    createConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const connection = yield amqplib_1.default.connect(this.config);
+                // console.log('---RabbitMQ Connection Created---')
+                this.connection = connection;
+                return connection;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    /**
+     * single connection can have multiple channel like publishChannel and consumeChannel
+     * @returns channel object
+     */
+    createChannel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const channel = yield this.connection.createChannel();
+                yield channel.assertExchange(this.exchange, this.exchangeType);
+                return channel;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    /**
+     * it will publish the data into a specific queue
+     * @param channel channel object
+     * @param queueName queue name
+     * @param message object
+     * @returns
+     */
+    publish(channel, queueName, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const bufferMessage = Buffer.from(JSON.stringify(message));
+                channel.publish(this.exchange, queueName, bufferMessage);
+                return { status: true, message: 'Data sent to Queue' };
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    /**
+     * must be called once
+     * it will starting consuming/listening the data from the queue
+     * if callback is passed then data will be sent to the callback
+     * @param channel channel object
+     * @param queueName queue name
+     * @param callback function for handling the data
+     * @returns
+     */
+    consume(channel, queueName, onMessage, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { queue } = yield channel.assertQueue(queueName, { durable: true, autoDelete: false });
+                yield channel.bindQueue(queue, this.exchange, queueName);
+                channel.consume(queueName, (message) => {
+                    // channel.ack(message);
+                    onMessage(message);
+                }, options);
+                return { status: true, message: `Started consuming Queue: ${queueName}` };
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+}
+exports.default = RabbitMqConnection;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sb-rabbitmq-provider",
-  "version": "1.0.13",
+  "version": "1.0.16",
   "description": "Pub/Sub model for RabbitMq",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",