fastify-rabbitmq 0.0.1-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Shane
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,93 @@
+# fastify-rabbitmq
+A Fastify RabbitMQ Plugin Developed in Pure TypeScript. Providing a lot more expandability on the ```amqplib``` package and RabbitMQ functionally.
+
+## Install
+```
+npm i fastify-rabbitmq
+```
+
+## Usage
+Register as a plugin. This will decorate your `fastify` instance with the following methods:
+
+* fastify.rabbitmq.publishMessage
+* fastify.rabbitmq.directMessage
+
+```js
+import fastifyRabbit from "fastify-rabbitmq"
+
+fastify.register(fastifyRabbit, {
+  queue: 'rabbitqueue',
+  consumeMessageFn: async (message, channel: Channel) => {
+    console.log(message.content.toString())
+  }
+})
+```
+
+## Options
+
+```typescript
+export interface FastifyRabbitMQOptions {
+  namespace?: string
+  queue: string
+  host?: string
+  port?: string
+  username?: string
+  password?: string
+  preProcessMessageFn?: (message: any) => string;
+  consumeMessageFn: (message: ConsumeMessage, channel: Channel) => void;
+  confirmChannel?: boolean
+}
+```
+### `queue` (required)
+
+The RabbitMQ queue to create.
+
+### `consumeMessageFn` (required)
+
+How this particular queue will process messages. Rememer that plugins in fastify can not access the request/reply scope. You will need to send your data that you get to a REST API endpoint for it to be processed.
+
+```typescript
+consumeMessageFn: async (message, channel: Channel) => {
+  const data = message.content.toString()
+  const options: any = {
+    json: {
+      ...data
+    },
+  };
+  const {body} = await got.post(`http://localhost:3000/foo`, options)
+}
+```
+One example using the ```got``` NPM package to then pass the results from theis RabbitMQ data.
+
+### `name`
+
+If you register more than one RabbitMQ queue within the same application, you must give it a namespace.
+The name can be the same as the queue.
+
+### `host`
+
+By default, it's ```localhost``` but pass your RabbitMQ server hostname or IP address. 
+
+### `port`
+
+By default it's ```5672``` but pass your RabbitMQ port.
+
+### `username`
+
+By default, it's ```guest``` but pass your RabbitMQ username.
+
+### `password`
+
+By default, it's ```guest``` but pass your RabbitMQ password.
+
+### `preProcessMessageFn`
+
+Before your message goes out, do something to your message.
+This is good so all your message go out correctly.
+If not, just make sure you are only sending strings out.
+
+### `confirmChannel`
+
+By default,
+it's ```false``` but mark this ture in order for you to mark your queue
+always confirm that it received data from a remote RabbitMQ.

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+import { FastifyInstance, FastifyPluginCallback } from 'fastify';
+import { Channel, ConsumeMessage } from 'amqplib';
+import FastifyRabbitMQOptions = fastifyRabbitMQ.FastifyRabbitMQOptions;
+declare module 'fastify' {
+    interface FastifyInstance {
+        rabbitmq: fastifyRabbitMQ.FastifyRabbitMQObject & fastifyRabbitMQ.FastifyRabbitMQNestedObject;
+    }
+}
+type fastifyRabbitMQPlugin = FastifyPluginCallback<NonNullable<fastifyRabbitMQ.FastifyRabbitMQOptions>>;
+declare namespace fastifyRabbitMQ {
+    export interface FastifyRabbitMQObject {
+        publishMessage(sendQueue: string, message: any): void;
+        directMessage(sendQueue: string, message: any): void;
+    }
+    export interface FastifyRabbitMQNestedObject {
+        [namespace: string]: FastifyRabbitMQObject;
+    }
+    export interface FastifyRabbitMQOptions {
+        namespace?: string;
+        queue: string;
+        host?: string;
+        port?: string;
+        username?: string;
+        password?: string;
+        preProcessMessageFn?: (message: any) => string;
+        consumeMessageFn: (message: ConsumeMessage, channel: Channel) => void;
+        confirmChannel?: boolean;
+    }
+    export const fastifyRabbitMQPlugin: fastifyRabbitMQPlugin;
+    export { fastifyRabbitMQPlugin as default };
+}
+declare const fastifyRabbit: (fastify: FastifyInstance, options: FastifyRabbitMQOptions) => Promise<void>;
+export default fastifyRabbit;

package/dist/index.js

@@ -0,0 +1,113 @@
+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());
+    });
+};
+import fp from 'fastify-plugin';
+import amqp from 'amqplib';
+/**
+ * decorateFastifyInstance
+ * @since 0.0.1
+ * @param fastify
+ * @param options
+ * @param functions
+ */
+const decorateFastifyInstance = (fastify, options, functions) => {
+    const { namespace } = options;
+    if (namespace) {
+        if (typeof fastify.rabbitmq === 'undefined') {
+            fastify.decorate('rabbitmq', Object.assign({}, functions));
+        }
+        if (typeof fastify.rabbitmq[namespace] !== 'undefined') {
+            throw Error('Connection name already registered: ' + namespace);
+        }
+    }
+    else {
+        if (typeof fastify.rabbitmq !== 'undefined') {
+            throw Error('fastify-rabbitmq has already registered');
+        }
+    }
+    if (typeof fastify.rabbitmq === 'undefined') {
+        fastify.decorate('rabbitmq', Object.assign({}, functions));
+    }
+};
+const fastifyRabbit = fp((fastify, options) => __awaiter(void 0, void 0, void 0, function* () {
+    const { queue, host = 'localhost', port = '5672', username = 'guest', password = 'guest', confirmChannel = false, consumeMessageFn, preProcessMessageFn } = options;
+    const RABBITMQ_FULL_URL = `amqp://${username}:${password}@${host}:${port}`;
+    /**
+     * getRabbitChannel
+     * @since 0.0.1
+     * @param confirmChannel {boolean} Set this to true if you want the channel to always ask for a confirmation that it was sent and received by the other side.
+     */
+    function getRabbitChannel(confirmChannel) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const conn = yield amqp.connect(RABBITMQ_FULL_URL);
+            return confirmChannel ? yield conn.createConfirmChannel() : yield conn.createChannel();
+        });
+    }
+    /**
+     * consumeRabbitMessage
+     * Process the incoming message from another queue. This is required.
+     * @since 0.0.1
+     * @param msg {ConsumeMessage} Data from RabbitMQ. It's in a string format; however, you need to interpret the data.
+     * @param channel {Channel} What channel did it comes from and the properties of that channel.
+     */
+    function consumeRabbitMessage(msg, channel) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof consumeMessageFn === 'function') {
+                consumeMessageFn(msg, channel);
+            }
+        });
+    }
+    /**
+     * preProcessMessage
+     * If the parameter preProcessMessageFn is passed, it will use that function to process the data.
+     * @since 0.0.1
+     * @param message {any} The data you want to send, however it must be a string.
+     */
+    function preProcessMessage(message) {
+        if (typeof preProcessMessageFn === 'function') {
+            return preProcessMessageFn(message);
+        }
+        else {
+            return message;
+        }
+    }
+    const channel = yield getRabbitChannel(confirmChannel);
+    yield (channel === null || channel === void 0 ? void 0 : channel.assertQueue(queue, { durable: false }).then(() => __awaiter(void 0, void 0, void 0, function* () {
+        return yield channel.consume(queue, (msg) => __awaiter(void 0, void 0, void 0, function* () {
+            yield consumeRabbitMessage(msg, channel);
+        }), {
+            noAck: true
+        });
+    })));
+    /**
+     * publishMessage
+     * @since 0.0.1
+     * @param sendQueue {string} The target queue.
+     * @param message {any} You can publish anything as long as it goes out over as a string.
+     */
+    function publishMessage(sendQueue, message) {
+        channel === null || channel === void 0 ? void 0 : channel.publish('', sendQueue, Buffer.from(preProcessMessage(message)));
+    }
+    /**
+     * directMessage
+     * @since 0.0.1
+     * @param sendQueue {string} The target queue and directed to that queue. No one else can take it.
+     * @param message {any} You can publish anything as long as it goes out over as a string.
+     */
+    function directMessage(sendQueue, message) {
+        channel === null || channel === void 0 ? void 0 : channel.sendToQueue(sendQueue, Buffer.from(preProcessMessage(message)), {
+            replyTo: queue
+        });
+    }
+    /**
+     * Decorate Fastify
+     */
+    decorateFastifyInstance(fastify, options, { publishMessage, directMessage });
+}));
+export default fastifyRabbit;

package/index.ts

@@ -0,0 +1,165 @@
+import {FastifyInstance, FastifyPluginCallback} from 'fastify'
+import fp from 'fastify-plugin'
+import amqp, {Channel, ConsumeMessage} from 'amqplib'
+
+import FastifyRabbitMQOptions = fastifyRabbitMQ.FastifyRabbitMQOptions;
+
+declare module 'fastify' {
+  interface FastifyInstance {
+    rabbitmq: fastifyRabbitMQ.FastifyRabbitMQObject & fastifyRabbitMQ.FastifyRabbitMQNestedObject;
+  }
+
+}
+
+type fastifyRabbitMQPlugin = FastifyPluginCallback<
+  NonNullable<fastifyRabbitMQ.FastifyRabbitMQOptions>
+>;
+
+declare namespace fastifyRabbitMQ {
+
+  export interface FastifyRabbitMQObject {
+    publishMessage (sendQueue: string, message: any): void
+    directMessage (sendQueue: string, message: any): void
+  }
+
+  export interface FastifyRabbitMQNestedObject {
+    [namespace: string]: FastifyRabbitMQObject;
+  }
+
+  export interface FastifyRabbitMQOptions {
+    namespace?: string
+    queue: string
+    host?: string
+    port?: string
+    username?: string
+    password?: string
+    preProcessMessageFn?: (message: any) => string;
+    consumeMessageFn: (message: ConsumeMessage, channel: Channel) => void;
+    confirmChannel?: boolean
+  }
+
+  export const fastifyRabbitMQPlugin: fastifyRabbitMQPlugin
+  export { fastifyRabbitMQPlugin as default }
+
+}
+
+/**
+ * decorateFastifyInstance
+ * @since 0.0.1
+ * @param fastify
+ * @param options
+ * @param functions
+ */
+const decorateFastifyInstance = (fastify: FastifyInstance, options: FastifyRabbitMQOptions, functions: any): void => {
+  const { namespace } = options
+
+  if (namespace) {
+    if (typeof fastify.rabbitmq === 'undefined') {
+      fastify.decorate('rabbitmq', {...functions})
+    }
+    if (typeof fastify.rabbitmq[namespace] !== 'undefined') {
+      throw Error('Connection name already registered: ' + namespace)
+    }
+
+  } else {
+    if (typeof fastify.rabbitmq !== 'undefined') {
+      throw Error('fastify-rabbitmq has already registered')
+    }
+  }
+
+  if (typeof fastify.rabbitmq === 'undefined') {
+    fastify.decorate('rabbitmq', {...functions})
+  }
+
+}
+
+const fastifyRabbit = fp(async (fastify: FastifyInstance, options: FastifyRabbitMQOptions): Promise<void> => {
+  const {
+    queue,
+    host = 'localhost',
+    port = '5672',
+    username = 'guest',
+    password = 'guest',
+    confirmChannel = false,
+    consumeMessageFn,
+    preProcessMessageFn
+  } = options
+
+  const RABBITMQ_FULL_URL = `amqp://${username}:${password}@${host}:${port}`
+
+  /**
+   * getRabbitChannel
+   * @since 0.0.1
+   * @param confirmChannel {boolean} Set this to true if you want the channel to always ask for a confirmation that it was sent and received by the other side.
+   */
+  async function getRabbitChannel (confirmChannel: boolean): Promise<Channel> {
+    const conn = await amqp.connect(RABBITMQ_FULL_URL)
+    return confirmChannel ? await conn.createConfirmChannel() : await conn.createChannel()
+  }
+
+  /**
+   * consumeRabbitMessage
+   * Process the incoming message from another queue. This is required.
+   * @since 0.0.1
+   * @param msg {ConsumeMessage} Data from RabbitMQ. It's in a string format; however, you need to interpret the data.
+   * @param channel {Channel} What channel did it comes from and the properties of that channel.
+   */
+  async function consumeRabbitMessage (msg: ConsumeMessage, channel: Channel): Promise<void> {
+    if (typeof consumeMessageFn === 'function') {
+      consumeMessageFn(msg, channel)
+    }
+  }
+
+  /**
+   * preProcessMessage
+   * If the parameter preProcessMessageFn is passed, it will use that function to process the data.
+   * @since 0.0.1
+   * @param message {any} The data you want to send, however it must be a string.
+   */
+  function preProcessMessage(message: any): string {
+    if (typeof preProcessMessageFn === 'function') {
+      return preProcessMessageFn(message)
+    } else {
+      return message
+    }
+  }
+
+  const channel = await getRabbitChannel(confirmChannel)
+
+  await channel?.assertQueue(queue, { durable: false }).then(async () => {
+    return await channel.consume(queue, async (msg:amqp.ConsumeMessage | null): Promise<void> => {
+      await consumeRabbitMessage(<ConsumeMessage>msg, channel)
+    }, {
+      noAck: true
+    })
+  })
+
+  /**
+   * publishMessage
+   * @since 0.0.1
+   * @param sendQueue {string} The target queue.
+   * @param message {any} You can publish anything as long as it goes out over as a string.
+   */
+  function publishMessage (sendQueue: string, message: any): void {
+    channel?.publish('', sendQueue, Buffer.from(preProcessMessage(message)))
+  }
+
+  /**
+   * directMessage
+   * @since 0.0.1
+   * @param sendQueue {string} The target queue and directed to that queue. No one else can take it.
+   * @param message {any} You can publish anything as long as it goes out over as a string.
+   */
+  function directMessage (sendQueue: string, message: any): void {
+    channel?.sendToQueue(sendQueue, Buffer.from(preProcessMessage(message)), {
+      replyTo: queue
+    })
+  }
+
+  /**
+   * Decorate Fastify
+   */
+  decorateFastifyInstance(fastify, options, {publishMessage, directMessage})
+})
+
+export default fastifyRabbit

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "fastify-rabbitmq",
+  "version": "0.0.1-alpha.0",
+  "description": "A Fastify RabbitMQ Plugin Developed in Pure TypeScript using the AMQPLIB",
+  "type": "module",
+  "types": "dist/index.d.ts",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc -w",
+    "lint": "ts-standard",
+    "lint:fix": "ts-standard --fix",
+    "test": "npm run unit && npm run typescript",
+    "update": "npx npm-check-updates -u && npm install"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Bugs5382/fastify-rabbitmq.git"
+  },
+  "keywords": [
+    "typescript",
+    "rabbitmq",
+    "fastify",
+    "fastify-plugin"
+  ],
+  "author": "Shane Froebel",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Bugs5382/fastify-rabbitmq/issues"
+  },
+  "homepage": "https://github.com/Bugs5382/fastify-rabbitmq#readme",
+  "dependencies": {
+    "amqplib": "^0.10.3",
+    "fastify-plugin": "^4.5.1"
+  },
+  "devDependencies": {
+    "@types/amqplib": "^0.10.1",
+    "@types/node": "^20.4.6",
+    "fastify": "^4.21.0",
+    "npm-check-updates": "^16.10.17",
+    "pre-commit": "^1.2.2",
+    "tap": "^16.3.8",
+    "ts-standard": "^12.0.2",
+    "typescript": "^5.1.6"
+  },
+  "pre-commit": []
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "files": ["index.ts"],
+  "compilerOptions": {
+    "target": "es2015",
+    "module": "es2015",
+    "moduleResolution": "node",
+    "declaration": true,
+    "outDir": "./dist",
+    "noEmit": false,
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  }
+}