Add DomainEvent and EventBus

Author: vilasmaciel

src/Contexts/Shared/domain/DomainEvent.ts

@@ -0,0 +1,17 @@
+export abstract class DomainEvent {
+  readonly id: string;
+  readonly eventId: string;
+  readonly occurredOn: Date;
+
+  constructor({ id }: { id: string }) {
+    this.id = id;
+    this.eventId = '';
+    this.occurredOn = new Date();
+  }
+
+  abstract get eventName(): string;
+
+  abstract toPrimitive(): Object;
+
+  abstract fromPrimitive(): Object;
+}

src/Contexts/Shared/domain/DomainEventSubscriber.ts

@@ -0,0 +1,7 @@
+import { DomainEvent } from './DomainEvent';
+
+export interface DomainEventSubscriber<T extends DomainEvent> {
+  subscribeTo(): Array<string>;
+
+  on(domainEvent: T): void;
+}

src/Contexts/Shared/domain/EventBus.ts

@@ -0,0 +1,5 @@
+import { DomainEvent } from './DomainEvent';
+
+export interface EventBus {
+  publish(events: Array<DomainEvent>): void;
+}

src/Contexts/Shared/infrastructure/EventEmitterBus.ts

@@ -0,0 +1,27 @@
+import { DomainEvent } from '../domain/DomainEvent';
+import { DomainEventSubscriber } from '../domain/DomainEventSubscriber';
+import { EventEmitter } from 'events';
+
+export class EventEmitterBus extends EventEmitter {
+  constructor(subscribers: Array<DomainEventSubscriber<DomainEvent>>) {
+    super();
+
+    this.registerSubscribers(subscribers);
+  }
+
+  private registerSubscribers(subscribers: DomainEventSubscriber<DomainEvent>[]) {
+    subscribers.map(subscriber => {
+      this.registerSubscriber(subscriber);
+    });
+  }
+
+  private registerSubscriber(subscriber: DomainEventSubscriber<DomainEvent>) {
+    subscriber.subscribeTo().map(event => {
+      this.on(event, subscriber.on);
+    });
+  }
+
+  publish(events: DomainEvent[]): void {
+    events.map(event => this.emit(event.eventName, event));
+  }
+}

src/Contexts/Shared/infrastructure/InMemoryAsyncEventBus.ts

@@ -0,0 +1,16 @@
+import { DomainEvent } from '../domain/DomainEvent';
+import { DomainEventSubscriber } from '../domain/DomainEventSubscriber';
+import { EventBus } from '../domain/EventBus';
+import { EventEmitterBus } from './EventEmitterBus';
+
+export class InMemoryAsyncEventBus implements EventBus {
+  private bus: EventEmitterBus;
+
+  constructor(subscribers: Array<DomainEventSubscriber<DomainEvent>>) {
+    this.bus = new EventEmitterBus(subscribers);
+  }
+
+  publish(events: DomainEvent[]): void {
+    this.bus.publish(events);
+  }
+}

tests/Contexts/Shared/infrastructure/InMemoryAsyncEventBus.test.ts

@@ -0,0 +1,49 @@
+import { InMemoryAsyncEventBus } from '../../../../src/Contexts/Shared/infrastructure/InMemoryAsyncEventBus';
+import { DomainEventSubscriber } from '../../../../src/Contexts/Shared/domain/DomainEventSubscriber';
+import { DomainEvent } from '../../../../src/Contexts/Shared/domain/DomainEvent';
+import uuid = require('uuid');
+
+describe('InMemoryAsyncEventBus', () => {
+  let subscriber: DomainEventSubscriberDummy;
+  let eventBus: InMemoryAsyncEventBus;
+
+  beforeAll(() => {});
+
+  it('', done => {
+    const event = new DummyEvent({ id: uuid() });
+    subscriber = new DomainEventSubscriberDummy();
+    subscriber.on = () => {
+      done();
+    };
+
+    eventBus = new InMemoryAsyncEventBus([subscriber]);
+
+    eventBus.publish([event]);
+  });
+});
+
+class DummyEvent extends DomainEvent {
+  static EVENT_NAME = 'dummy:event';
+
+  get eventName(): string {
+    return DummyEvent.EVENT_NAME;
+  }
+
+  toPrimitive(): Object {
+    throw new Error('Method not implemented.');
+  }
+
+  fromPrimitive(): Object {
+    throw new Error('Method not implemented.');
+  }
+}
+
+class DomainEventSubscriberDummy implements DomainEventSubscriber<DummyEvent> {
+  subscribeTo(): string[] {
+    return [DummyEvent.EVENT_NAME];
+  }
+
+  on(domainEvent: DummyEvent): void {
+    console.log(domainEvent);
+  }
+}