@theshelf/eventbroker 0.0.4 → 0.2.0

package/README.md

@@ -11,36 +11,37 @@ This package is based on a publish / subscribe model.
 npm install @theshelf/eventbroker
 ```
 
-## Implementations
+## Driver
 
-Currently, there is only one implementation:
+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 implementation later on.
-
-## Configuration
-
-The used implementation needs to be configured in the `.env` file.
-
-```env
-EVENT_BROKER_IMPLEMENTATION="memory"
-```
+We have plans to add a Kafka driver later on.
 
 ## How to use
 
-An instance of the configured event broker implementation can be imported for performing event operations.
+The basic set up looks like this.
 
 ```ts
-import eventBroker from '@theshelf/eventbroker';
+import EventBroker, { MemoryDriver as SelectedDriver } from '@theshelf/eventbroker';
+
+const driver = new SelectedDriver(/* configuration */);
+const eventBroker = new EventBroker(driver);
 
 // Perform operations with the eventBroker instance
 ```
 
+### Configuration
+
+#### Memory driver
+
+No configuration options.
+
 ### Operations
 
 ```ts
-import eventBroker, { Publication, Subscription } from '@theshelf/eventbroker';
+import { Publication, Subscription } from '@theshelf/eventbroker';
 
 // Open connection
 await eventBroker.connect();

package/dist/ConnectionManager.d.ts

@@ -0,0 +1,9 @@
+import type { ConnectionState } from './definitions/constants.js';
+import type { Driver } from './definitions/interfaces.js';
+export default class ConnectionManager {
+    #private;
+    constructor(driver: Driver);
+    get state(): ConnectionState;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+}

package/dist/ConnectionManager.js

@@ -0,0 +1,53 @@
+import { ConnectionStates } from './definitions/constants.js';
+export default class ConnectionManager {
+    #driver;
+    #state = ConnectionStates.DISCONNECTED;
+    #connectPromise;
+    #disconnectPromise;
+    constructor(driver) {
+        this.#driver = driver;
+    }
+    get state() { return this.#state; }
+    async connect() {
+        if (this.#connectPromise !== undefined) {
+            return this.#connectPromise;
+        }
+        if (this.#state !== ConnectionStates.DISCONNECTED) {
+            return;
+        }
+        this.#state = ConnectionStates.CONNECTING;
+        try {
+            this.#connectPromise = this.#driver.connect();
+            await this.#connectPromise;
+            this.#state = ConnectionStates.CONNECTED;
+        }
+        catch (error) {
+            this.#state = ConnectionStates.DISCONNECTED;
+            throw error;
+        }
+        finally {
+            this.#connectPromise = undefined;
+        }
+    }
+    async disconnect() {
+        if (this.#disconnectPromise !== undefined) {
+            return this.#disconnectPromise;
+        }
+        if (this.#state !== ConnectionStates.CONNECTED) {
+            return;
+        }
+        this.#state = ConnectionStates.DISCONNECTING;
+        try {
+            this.#disconnectPromise = this.#driver.disconnect();
+            await this.#disconnectPromise;
+            this.#state = ConnectionStates.DISCONNECTED;
+        }
+        catch (error) {
+            this.#state = ConnectionStates.CONNECTED;
+            throw error;
+        }
+        finally {
+            this.#disconnectPromise = undefined;
+        }
+    }
+}

package/dist/EventBroker.d.ts

@@ -1,13 +1,14 @@
+import type { ConnectionState } from './definitions/constants.js';
 import type { Driver } from './definitions/interfaces.js';
 import type { Publication, Subscription } from './definitions/types.js';
 export default class EventBroker implements Driver {
     #private;
     constructor(driver: Driver);
+    get connectionState(): ConnectionState;
     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

@@ -1,14 +1,23 @@
+import { ConnectionStates } from './definitions/constants.js';
+import ConnectionManager from './ConnectionManager.js';
 export default class EventBroker {
     #driver;
+    #connectionManager;
     constructor(driver) {
         this.#driver = driver;
+        this.#connectionManager = new ConnectionManager(driver);
+    }
+    get connectionState() {
+        return this.#connectionManager.state;
+    }
+    get connected() {
+        return this.connectionState === ConnectionStates.CONNECTED;
     }
-    get connected() { return this.#driver.connected; }
     connect() {
-        return this.#driver.connect();
+        return this.#connectionManager.connect();
     }
     disconnect() {
-        return this.#driver.disconnect();
+        return this.#connectionManager.disconnect();
     }
     publish(publication) {
         return this.#driver.publish(publication);
@@ -19,7 +28,4 @@ export default class EventBroker {
     unsubscribe(subscription) {
         return this.#driver.unsubscribe(subscription);
     }
-    clear() {
-        return this.#driver.clear();
-    }
 }

package/dist/definitions/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const ConnectionStates: {
+    readonly DISCONNECTED: "DISCONNECTED";
+    readonly DISCONNECTING: "DISCONNECTING";
+    readonly CONNECTING: "CONNECTING";
+    readonly CONNECTED: "CONNECTED";
+};
+export type ConnectionState = typeof ConnectionStates[keyof typeof ConnectionStates];

package/dist/definitions/constants.js

@@ -0,0 +1,6 @@
+export const ConnectionStates = {
+    DISCONNECTED: 'DISCONNECTED',
+    DISCONNECTING: 'DISCONNECTING',
+    CONNECTING: 'CONNECTING',
+    CONNECTED: 'CONNECTED'
+};

package/dist/definitions/interfaces.d.ts

@@ -6,5 +6,4 @@ export interface Driver {
     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 → drivers}/Memory.d.ts

@@ -1,12 +1,14 @@
-import type { Driver } from '../../definitions/interfaces.js';
-import type { Publication, Subscription } from '../../definitions/types.js';
+import { EventEmitter } from 'node:events';
+import type { Driver } from '../definitions/interfaces.js';
+import type { Publication, Subscription } from '../definitions/types.js';
 export default class Memory implements Driver {
     #private;
     get connected(): boolean;
+    get emitters(): Map<string, EventEmitter>;
     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>;
+    clear(): void;
 }

package/dist/{implementations/memory → drivers}/Memory.js

@@ -1,13 +1,21 @@
 import { EventEmitter } from 'node:events';
+import NotConnected from '../errors/NotConnected.js';
 export default class Memory {
     #emitters = new Map();
     #connected = false;
     get connected() { return this.#connected; }
+    get emitters() {
+        if (this.#connected === false) {
+            throw new NotConnected();
+        }
+        return this.#emitters;
+    }
     async connect() {
         this.#connected = true;
     }
     async disconnect() {
         this.#connected = false;
+        this.#emitters.clear();
     }
     async publish(publication) {
         const emitter = this.#getEmitter(publication);
@@ -21,13 +29,14 @@ export default class Memory {
         const emitter = this.#getEmitter(subscription);
         emitter.off(subscription.name, subscription.handler);
     }
-    async clear() {
-        this.#emitters.clear();
+    clear() {
+        this.emitters.clear();
     }
     #getEmitter(event) {
-        if (this.#emitters.has(event.channel) === false) {
-            this.#emitters.set(event.channel, new EventEmitter());
+        const emitters = this.emitters;
+        if (emitters.has(event.channel) === false) {
+            emitters.set(event.channel, new EventEmitter());
         }
-        return this.#emitters.get(event.channel);
+        return emitters.get(event.channel);
     }
 }

package/dist/errors/EventBrokerError.d.ts

@@ -1,2 +1,3 @@
 export default class EventBrokerError extends Error {
+    constructor(message?: string);
 }

package/dist/errors/EventBrokerError.js

@@ -1,2 +1,9 @@
 export default class EventBrokerError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
 }

package/dist/errors/NotConnected.d.ts

@@ -0,0 +1,4 @@
+import EventBrokerError from './EventBrokerError.js';
+export default class NotConnected extends EventBrokerError {
+    constructor();
+}

package/dist/errors/NotConnected.js

@@ -0,0 +1,6 @@
+import EventBrokerError from './EventBrokerError.js';
+export default class NotConnected extends EventBrokerError {
+    constructor() {
+        super('Event broker not connected');
+    }
+}

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-import EventBroker from './EventBroker.js';
-declare const eventBroker: EventBroker;
-export * from './definitions/types.js';
-export type { EventBroker };
-export default eventBroker;
+export type * from './definitions/interfaces.js';
+export type * from './definitions/types.js';
+export { default as MemoryDriver } from './drivers/Memory.js';
+export { default } from './EventBroker.js';

package/dist/index.js

@@ -1,5 +1,2 @@
-import EventBroker from './EventBroker.js';
-import implementation from './implementation.js';
-const eventBroker = new EventBroker(implementation);
-export * from './definitions/types.js';
-export default eventBroker;
+export { default as MemoryDriver } from './drivers/Memory.js';
+export { default } from './EventBroker.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@theshelf/eventbroker",
   "private": false,
-  "version": "0.0.4",
+  "version": "0.2.0",
   "type": "module",
   "repository": {
     "url": "https://github.com/MaskingTechnology/theshelf"

package/dist/errors/UnknownImplementation.d.ts

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

package/dist/errors/UnknownImplementation.js

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

package/dist/implementation.d.ts

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

package/dist/implementation.js

@@ -1,12 +0,0 @@
-import UnknownImplementation from './errors/UnknownImplementation.js';
-import createMemoryBroker from './implementations/memory/create.js';
-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/create.d.ts

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

package/dist/implementations/memory/create.js

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