@bsb/events-rabbitmq 0.0.1

package/lib/plugins/events-rabbitmq/index.js

@@ -0,0 +1,150 @@
+import * as amqplib from "amqp-connection-manager";
+import * as amqplibCore from "amqplib";
+import { broadcast } from "./events/broadcast.js";
+import { emit } from "./events/emit.js";
+import { emitAndReturn } from "./events/emitAndReturn.js";
+import { emitStreamAndReceiveStream } from "./events/emitStreamAndReceiveStream.js";
+import { randomUUID } from "crypto";
+import { hostname } from "os";
+import { BSBEvents, createConfigSchema, PluginObservable, ResourceContextBuilder, createFakeDTrace, } from "@bsb/base";
+import * as av from "anyvali";
+const ConfigSchema = av.object({
+    platformKey: av.nullable(av.string()).default(null).describe("Optional platform key appended to RabbitMQ queue names"),
+    fatalOnDisconnect: av.bool().default(true).describe("Whether the process should fail when RabbitMQ disconnects"),
+    prefetch: av.int32().default(10).describe("RabbitMQ channel prefetch count"),
+    endpoints: av.array(av.string()).default(["amqp://localhost"]).describe("RabbitMQ connection endpoint URLs"),
+    credentials: av.object({
+        username: av.string().default("guest").describe("RabbitMQ username"),
+        password: av.string().default("guest").describe("RabbitMQ password"),
+    }).default({ username: "guest", password: "guest" }).describe("RabbitMQ authentication credentials"),
+    uniqueId: av.nullable(av.string()).default(null).describe("Optional stable instance ID used in event consumer identity"),
+}).describe("RabbitMQ events plugin configuration");
+export const Config = createConfigSchema({
+    name: 'events-rabbitmq',
+    description: 'RabbitMQ events plugin for distributed event bus',
+    image: './assets/events-rabbitmq.png',
+    tags: ['rabbitmq', 'amqp', 'event-bus', 'distributed'],
+    documentation: ['./docs/plugin.md'],
+}, ConfigSchema);
+export class Plugin extends BSBEvents {
+    constructor(config) {
+        super(config);
+        this.broadcast = new broadcast(this);
+        this.emit = new emit(this);
+        this.ear = new emitAndReturn(this);
+        this.eas = new emitStreamAndReceiveStream(this);
+    }
+    getPlatformName(name) {
+        if (this.config.platformKey === null)
+            return name;
+        return `${name}-${this.config.platformKey}`;
+    }
+    async init(obs) {
+        await this._connectToAMQP(obs);
+    }
+    createObservableFromTrace(trace, attributes) {
+        const safeTrace = trace ?? createFakeDTrace("events-rabbitmq", "missing-trace");
+        const resource = ResourceContextBuilder.build({
+            appId: this.appId,
+            mode: this.mode,
+            pluginName: this.pluginName,
+            cwd: this.cwd,
+            packageCwd: this.packageCwd,
+            pluginCwd: this.pluginCwd,
+            pluginVersion: this.pluginVersion || 'unknown',
+        }, this.region);
+        return new PluginObservable(safeTrace, resource, this.__internalObservable, attributes || {});
+    }
+    async _connectToAMQP(obs) {
+        const endpoints = this.config.endpoints ?? ["amqp://localhost"];
+        const fatalOnDisconnect = this.config.fatalOnDisconnect ?? true;
+        const credentials = this.config.credentials;
+        obs.log.info('Connect to {endpoints}', {
+            endpoints,
+        });
+        const socketOptions = {
+            connectionOptions: {},
+        };
+        if (credentials?.username) {
+            socketOptions.connectionOptions.credentials =
+                amqplibCore.credentials.plain(credentials.username, credentials.password ?? "guest");
+        }
+        this.publishConnection = amqplib.connect(endpoints, socketOptions);
+        this.receiveConnection = amqplib.connect(endpoints, socketOptions);
+        this.publishConnection.on("connect", async (data) => {
+            obs.log.info("AMQP CONNECTED: {url}", { url: data.url });
+        });
+        this.publishConnection.on("connectFailed", async (data) => {
+            const errMsg = data.err?.toString() ?? "unknown";
+            if (fatalOnDisconnect || endpoints.length === 1) {
+                obs.log.error("AMQP CONNECT FAIL: {url} ({err})", { url: data.url, err: errMsg });
+                throw new Error(`AMQP connection failed: ${data.url} (${errMsg})`);
+            }
+            obs.log.error("AMQP CONNECT FAIL: {url} ({err})", { url: data.url, err: errMsg });
+        });
+        this.publishConnection.on("error", async (err) => {
+            if (err.message !== "Connection closing") {
+                obs.log.error("AMQP publish error: {err}", { err: err.message });
+            }
+            if (fatalOnDisconnect) {
+                throw new Error(`AMQP publish error (fatal): ${err.message}`);
+            }
+        });
+        this.receiveConnection.on("error", async (err) => {
+            if (err.message !== "Connection closing") {
+                obs.log.error("AMQP receive error: {err}", { err: err.message });
+            }
+            if (fatalOnDisconnect) {
+                throw new Error(`AMQP receive error (fatal): ${err.message}`);
+            }
+        });
+        this.publishConnection.on("close", async () => {
+            obs.log.warn("AMQP publish connection closed");
+        });
+        this.receiveConnection.on("close", async () => {
+            obs.log.warn("AMQP receive connection closed");
+        });
+        obs.log.info('Connected to {endpoints}x2? (s:{sendS}/p:{pubS})', {
+            endpoints,
+            sendS: this.receiveConnection.isConnected(),
+            pubS: this.publishConnection.isConnected(),
+        });
+        this.myId = `${this.config.uniqueId ?? hostname()}-${randomUUID()}`;
+        await this.broadcast.init(obs);
+        await this.emit.init(obs);
+        await this.ear.init(obs);
+    }
+    dispose() {
+        this.broadcast.dispose();
+        this.emit.dispose();
+        this.ear.dispose();
+        this.eas.dispose();
+        this.publishConnection.close();
+        this.receiveConnection.close();
+    }
+    async onBroadcast(obs, pluginName, event, listener) {
+        await this.broadcast.onBroadcast(obs, pluginName, event, listener);
+    }
+    async emitBroadcast(obs, pluginName, event, args) {
+        await this.broadcast.emitBroadcast(obs, pluginName, event, args);
+    }
+    async onEvent(obs, pluginName, event, listener) {
+        await this.emit.onEvent(obs, pluginName, event, listener);
+    }
+    async emitEvent(obs, pluginName, event, args) {
+        await this.emit.emitEvent(obs, pluginName, event, args);
+    }
+    async onReturnableEvent(obs, pluginName, event, listener) {
+        await this.ear.onReturnableEvent(obs, pluginName, event, listener);
+    }
+    async emitEventAndReturn(obs, pluginName, event, timeoutSeconds, args) {
+        return await this.ear.emitEventAndReturn(obs, pluginName, event, timeoutSeconds, args);
+    }
+    async receiveStream(obs, pluginName, event, listener, timeoutSeconds) {
+        return this.eas.receiveStream(obs, pluginName, event, listener, timeoutSeconds);
+    }
+    async sendStream(obs, pluginName, event, streamId, stream) {
+        return this.eas.sendStream(obs, pluginName, event, streamId, stream);
+    }
+}
+Plugin.Config = Config;

package/lib/plugins/events-rabbitmq/plugin.config.json

@@ -0,0 +1,39 @@
+{
+  "key": "events-rabbitmq",
+  "name": "RabbitMQ",
+  "icon": "events-rabbitmq.png",
+  "description": "RabbitMQ events plugin",
+  "badges": [
+    {
+      "url": "https://codecov.io/gh/BetterCorp/service-base-events-rabbitmq",
+      "img": "https://codecov.io/gh/BetterCorp/service-base-events-rabbitmq/branch/master/graph/badge.svg"
+    },
+    {
+      "img": "https://img.shields.io/github/license/BetterCorp/service-base-events-rabbitmq"
+    },
+    {
+      "img": "https://img.shields.io/snyk/vulnerabilities/github/BetterCorp/service-base-events-rabbitmq"
+    },
+    {
+      "img": "https://img.shields.io/github/issues-raw/BetterCorp/service-base-events-rabbitmq"
+    },
+    {
+      "img": "https://github.com/BetterCorp/service-base-events-rabbitmq/actions/workflows/develop.yml/badge.svg?branch=develop"
+    },
+    {
+      "img": "https://github.com/BetterCorp/service-base-events-rabbitmq/actions/workflows/master.yml/badge.svg?branch=master"
+    },
+    {
+      "img": "https://img.shields.io/github/issues-raw/BetterCorp/service-base-events-rabbitmq"
+    },
+    {
+      "img": "https://img.shields.io/npm/dt/@bettercorp/service-base-events-rabbitmq"
+    },
+    {
+      "img": "https://img.shields.io/bundlephobia/min/@bettercorp/service-base-events-rabbitmq"
+    },
+    {
+      "img": "https://img.shields.io/npm/v/@bettercorp/service-base-events-rabbitmq"
+    }
+  ]
+}

package/lib/schemas/events-rabbitmq.json

@@ -0,0 +1,118 @@
+{
+  "pluginName": "events-rabbitmq",
+  "events": {},
+  "version": "0.0.1",
+  "configSchema": {
+    "anyvaliVersion": "1.0",
+    "schemaVersion": "1.1",
+    "root": {
+      "kind": "object",
+      "properties": {
+        "platformKey": {
+          "kind": "nullable",
+          "inner": {
+            "kind": "string"
+          },
+          "default": null,
+          "metadata": {
+            "description": "Optional platform key appended to RabbitMQ queue names"
+          }
+        },
+        "fatalOnDisconnect": {
+          "kind": "bool",
+          "default": true,
+          "metadata": {
+            "description": "Whether the process should fail when RabbitMQ disconnects"
+          }
+        },
+        "prefetch": {
+          "kind": "int32",
+          "default": 10,
+          "metadata": {
+            "description": "RabbitMQ channel prefetch count"
+          }
+        },
+        "endpoints": {
+          "kind": "array",
+          "items": {
+            "kind": "string"
+          },
+          "default": [
+            "amqp://localhost"
+          ],
+          "metadata": {
+            "description": "RabbitMQ connection endpoint URLs"
+          }
+        },
+        "credentials": {
+          "kind": "object",
+          "properties": {
+            "username": {
+              "kind": "string",
+              "default": "guest",
+              "metadata": {
+                "description": "RabbitMQ username"
+              }
+            },
+            "password": {
+              "kind": "string",
+              "default": "guest",
+              "metadata": {
+                "description": "RabbitMQ password"
+              }
+            }
+          },
+          "required": [
+            "username",
+            "password"
+          ],
+          "unknownKeys": "strip",
+          "default": {
+            "username": "guest",
+            "password": "guest"
+          },
+          "metadata": {
+            "description": "RabbitMQ authentication credentials"
+          }
+        },
+        "uniqueId": {
+          "kind": "nullable",
+          "inner": {
+            "kind": "string"
+          },
+          "default": null,
+          "metadata": {
+            "description": "Optional stable instance ID used in event consumer identity"
+          }
+        }
+      },
+      "required": [
+        "platformKey",
+        "fatalOnDisconnect",
+        "prefetch",
+        "endpoints",
+        "credentials",
+        "uniqueId"
+      ],
+      "unknownKeys": "strip",
+      "metadata": {
+        "description": "RabbitMQ events plugin configuration"
+      }
+    },
+    "definitions": {},
+    "extensions": {}
+  },
+  "pluginType": "events",
+  "capabilities": {
+    "eventsApi": {
+      "onBroadcast": true,
+      "emitBroadcast": true,
+      "onEvent": true,
+      "emitEvent": true,
+      "onReturnableEvent": true,
+      "emitEventAndReturn": true,
+      "receiveStream": true,
+      "sendStream": true
+    }
+  }
+}

package/lib/schemas/events-rabbitmq.plugin.json

@@ -0,0 +1,124 @@
+{
+  "id": "events-rabbitmq",
+  "name": "events-rabbitmq",
+  "version": "0.0.1",
+  "description": "RabbitMQ events plugin for distributed event bus",
+  "category": "events",
+  "tags": [
+    "rabbitmq",
+    "amqp",
+    "event-bus",
+    "distributed"
+  ],
+  "documentation": [
+    "./docs/plugin.md"
+  ],
+  "dependencies": [],
+  "author": {
+    "name": "BetterCorp (PTY) Ltd",
+    "email": "ninja@bettercorp.dev",
+    "url": "https://bettercorp.dev/"
+  },
+  "license": "(AGPL-3.0-only OR Commercial)",
+  "image": "./assets/events-rabbitmq.png",
+  "configSchema": {
+    "anyvaliVersion": "1.0",
+    "schemaVersion": "1.1",
+    "root": {
+      "kind": "object",
+      "properties": {
+        "platformKey": {
+          "kind": "nullable",
+          "inner": {
+            "kind": "string"
+          },
+          "default": null,
+          "metadata": {
+            "description": "Optional platform key appended to RabbitMQ queue names"
+          }
+        },
+        "fatalOnDisconnect": {
+          "kind": "bool",
+          "default": true,
+          "metadata": {
+            "description": "Whether the process should fail when RabbitMQ disconnects"
+          }
+        },
+        "prefetch": {
+          "kind": "int32",
+          "default": 10,
+          "metadata": {
+            "description": "RabbitMQ channel prefetch count"
+          }
+        },
+        "endpoints": {
+          "kind": "array",
+          "items": {
+            "kind": "string"
+          },
+          "default": [
+            "amqp://localhost"
+          ],
+          "metadata": {
+            "description": "RabbitMQ connection endpoint URLs"
+          }
+        },
+        "credentials": {
+          "kind": "object",
+          "properties": {
+            "username": {
+              "kind": "string",
+              "default": "guest",
+              "metadata": {
+                "description": "RabbitMQ username"
+              }
+            },
+            "password": {
+              "kind": "string",
+              "default": "guest",
+              "metadata": {
+                "description": "RabbitMQ password"
+              }
+            }
+          },
+          "required": [
+            "username",
+            "password"
+          ],
+          "unknownKeys": "strip",
+          "default": {
+            "username": "guest",
+            "password": "guest"
+          },
+          "metadata": {
+            "description": "RabbitMQ authentication credentials"
+          }
+        },
+        "uniqueId": {
+          "kind": "nullable",
+          "inner": {
+            "kind": "string"
+          },
+          "default": null,
+          "metadata": {
+            "description": "Optional stable instance ID used in event consumer identity"
+          }
+        }
+      },
+      "required": [
+        "platformKey",
+        "fatalOnDisconnect",
+        "prefetch",
+        "endpoints",
+        "credentials",
+        "uniqueId"
+      ],
+      "unknownKeys": "strip",
+      "metadata": {
+        "description": "RabbitMQ events plugin configuration"
+      }
+    },
+    "definitions": {},
+    "extensions": {}
+  }
+}

package/lib/tests/mocks.d.ts

@@ -0,0 +1,3 @@
+import { BSBEventsConstructor, SBObservable } from "@bsb/base";
+export declare const MockSBObservable: () => SBObservable;
+export declare const getEventsConstructorConfig: (config: any) => BSBEventsConstructor;

package/lib/tests/mocks.js

@@ -0,0 +1,65 @@
+import { EventEmitter } from "events";
+export const MockSBObservable = () => {
+    const observableBus = new EventEmitter();
+    observableBus.on("error", () => { });
+    return {
+        observableBus,
+        isReady: true,
+        debug: (plugin, trace, message, meta) => {
+            observableBus.emit("debug", plugin, trace, message, meta);
+        },
+        info: (plugin, trace, message, meta) => {
+            observableBus.emit("info", plugin, trace, message, meta);
+        },
+        warn: (plugin, trace, message, meta) => {
+            observableBus.emit("warn", plugin, trace, message, meta);
+        },
+        error: (plugin, trace, message, meta) => {
+            observableBus.emit("error", plugin, trace, message, meta);
+        },
+        createCounter: (timestamp, pluginName, name, description, help, labels) => {
+            observableBus.emit("createCounter", timestamp, pluginName, name, description, help, labels);
+        },
+        incrementCounter: (timestamp, pluginName, name, value, labels) => {
+            observableBus.emit("incrementCounter", timestamp, pluginName, name, value, labels);
+        },
+        createGauge: (timestamp, pluginName, name, description, help, labels) => {
+            observableBus.emit("createGauge", timestamp, pluginName, name, description, help, labels);
+        },
+        setGauge: (timestamp, pluginName, name, value, labels) => {
+            observableBus.emit("setGauge", timestamp, pluginName, name, value, labels);
+        },
+        createHistogram: (timestamp, pluginName, name, description, help, boundaries, labels) => {
+            observableBus.emit("createHistogram", timestamp, pluginName, name, description, help, boundaries, labels);
+        },
+        observeHistogram: (timestamp, pluginName, name, value, labels) => {
+            observableBus.emit("observeHistogram", timestamp, pluginName, name, value, labels);
+        },
+        startSpan: (timestamp, appId, pluginName, traceId, parentSpanId, spanId, name, attributes) => {
+            observableBus.emit("spanStart", { t: traceId, s: spanId }, pluginName, name, attributes);
+        },
+        endSpan: (timestamp, appId, pluginName, traceId, spanId, attributes) => {
+            observableBus.emit("spanEnd", { t: traceId, s: spanId }, pluginName, attributes);
+        },
+        errorSpan: (timestamp, appId, pluginName, traceId, spanId, error, attributes) => {
+            observableBus.emit("spanError", { t: traceId, s: spanId }, pluginName, error, attributes);
+        },
+        setupObservablePlugins: async () => { },
+        init: async () => { },
+        run: async () => { },
+        dispose: async () => { },
+    };
+};
+export const getEventsConstructorConfig = (config) => {
+    return {
+        appId: "test-app",
+        packageCwd: process.cwd(),
+        pluginCwd: process.cwd(),
+        cwd: process.cwd(),
+        mode: "development",
+        pluginName: "test-plugin",
+        pluginVersion: "0.0.0",
+        sbObservable: MockSBObservable(),
+        config: config,
+    };
+};

package/lib/tests/plugins/events/events/broadcast.d.ts

@@ -0,0 +1,4 @@
+import { BSBEvents } from "@bsb/base";
+export declare function broadcast(genNewPlugin: {
+    (): Promise<BSBEvents>;
+}, maxTimeoutToExpectAResponse: number): void;