@bsb/events-rabbitmq 0.0.1

package/lib/tests/plugins/events/events/emitAndReturn.js

@@ -0,0 +1,307 @@
+import * as assert from "assert";
+import { randomUUID } from "crypto";
+import { SmartFunctionCallSync } from "@bsb/base";
+import { createTestObservable } from "../../../trace.js";
+const randomName = () => randomUUID();
+export function emitAndReturn(genNewPlugin, maxTimeoutToExpectAResponse) {
+    let emitter;
+    beforeEach(async () => {
+        emitter = await genNewPlugin();
+    });
+    afterEach(function () {
+        SmartFunctionCallSync(emitter, emitter.dispose);
+    });
+    describe("EmitAndReturn", async () => {
+        const timermaxTimeoutToExpectAResponse = maxTimeoutToExpectAResponse + 10;
+        describe("emitEventAndReturn", async () => {
+            const emitData = true;
+            const emitData2 = false;
+            it("should be able to emit to events with plugin name defined", async () => {
+                const thisPlugin = randomName();
+                const thisEvent = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.fail("Event not received");
+                }, timermaxTimeoutToExpectAResponse);
+                await emitter.onReturnableEvent(obs, thisPlugin, thisEvent, async (receivedObs, data) => {
+                    return emitData2;
+                });
+                await emitter.emitEventAndReturn(obs, thisPlugin, thisEvent, maxTimeoutToExpectAResponse / 1000, []);
+                clearTimeout(emitTimeout);
+                assert.ok(true, "Received Response");
+            });
+            it("should be able to emit to events with self", async () => {
+                const thisCaller = randomName();
+                const thisEvent = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.fail("Event not received");
+                }, timermaxTimeoutToExpectAResponse);
+                await emitter.onReturnableEvent(obs, thisCaller, thisEvent, async (receivedObs, data) => {
+                    return emitData2;
+                });
+                await emitter.emitEventAndReturn(obs, thisCaller, thisEvent, maxTimeoutToExpectAResponse / 1000, [emitData]);
+                clearTimeout(emitTimeout);
+                assert.ok(true, "Received Response");
+            });
+            it("should not be able to emit to other events with plugin name defined", async () => {
+                const thisPlugin = randomName();
+                const thisEvent = randomName();
+                const thisEvent2 = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.ok(true);
+                }, timermaxTimeoutToExpectAResponse);
+                await emitter.onReturnableEvent(obs, thisPlugin, thisEvent, async () => {
+                    assert.fail("EEAR MSG Received");
+                });
+                try {
+                    await emitter.emitEventAndReturn(obs, thisPlugin, thisEvent2, maxTimeoutToExpectAResponse / 1000, [emitData]);
+                    clearTimeout(emitTimeout);
+                    assert.fail("EEAR Returned");
+                }
+                catch {
+                    clearTimeout(emitTimeout);
+                    assert.ok("Timeout of EEAR");
+                }
+            });
+            it("should not be able to emit to other events with self", async () => {
+                const thisCaller = randomName();
+                const thisEvent = randomName();
+                const thisEvent2 = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.ok(true);
+                }, timermaxTimeoutToExpectAResponse);
+                await emitter.onReturnableEvent(obs, thisCaller, thisEvent, async () => {
+                    assert.fail("EEAR MSG Received");
+                });
+                try {
+                    await emitter.emitEventAndReturn(obs, thisCaller, thisEvent2, maxTimeoutToExpectAResponse / 1000, [emitData]);
+                    clearTimeout(emitTimeout);
+                    assert.fail("EEAR Returned");
+                }
+                catch {
+                    clearTimeout(emitTimeout);
+                    assert.ok("Timeout of EEAR");
+                }
+            });
+            it("should timeout correctly", async () => {
+                const thisCaller = randomName();
+                const thisEvent = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.fail("Event not received");
+                }, timermaxTimeoutToExpectAResponse);
+                await emitter.onReturnableEvent(obs, thisCaller, thisEvent, async () => { });
+                try {
+                    await emitter.emitEventAndReturn(obs, thisCaller, thisEvent, maxTimeoutToExpectAResponse / 1000, [emitData]);
+                    clearTimeout(emitTimeout);
+                    assert.fail("EEAR Returned");
+                }
+                catch {
+                    clearTimeout(emitTimeout);
+                    assert.ok("Timeout of EEAR");
+                }
+            });
+            it("should response error correctly", async () => {
+                const thisCaller = randomName();
+                const thisEvent = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.fail("Event not received");
+                }, timermaxTimeoutToExpectAResponse);
+                await emitter.onReturnableEvent(obs, thisCaller, thisEvent, async () => {
+                    throw "THISISANERROR";
+                });
+                try {
+                    await emitter.emitEventAndReturn(obs, thisCaller, thisEvent, maxTimeoutToExpectAResponse / 1000, [emitData]);
+                    clearTimeout(emitTimeout);
+                    assert.fail("EEAR Returned");
+                }
+                catch (exc) {
+                    clearTimeout(emitTimeout);
+                    assert.ok("EEAR");
+                    assert.strictEqual(exc, "THISISANERROR");
+                }
+            });
+        });
+        const typesToTest = [
+            {
+                name: "DiffData",
+                data: null,
+                rData: "HELLO WORLD",
+            },
+            {
+                name: "Null",
+                data: null,
+            },
+            {
+                name: "Boolean true",
+                data: true,
+            },
+            {
+                name: "Boolean false",
+                data: false,
+            },
+            {
+                name: "String",
+                data: "HELLO WO4lD",
+            },
+            {
+                name: "Min Number",
+                data: Number.MIN_SAFE_INTEGER,
+            },
+            {
+                name: "Max Number",
+                data: Number.MAX_SAFE_INTEGER,
+            },
+            {
+                name: "Array",
+                data: [0, "Hello", true],
+            },
+            {
+                name: "Object",
+                data: {
+                    name: "Sarah",
+                    surname: "Blond",
+                    age: 24,
+                    meta: {
+                        location: [-12212, 55336],
+                    },
+                },
+            },
+        ];
+        for (const typeToTest of typesToTest) {
+            describe(`emitEventAndReturn ${typeToTest.name}`, async () => {
+                it("should be able to emit to events with plugin name defined", async () => {
+                    const thisPlugin = randomName();
+                    const thisEvent = randomName();
+                    const obs = createTestObservable();
+                    const emitTimeout = setTimeout(() => {
+                        assert.fail("Event not received");
+                    }, timermaxTimeoutToExpectAResponse);
+                    await emitter.onReturnableEvent(obs, thisPlugin, thisEvent, async () => {
+                        return typeToTest.rData !== undefined ? typeToTest.rData : typeToTest.data;
+                    });
+                    const resp = await emitter.emitEventAndReturn(obs, thisPlugin, thisEvent, maxTimeoutToExpectAResponse / 1000, [typeToTest.data]);
+                    clearTimeout(emitTimeout);
+                    assert.strictEqual(JSON.stringify(resp), JSON.stringify(typeToTest.rData !== undefined ? typeToTest.rData : typeToTest.data));
+                });
+                it("should be able to emit to events with self", async () => {
+                    const thisCaller = randomName();
+                    const thisEvent = randomName();
+                    const obs = createTestObservable();
+                    const emitTimeout = setTimeout(() => {
+                        assert.fail("Event not received - timeout");
+                    }, timermaxTimeoutToExpectAResponse);
+                    await emitter.onReturnableEvent(obs, thisCaller, thisEvent, async (receivedObs, data) => {
+                        clearTimeout(emitTimeout);
+                        assert.strictEqual(JSON.stringify(data[0]), JSON.stringify(typeToTest.data), "Received data");
+                        return typeToTest.rData || typeToTest.data;
+                    });
+                    assert.strictEqual(JSON.stringify(await emitter.emitEventAndReturn(obs, thisCaller, thisEvent, maxTimeoutToExpectAResponse / 1000, [typeToTest.data])), JSON.stringify(typeToTest.rData || typeToTest.data), "Returned data");
+                    clearTimeout(emitTimeout);
+                });
+                it("should not be able to emit to other events with plugin name defined", async () => {
+                    const thisPlugin = randomName();
+                    const thisEvent = randomName();
+                    const thisEvent2 = randomName();
+                    const obs = createTestObservable();
+                    const emitTimeout = setTimeout(() => {
+                        assert.ok(true);
+                    }, timermaxTimeoutToExpectAResponse);
+                    await emitter.onReturnableEvent(obs, thisPlugin, thisEvent, async () => {
+                        assert.fail("EEAR MSG Received");
+                    });
+                    try {
+                        await emitter.emitEventAndReturn(obs, thisPlugin, thisEvent2, maxTimeoutToExpectAResponse / 1000, [typeToTest.data]);
+                        clearTimeout(emitTimeout);
+                        assert.fail("EEAR Returned");
+                    }
+                    catch {
+                        clearTimeout(emitTimeout);
+                        assert.ok("Timeout of EEAR");
+                    }
+                });
+                it("should not be able to emit to other events with self", async () => {
+                    const thisCaller = randomName();
+                    const thisEvent = randomName();
+                    const thisEvent2 = randomName();
+                    const obs = createTestObservable();
+                    const emitTimeout = setTimeout(() => {
+                        assert.ok(true);
+                    }, timermaxTimeoutToExpectAResponse);
+                    await emitter.onReturnableEvent(obs, thisCaller, thisEvent, async () => {
+                        assert.fail("EEAR MSG Received");
+                    });
+                    try {
+                        await emitter.emitEventAndReturn(obs, thisCaller, thisEvent2, maxTimeoutToExpectAResponse / 1000, [typeToTest.data]);
+                        clearTimeout(emitTimeout);
+                        assert.fail("EEAR Returned");
+                    }
+                    catch {
+                        clearTimeout(emitTimeout);
+                        assert.ok("Timeout of EEAR");
+                    }
+                });
+                it("should timeout correctly - general timeout", async () => {
+                    const thisCaller = randomName();
+                    const thisEvent = randomName();
+                    const obs = createTestObservable();
+                    const emitTimeout = setTimeout(() => {
+                        assert.fail("Event not received");
+                    }, timermaxTimeoutToExpectAResponse + 10);
+                    await emitter.onReturnableEvent(obs, thisCaller, thisEvent, async () => { });
+                    try {
+                        await emitter.emitEventAndReturn(obs, thisCaller, thisEvent, maxTimeoutToExpectAResponse / 1000, [typeToTest.data]);
+                        clearTimeout(emitTimeout);
+                        assert.fail("EEAR Returned");
+                    }
+                    catch {
+                        clearTimeout(emitTimeout);
+                        assert.ok("Timeout of EEAR");
+                    }
+                });
+                it("should timeout correctly - no receipt", async () => {
+                    const thisCaller = randomName();
+                    const thisEvent = randomName();
+                    const obs = createTestObservable();
+                    const emitTimeout = setTimeout(() => {
+                        assert.fail("Event not received");
+                    }, timermaxTimeoutToExpectAResponse + 10);
+                    try {
+                        await emitter.emitEventAndReturn(obs, thisCaller, thisEvent, maxTimeoutToExpectAResponse / 1000, [typeToTest.data]);
+                        clearTimeout(emitTimeout);
+                        assert.fail("EEAR Returned");
+                    }
+                    catch {
+                        clearTimeout(emitTimeout);
+                        assert.ok("Timeout of EEAR");
+                    }
+                });
+                it("should response error correctly", async () => {
+                    const thisCaller = randomName();
+                    const thisEvent = randomName();
+                    const obs = createTestObservable();
+                    const emitTimeout = setTimeout(() => {
+                        assert.fail("Event not received");
+                    }, timermaxTimeoutToExpectAResponse);
+                    await emitter.onReturnableEvent(obs, thisCaller, thisEvent, async () => {
+                        throw typeToTest.rData || typeToTest.data;
+                    });
+                    try {
+                        await emitter.emitEventAndReturn(obs, thisCaller, thisEvent, maxTimeoutToExpectAResponse / 1000, [typeToTest.data]);
+                        clearTimeout(emitTimeout);
+                        assert.fail("EEAR Returned");
+                    }
+                    catch (exc) {
+                        clearTimeout(emitTimeout);
+                        assert.ok("EEAR");
+                        assert.strictEqual(JSON.stringify(exc), JSON.stringify(typeToTest.rData || typeToTest.data));
+                    }
+                });
+            });
+        }
+    });
+}

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

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

package/lib/tests/plugins/events/events/emitStreamAndReceiveStream.js

@@ -0,0 +1,199 @@
+import * as fs from "fs";
+import * as crypto from "crypto";
+import { pipeline } from "stream";
+import * as assert from "assert";
+import { SmartFunctionCallSync } from "@bsb/base";
+import { createTestObservable } from "../../../trace.js";
+const randomName = () => crypto.randomUUID();
+const mockBareFakeStream = () => {
+    const obj = {
+        listeners: {},
+        emit: (name, data) => {
+            if (obj.listeners[name] !== undefined) {
+                obj.listeners[name](data);
+            }
+        },
+        on: (name, listn) => {
+            obj.listeners[name] = listn;
+        },
+        destroy: () => { },
+    };
+    return obj;
+};
+const getFileHash = (filename) => new Promise((resolve, reject) => {
+    const fd = fs.createReadStream(filename);
+    const hash = crypto.createHash("sha1");
+    hash.setEncoding("hex");
+    fd.on("error", reject);
+    fd.on("end", () => {
+        hash.end();
+        resolve(hash.read());
+    });
+    fd.pipe(hash);
+});
+const createTestFile = (filePath, sizeStr) => {
+    return new Promise((resolve, reject) => {
+        const match = sizeStr.match(/^(\d+)(KB|MB)$/);
+        if (!match) {
+            return reject(new Error(`Invalid size format: ${sizeStr}`));
+        }
+        const num = parseInt(match[1], 10);
+        const unit = match[2];
+        const sizeBytes = unit === "KB" ? num * 1024 : num * 1024 * 1024;
+        const writeStream = fs.createWriteStream(filePath);
+        const chunkSize = 64 * 1024;
+        let written = 0;
+        const writeChunk = () => {
+            while (written < sizeBytes) {
+                const remaining = sizeBytes - written;
+                const size = Math.min(chunkSize, remaining);
+                const buffer = crypto.randomBytes(size);
+                const canContinue = writeStream.write(buffer);
+                written += size;
+                if (!canContinue) {
+                    writeStream.once("drain", writeChunk);
+                    return;
+                }
+            }
+            writeStream.end();
+        };
+        writeStream.on("finish", () => resolve());
+        writeStream.on("error", reject);
+        writeChunk();
+    });
+};
+export function emitStreamAndReceiveStream(genNewPlugin, maxTimeoutToExpectAResponse) {
+    let emitter;
+    beforeEach(async () => {
+        emitter = await genNewPlugin();
+    });
+    afterEach(function () {
+        SmartFunctionCallSync(emitter, emitter.dispose);
+    });
+    describe("EmitStreamAndReceiveStream", async () => {
+        const timermaxTimeoutToExpectAResponse = maxTimeoutToExpectAResponse + 10;
+        it("receiveStream creates a should generate a valid string", async () => {
+            const thisCaller = randomName();
+            const thisCallerEvent = randomName();
+            const obs = createTestObservable();
+            const uuid = await emitter.receiveStream(obs, thisCaller, thisCallerEvent, async (receivedObs, error, stream) => { }, maxTimeoutToExpectAResponse);
+            assert.ok(`${uuid}`.length >= 10, "Not a valid unique ID for stream");
+        });
+        it("sendStream triggers timeout when no receiveStream setup", async () => {
+            const thisCaller = randomName();
+            const thisEvent = randomName();
+            const streamId = `${randomName()}=1`;
+            const obs = createTestObservable();
+            try {
+                await emitter.sendStream(obs, thisCaller, thisEvent, streamId, mockBareFakeStream());
+                assert.fail("Timeout not called");
+            }
+            catch {
+                assert.ok(true, "Timeout called exception");
+            }
+        });
+        it("sendStream triggers receiveStream listener", async () => {
+            const thisCaller = randomName();
+            const thisCallerEvent = randomName();
+            const obs = createTestObservable();
+            const emitTimeout = setTimeout(() => {
+                assert.fail("Event not received");
+            }, timermaxTimeoutToExpectAResponse);
+            const uuid = await emitter.receiveStream(obs, thisCaller, thisCallerEvent, async (receivedObs, error, stream) => {
+                clearTimeout(emitTimeout);
+                stream.emit("end");
+                assert.ok(true, "Listener called");
+            }, maxTimeoutToExpectAResponse);
+            try {
+                await emitter.sendStream(obs, thisCaller, thisCallerEvent, uuid, mockBareFakeStream());
+            }
+            catch { }
+        });
+        describe("sendStream triggers receiveStream listener passing in the stream", async () => {
+            it("should not call the listener with an error", async () => {
+                const thisCaller = randomName();
+                const thisCallerEvent = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.fail("Event not received");
+                }, timermaxTimeoutToExpectAResponse);
+                const uuid = await emitter.receiveStream(obs, thisCaller, thisCallerEvent, async (receivedObs, error, stream) => {
+                    clearTimeout(emitTimeout);
+                    stream.emit("end");
+                    assert.strictEqual(error, null, "Error is not null");
+                }, maxTimeoutToExpectAResponse);
+                try {
+                    await emitter.sendStream(obs, thisCaller, thisCallerEvent, uuid, mockBareFakeStream());
+                }
+                catch { }
+            });
+            it("should call the listener with a stream", async () => {
+                const thisCaller = randomName();
+                const thisCallerEvent = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.fail("Event not received");
+                }, timermaxTimeoutToExpectAResponse);
+                const uuid = await emitter.receiveStream(obs, thisCaller, thisCallerEvent, async (receivedObs, error, stream) => {
+                    clearTimeout(emitTimeout);
+                    stream.emit("end");
+                    assert.strictEqual(typeof stream, typeof mockBareFakeStream(), "Listener called");
+                }, maxTimeoutToExpectAResponse);
+                try {
+                    await emitter.sendStream(obs, thisCaller, thisCallerEvent, uuid, mockBareFakeStream());
+                }
+                catch { }
+            });
+        });
+        describe("sendStream triggers receiveStream files", function () {
+            this.timeout(120000);
+            const runTest = async (size, count = 1) => {
+                it(`should be able to fully stream a file - ${size}`, async function () {
+                    this.timeout(120000);
+                    const thisCaller = randomName();
+                    const thisCallerEvent = randomName();
+                    const obs = createTestObservable();
+                    const fileName = `./test-file-${size}`;
+                    const fileNameOut = fileName + "-out";
+                    try {
+                        await createTestFile(fileName, size);
+                        const srcFileHash = await getFileHash(fileName);
+                        const emitTimeout = setTimeout(() => {
+                            assert.fail("Event not received");
+                        }, timermaxTimeoutToExpectAResponse);
+                        const uuid = await emitter.receiveStream(obs, thisCaller, thisCallerEvent, async (receivedObs, error, stream) => {
+                            if (error) {
+                                return assert.fail(error);
+                            }
+                            clearTimeout(emitTimeout);
+                            pipeline(stream, fs.createWriteStream(fileNameOut), (errf) => {
+                                if (errf) {
+                                    assert.fail(errf);
+                                }
+                            });
+                        }, maxTimeoutToExpectAResponse);
+                        await emitter.sendStream(obs, thisCaller, thisCallerEvent, uuid, fs.createReadStream(fileName));
+                        fs.unlinkSync(fileName);
+                        assert.strictEqual(await getFileHash(fileNameOut), srcFileHash, "Validate data equals");
+                        fs.unlinkSync(fileNameOut);
+                    }
+                    catch (xx) {
+                        if (fs.existsSync(fileName)) {
+                            fs.unlinkSync(fileName);
+                        }
+                        if (fs.existsSync(fileNameOut)) {
+                            fs.unlinkSync(fileNameOut);
+                        }
+                        assert.fail(xx.toString());
+                    }
+                });
+            };
+            runTest("1KB");
+            runTest("16KB");
+            runTest("128KB");
+            runTest("512KB");
+            runTest("1MB");
+            runTest("16MB");
+        });
+    });
+}

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

@@ -0,0 +1,2 @@
+import { BSBEventsRef } from "@bsb/base";
+export declare const RunEventsPluginTests: (eventsPlugin: typeof BSBEventsRef, config?: any) => void;

package/lib/tests/plugins/events/plugin.js

@@ -0,0 +1,47 @@
+import { Plugin } from "../../../plugins/events-rabbitmq/index.js";
+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 { getEventsConstructorConfig } from "../../mocks.js";
+import { createTestObservable } from "../../trace.js";
+export const RunEventsPluginTests = (eventsPlugin, config = undefined) => {
+    broadcast(async () => {
+        const refP = new eventsPlugin(getEventsConstructorConfig(config));
+        if (refP.init !== undefined) {
+            await refP.init(createTestObservable());
+        }
+        return refP;
+    }, 30);
+    emit(async () => {
+        const refP = new eventsPlugin(getEventsConstructorConfig(config));
+        if (refP.init !== undefined) {
+            await refP.init(createTestObservable());
+        }
+        return refP;
+    }, 30);
+    emitAndReturn(async () => {
+        const refP = new eventsPlugin(getEventsConstructorConfig(config));
+        if (refP.init !== undefined) {
+            await refP.init(createTestObservable());
+        }
+        return refP;
+    }, 30);
+    emitStreamAndReceiveStream(async () => {
+        const refP = new eventsPlugin(getEventsConstructorConfig(config));
+        if (refP.init !== undefined) {
+            await refP.init(createTestObservable());
+        }
+        return refP;
+    }, 500);
+};
+describe("plugins/events-rabbitmq", () => RunEventsPluginTests(Plugin, {
+    platformKey: null,
+    fatalOnDisconnect: false,
+    prefetch: 10,
+    endpoints: ["amqp://127.0.0.1:5670"],
+    credentials: {
+        username: "guest",
+        password: "guest",
+    },
+}));

package/lib/tests/trace.d.ts

@@ -0,0 +1,4 @@
+import { DTrace } from "@bsb/base";
+import { Observable } from "@bsb/base";
+export declare function createFakeDTrace(trace?: string, span?: string): DTrace;
+export declare function createTestObservable(trace?: string, span?: string, pluginName?: string): Observable;

package/lib/tests/trace.js

@@ -0,0 +1,39 @@
+import { PluginObservable } from "@bsb/base";
+export function createFakeDTrace(trace, span) {
+    return {
+        t: trace ?? "",
+        s: span ?? "",
+    };
+}
+export function createTestObservable(trace, span, pluginName = "test-plugin") {
+    const dTrace = createFakeDTrace(trace ?? "test-trace", span ?? "test-span");
+    const resource = {
+        "service.name": pluginName,
+        "service.version": "1.0.0-test",
+        "service.instance.id": "test-instance",
+        "deployment.environment": "test",
+    };
+    const backend = {
+        debug: () => { },
+        info: () => { },
+        warn: () => { },
+        error: () => { },
+        createCounter: () => ({ increment: () => { } }),
+        createGauge: () => ({ set: () => { }, increment: () => { }, decrement: () => { } }),
+        createHistogram: () => ({ record: () => { } }),
+        createTimer: () => ({ stop: () => 0 }),
+        createTrace: () => ({
+            id: "test-trace-id",
+            trace: createFakeDTrace("test-trace", "test-span"),
+            error: () => { },
+            end: () => { },
+        }),
+        createSpan: (parentTrace, name) => ({
+            id: "child-span-" + name,
+            trace: createFakeDTrace(parentTrace.t, "child-span-" + name),
+            error: () => { },
+            end: () => { },
+        }),
+    };
+    return new PluginObservable(dTrace, resource, backend, {});
+}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@bsb/events-rabbitmq",
+  "version": "0.0.1",
+  "type": "module",
+  "license": "(AGPL-3.0-only OR Commercial)",
+  "author": {
+    "name": "BetterCorp (PTY) Ltd",
+    "email": "ninja@bettercorp.dev",
+    "url": "https://bettercorp.dev/"
+  },
+  "description": "RabbitMQ events plugin for BSB - distributed event bus using RabbitMQ",
+  "keywords": [
+    "bsb",
+    "events",
+    "rabbitmq",
+    "amqp",
+    "event-bus",
+    "distributed"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BetterCorp/better-service-base",
+    "directory": "plugins/nodejs/events-rabbitmq"
+  },
+  "main": "lib/plugins/events-rabbitmq/index.js",
+  "types": "lib/plugins/events-rabbitmq/index.d.ts",
+  "files": [
+    "lib/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "clean": "bsb-plugin-cli clean",
+    "build": "bsb-plugin-cli build",
+    "start": "bsb-plugin-cli start",
+    "dev": "bsb-plugin-cli dev",
+    "test": "bsb-plugin-cli test",
+    "publish:client": "bsb client publish",
+    "lint": "eslint src/ --ext .js,.jsx,.ts,.tsx",
+    "prepublishOnly": "npm run build",
+    "test:run": "cross-env TS_NODE_PROJECT=tsconfig.test.json NODE_OPTIONS= mocha --reporter json --reporter-options output=junit.json",
+    "testDev": "cross-env TS_NODE_PROJECT=tsconfig.test.json NODE_OPTIONS= mocha"
+  },
+  "peerDependencies": {
+    "@bsb/base": "^9.1.11"
+  },
+  "dependencies": {
+    "amqp-connection-manager": "^5.0.0",
+    "amqplib": "^2.0.1",
+    "anyvali": "^1.0.6"
+  },
+  "devDependencies": {
+    "@bsb/base": "^9.1.11",
+    "@types/amqplib": "^0.10.4",
+    "@types/mocha": "^10.0.6",
+    "@types/node": "^25.6.0",
+    "@typescript-eslint/eslint-plugin": "^8.54.0",
+    "@typescript-eslint/parser": "^8.54.0",
+    "cross-env": "^10.1.0",
+    "eslint": "^9.39.2",
+    "mocha": "^11.7.6",
+    "rimraf": "^6.1.2",
+    "typescript": "^6.0.3"
+  },
+  "engines": {
+    "node": ">=24.0.0",
+    "npm": ">=11.0.0"
+  },
+  "homepage": "https://io.bsbcode.dev/packages/nodejs/@bsb/events-rabbitmq"
+}