@theshelf/eventbroker 0.0.1

package/README.md

@@ -0,0 +1,61 @@
+
+# Event Broker | The Shelf
+
+The event broker package provides a universal interaction layer with an actual event broker solution.
+
+This package is based on a publish / subscribe model.
+
+## Installation
+
+```bash
+npm install @theshelf/eventbroker
+```
+
+## Implementations
+
+Currently, there is only one implementation:
+
+* **Memory** - non-persistent event broker based on the Node.js `EventEmitter`.
+
+We have plans to add a Kafka implementation later on.
+
+## Configuration
+
+The used implementation needs to be configured in the `.env` file.
+
+```env
+EVENT_BROKER_IMPLEMENTATION="memory"
+```
+
+## How to use
+
+An instance of the configured event broker implementation can be imported for performing event operations.
+
+```ts
+import eventBroker from '@theshelf/eventbroker';
+
+// Perform operations with the eventBroker instance
+```
+
+### Operations
+
+```ts
+import eventBroker, { Publication, Subscription } from '@theshelf/eventbroker';
+
+// Open connection
+await eventBroker.connect();
+
+// Close connection
+await eventBroker.disconnect();
+
+// Subscribe to an event
+const subscription: Subscription = { channel: 'post', name: 'updated', handler: (postId: string) => { ... } };
+await eventBroker.subscribe(subscription);
+
+// Publish an event
+const publication: Publication = { channel: 'post', name: 'updated', data: { postId: '123' } };
+await eventBroker.publish(publication);
+
+// Unsubscribe from an event
+await eventBroker.unsubscribe(subscription);
+```

package/dist/EventBroker.d.ts

@@ -0,0 +1,13 @@
+import type { Driver } from './definitions/interfaces';
+import type { Publication, Subscription } from './definitions/types';
+export default class EventBroker implements Driver {
+    #private;
+    constructor(driver: Driver);
+    get connected(): boolean;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    publish<T>(publication: Publication<T>): Promise<void>;
+    subscribe<T>(subscription: Subscription<T>): Promise<void>;
+    unsubscribe<T>(subscription: Subscription<T>): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/EventBroker.js

@@ -0,0 +1,25 @@
+export default class EventBroker {
+    #driver;
+    constructor(driver) {
+        this.#driver = driver;
+    }
+    get connected() { return this.#driver.connected; }
+    connect() {
+        return this.#driver.connect();
+    }
+    disconnect() {
+        return this.#driver.disconnect();
+    }
+    publish(publication) {
+        return this.#driver.publish(publication);
+    }
+    subscribe(subscription) {
+        return this.#driver.subscribe(subscription);
+    }
+    unsubscribe(subscription) {
+        return this.#driver.unsubscribe(subscription);
+    }
+    clear() {
+        return this.#driver.clear();
+    }
+}

package/dist/definitions/interfaces.d.ts

@@ -0,0 +1,10 @@
+import type { Publication, Subscription } from './types';
+export interface Driver {
+    get connected(): boolean;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    publish<T>(publication: Publication<T>): Promise<void>;
+    subscribe<T>(subscription: Subscription<T>): Promise<void>;
+    unsubscribe<T>(subscription: Subscription<T>): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/definitions/interfaces.js

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

package/dist/definitions/types.d.ts

@@ -0,0 +1,11 @@
+export type Event = {
+    channel: string;
+    name: string;
+};
+export type EventHandler<T> = (data: T) => void;
+export type Publication<T> = Event & {
+    data?: T;
+};
+export type Subscription<T> = Event & {
+    handler: EventHandler<T>;
+};

package/dist/definitions/types.js

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

package/dist/errors/EventBrokerError.d.ts

@@ -0,0 +1,2 @@
+export default class EventBrokerError extends Error {
+}

package/dist/errors/EventBrokerError.js

@@ -0,0 +1,2 @@
+export default class EventBrokerError extends Error {
+}

package/dist/errors/UnknownImplementation.d.ts

@@ -0,0 +1,4 @@
+import EventBrokerError from './EventBrokerError';
+export default class UnknownImplementation extends EventBrokerError {
+    constructor(name: string);
+}

package/dist/errors/UnknownImplementation.js

@@ -0,0 +1,6 @@
+import EventBrokerError from './EventBrokerError';
+export default class UnknownImplementation extends EventBrokerError {
+    constructor(name) {
+        super(`Unknown event broker implementation: ${name}`);
+    }
+}

package/dist/implementation.d.ts

@@ -0,0 +1,3 @@
+import type { Driver } from './definitions/interfaces';
+declare const _default: Driver;
+export default _default;

package/dist/implementation.js

@@ -0,0 +1,12 @@
+import UnknownImplementation from './errors/UnknownImplementation';
+import createMemoryBroker from './implementations/memory/create';
+const implementations = new Map([
+    ['memory', createMemoryBroker]
+]);
+const DEFAULT_BROKER_IMPLEMENTATION = 'memory';
+const implementationName = process.env.EVENT_BROKER_IMPLEMENTATION ?? DEFAULT_BROKER_IMPLEMENTATION;
+const creator = implementations.get(implementationName.toLowerCase());
+if (creator === undefined) {
+    throw new UnknownImplementation(implementationName);
+}
+export default creator();

package/dist/implementations/memory/Memory.d.ts

@@ -0,0 +1,12 @@
+import type { Driver } from '../../definitions/interfaces';
+import type { Publication, Subscription } from '../../definitions/types';
+export default class Memory implements Driver {
+    #private;
+    get connected(): boolean;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    publish<T>(publication: Publication<T>): Promise<void>;
+    subscribe<T>(subscription: Subscription<T>): Promise<void>;
+    unsubscribe<T>(subscription: Subscription<T>): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/implementations/memory/Memory.js

@@ -0,0 +1,33 @@
+import { EventEmitter } from 'node:events';
+export default class Memory {
+    #emitters = new Map();
+    #connected = false;
+    get connected() { return this.#connected; }
+    async connect() {
+        this.#connected = true;
+    }
+    async disconnect() {
+        this.#connected = false;
+    }
+    async publish(publication) {
+        const emitter = this.#getEmitter(publication);
+        emitter.emit(publication.name, publication.data);
+    }
+    async subscribe(subscription) {
+        const emitter = this.#getEmitter(subscription);
+        emitter.on(subscription.name, subscription.handler);
+    }
+    async unsubscribe(subscription) {
+        const emitter = this.#getEmitter(subscription);
+        emitter.off(subscription.name, subscription.handler);
+    }
+    async clear() {
+        this.#emitters.clear();
+    }
+    #getEmitter(event) {
+        if (this.#emitters.has(event.channel) === false) {
+            this.#emitters.set(event.channel, new EventEmitter());
+        }
+        return this.#emitters.get(event.channel);
+    }
+}

package/dist/implementations/memory/create.d.ts

@@ -0,0 +1,2 @@
+import Memory from './Memory';
+export default function create(): Memory;

package/dist/implementations/memory/create.js

@@ -0,0 +1,4 @@
+import Memory from './Memory';
+export default function create() {
+    return new Memory();
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import EventBroker from './EventBroker';
+declare const eventBroker: EventBroker;
+export * from './definitions/types';
+export type { EventBroker };
+export default eventBroker;

package/dist/index.js

@@ -0,0 +1,5 @@
+import EventBroker from './EventBroker';
+import implementation from './implementation';
+const eventBroker = new EventBroker(implementation);
+export * from './definitions/types';
+export default eventBroker;

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@theshelf/eventbroker",
+  "private": false,
+  "version": "0.0.1",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "clean": "rimraf dist",
+    "test": "vitest run",
+    "test-coverage": "vitest run --coverage",
+    "lint": "eslint",
+    "review": "npm run build && npm run lint && npm run test",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "files": [
+    "README.md",
+    "dist"
+  ],
+  "types": "dist/index.d.ts",
+  "exports": "./dist/index.js"
+}