@theshelf/eventbroker 0.3.2 → 0.4.1

package/README.md

@@ -1,9 +1,7 @@
 
-# Event Broker | The Shelf
+# Event Broker core | 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.
+This package contains the publication / subscription model. It uses a interchangeable driver system for performing the actual operations. An in-memory driver is included.
 
 ## Installation
 
@@ -11,37 +9,23 @@ This package is based on a publish / subscribe model.
 npm install @theshelf/eventbroker
 ```
 
-## Driver
-
-Currently, there is only one driver available:
-
-* **Memory** - non-persistent event broker based on the Node.js `EventEmitter`.
-
-We have plans to add a Kafka driver later on.
-
 ## How to use
 
 The basic set up looks like this.
 
 ```ts
-import EventBroker, { MemoryDriver as SelectedDriver } from '@theshelf/eventbroker';
+import EventBroker, { MemoryDriver } from '@theshelf/eventbroker';
 
-const driver = new SelectedDriver(/* configuration */);
+const driver = new MemoryDriver();
 const eventBroker = new EventBroker(driver);
 
 // Perform operations with the eventBroker instance
 ```
 
-### Configuration
-
-#### Memory driver
-
-No configuration options.
-
-### Operations
+## Operations
 
 ```ts
-import { Publication, Subscription } from '@theshelf/eventbroker';
+import type { Publication, Subscription } from '@theshelf/eventbroker';
 
 // Open connection
 await eventBroker.connect();
@@ -60,3 +44,42 @@ await eventBroker.publish(publication);
 // Unsubscribe from an event
 await eventBroker.unsubscribe(subscription);
 ```
+
+## Types
+
+The publication has the following structure.
+
+```ts
+type Publication<T> = {
+    channel: string;
+    name: string;
+    data?: T
+}
+```
+
+The subscription has the following structure.
+
+```ts
+type Subscription<T> = {
+    channel: string;
+    name: string;
+    handler: EventHandler<T>;
+}
+```
+
+Where the event handler performs an operation on the data of the publication.
+
+```ts
+type EventHandler<T> = (data: T) => void;
+```
+
+## Drivers
+
+### Memory
+
+In-memory event broker (suited for testing). It doesn't have any configuration options, but has an additional operation.
+
+```ts
+// Clear the memory
+driver.clear();
+```

package/dist/EventBroker.d.ts

@@ -1,8 +1,9 @@
+import type Logger from '@theshelf/logging';
 import type { Driver } from './definitions/interfaces.js';
 import type { Publication, Subscription } from './definitions/types.js';
-export default class EventBroker implements Driver {
+export default class EventBroker {
     #private;
-    constructor(driver: Driver);
+    constructor(driver: Driver, logger?: Logger);
     get connected(): boolean;
     connect(): Promise<void>;
     disconnect(): Promise<void>;

package/dist/EventBroker.js

@@ -1,24 +1,78 @@
+import NotConnected from './errors/NotConnected.js';
 export default class EventBroker {
     #driver;
-    constructor(driver) {
+    #logger;
+    #logPrefix;
+    constructor(driver, logger) {
         this.#driver = driver;
+        this.#logger = logger?.for(EventBroker.name);
+        this.#logPrefix = `${this.#driver.name} ->`;
     }
     get connected() {
         return this.#driver.connected;
     }
-    connect() {
-        return this.#driver.connect();
+    async connect() {
+        if (this.connected === true) {
+            return;
+        }
+        this.#logger?.debug(this.#logPrefix, 'Connecting');
+        try {
+            await this.#driver.connect();
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Connect failed with error', error);
+            throw error;
+        }
     }
-    disconnect() {
-        return this.#driver.disconnect();
+    async disconnect() {
+        if (this.connected === false) {
+            return;
+        }
+        this.#logger?.debug(this.#logPrefix, 'Disconnecting');
+        try {
+            return await this.#driver.disconnect();
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Disconnect failed with error', error);
+            throw error;
+        }
     }
-    publish(publication) {
-        return this.#driver.publish(publication);
+    async publish(publication) {
+        this.#logger?.debug(this.#logPrefix, 'Publishing to', publication.channel, '->', publication.name);
+        try {
+            this.#validateConnection();
+            return await this.#driver.publish(publication);
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Publish to', publication.channel, '->', publication.name, 'failed with error', error);
+            throw error;
+        }
     }
-    subscribe(subscription) {
-        return this.#driver.subscribe(subscription);
+    async subscribe(subscription) {
+        this.#logger?.debug(this.#logPrefix, 'Subscribing to', subscription.channel, '->', subscription.name);
+        try {
+            this.#validateConnection();
+            return await this.#driver.subscribe(subscription);
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Subscribe to', subscription.channel, '->', subscription.name, 'failed with error', error);
+            throw error;
+        }
     }
-    unsubscribe(subscription) {
-        return this.#driver.unsubscribe(subscription);
+    async unsubscribe(subscription) {
+        this.#logger?.debug(this.#logPrefix, 'Unsubscribing from', subscription.channel, '->', subscription.name);
+        try {
+            this.#validateConnection();
+            return await this.#driver.unsubscribe(subscription);
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Unsubscribe from', subscription.channel, '->', subscription.name, 'failed with error', error);
+            throw error;
+        }
+    }
+    #validateConnection() {
+        if (this.connected === false) {
+            throw new NotConnected();
+        }
     }
 }

package/dist/definitions/interfaces.d.ts

@@ -1,5 +1,6 @@
 import type { Publication, Subscription } from './types.js';
 export interface Driver {
+    get name(): string;
     get connected(): boolean;
     connect(): Promise<void>;
     disconnect(): Promise<void>;

package/dist/drivers/Memory.d.ts

@@ -3,6 +3,7 @@ import type { Driver } from '../definitions/interfaces.js';
 import type { Publication, Subscription } from '../definitions/types.js';
 export default class Memory implements Driver {
     #private;
+    get name(): string;
     get connected(): boolean;
     get emitters(): Map<string, EventEmitter>;
     connect(): Promise<void>;

package/dist/drivers/Memory.js

@@ -3,6 +3,7 @@ import NotConnected from '../errors/NotConnected.js';
 export default class Memory {
     #emitters = new Map();
     #connected = false;
+    get name() { return Memory.name; }
     get connected() { return this.#connected; }
     get emitters() {
         if (this.#connected === false) {

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@theshelf/eventbroker",
   "private": false,
-  "version": "0.3.2",
+  "version": "0.4.1",
   "type": "module",
   "repository": {
     "url": "git+https://github.com/MaskingTechnology/theshelf.git"
   },
+  "license": "MIT",
   "scripts": {
     "build": "tsc",
     "clean": "rimraf dist",
@@ -19,6 +20,6 @@
     "README.md",
     "dist"
   ],
-  "types": "dist/index.d.ts",
+  "types": "./dist/index.d.ts",
   "exports": "./dist/index.js"
 }