Implementing DomainEventJsonDeserializer and DomainEventMapping

Description:

- DomainEventJsonDeserializer.

 Is in charge of converting a string event to a DomainEvent.

- DomainEventMapping

It is a collaborator of DomainEventJsonDeserializer. It has the
information about the relation between event types and DomainEvents in a
map. This map has been constructed dinamically (using the DI) calling
the subscribedTo method for the subscribers. So, it treats subscribers
as the source of truth.
________________________________________________________________________

There are more work to do in the next commits:

- Rethink the types, a huge amount of types with any right now
- DomainEvent is receiving the name as param in the constructor but
probably it won't be needed. That would allow to only declare an
abstract method that will be implemented in each DomainEvent.

Author: davidmatas

src/Contexts/Mooc/Courses/domain/CourseCreatedDomainEvent.ts

@@ -13,9 +13,9 @@ export class CourseCreatedDomainEvent extends DomainEvent {
 
   constructor({
     id,
-    eventId,
-    duration,
     name,
+    duration,
+    eventId,
     occurredOn
   }: {
     id: string;
@@ -42,7 +42,7 @@ export class CourseCreatedDomainEvent extends DomainEvent {
     body: CreateCourseDomainEventBody,
     eventId: string,
     occurredOn: Date
-  ): CourseCreatedDomainEvent {
+  ): DomainEvent {
     return new CourseCreatedDomainEvent({
       id: aggregateId,
       duration: body.duration,

src/Contexts/Mooc/CoursesCounter/application/Increment/IncrementCoursesCounterOnCourseCreated.ts

@@ -1,13 +1,13 @@
 import { DomainEventSubscriber } from '../../../../Shared/domain/DomainEventSubscriber';
 import { CourseCreatedDomainEvent } from '../../../Courses/domain/CourseCreatedDomainEvent';
-import { CoursesCounterIncrementer } from './CoursesCounterIncrementer';
 import { CourseId } from '../../../Shared/domain/Courses/CourseId';
+import { CoursesCounterIncrementer } from './CoursesCounterIncrementer';
 
 export class IncrementCoursesCounterOnCourseCreated implements DomainEventSubscriber<CourseCreatedDomainEvent> {
   constructor(private incrementer: CoursesCounterIncrementer) {}
 
-  subscribedTo(): string[] {
-    return [CourseCreatedDomainEvent.EVENT_NAME];
+  subscribedTo(): any[] {
+    return [CourseCreatedDomainEvent];
   }
 
   async on(domainEvent: CourseCreatedDomainEvent) {

src/Contexts/Shared/domain/DomainEventSubscriber.ts

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

src/Contexts/Shared/infrastructure/EventBus/DomainEventJsonDeserializer.ts

@@ -0,0 +1,27 @@
+import { DomainEvent } from '../../domain/DomainEvent';
+import { DomainEventMapping } from './DomainEventMapping';
+
+export class DomainEventJsonDeserializer {
+  private mapping: DomainEventMapping;
+
+  constructor(mapping: DomainEventMapping) {
+    this.mapping = mapping;
+  }
+
+  deserialize(event: string): DomainEvent {
+    const eventData = JSON.parse(event).data;
+    const eventName = eventData.type;
+    const eventClass = this.mapping.for(eventName);
+
+    if (!eventClass) {
+      throw new Error(`The event ${eventName} doesn't exist or has no subscribers`);
+    }
+
+    return eventClass.fromPrimitives(
+      eventData.attributes.id,
+      eventData.attributes,
+      eventData.id,
+      eventData.occurred_on
+    );
+  }
+}

src/Contexts/Shared/infrastructure/EventBus/DomainEventMapping.ts

@@ -0,0 +1,21 @@
+import { DomainEventSubscriber } from '../../domain/DomainEventSubscriber';
+
+export class DomainEventMapping {
+  mapping: any;
+
+  constructor(mapping: any) {
+    this.mapping = mapping.reduce((prev: any, subscriber: DomainEventSubscriber<any>) => {
+      subscriber.subscribedTo().forEach(event => {
+        prev[event.EVENT_NAME] = event;
+      });
+      return prev;
+    }, {});
+  }
+
+  for(name: string) {
+    if (!this.mapping[name]) {
+      throw new Error(`The Domain Event Class for ${name} doesn't exists or have no subscribers`);
+    }
+    return this.mapping[name];
+  }
+}

src/Contexts/Shared/infrastructure/EventBus/EventEmitterBus.ts

@@ -1,6 +1,6 @@
+import { EventEmitter } from 'events';
 import { DomainEvent } from '../../domain/DomainEvent';
 import { DomainEventSubscriber } from '../../domain/DomainEventSubscriber';
-import { EventEmitter } from 'events';
 
 export class EventEmitterBus extends EventEmitter {
   constructor(subscribers: Array<DomainEventSubscriber<DomainEvent>>) {
@@ -17,7 +17,7 @@ export class EventEmitterBus extends EventEmitter {
 
   private registerSubscriber(subscriber: DomainEventSubscriber<DomainEvent>) {
     subscriber.subscribedTo().map(event => {
-      this.on(event, subscriber.on);
+      this.on(event.EVENT_NAME, subscriber.on);
     });
   }
 

src/Contexts/Shared/infrastructure/EventBus/InMemorySyncEventBus.ts

@@ -1,6 +1,6 @@
-import { EventBus } from '../../domain/EventBus';
 import { DomainEvent } from '../../domain/DomainEvent';
 import { DomainEventSubscriber } from '../../domain/DomainEventSubscriber';
+import { EventBus } from '../../domain/EventBus';
 
 type Subscription = {
   boundedCallback: Function;
@@ -27,7 +27,7 @@ export class InMemorySyncEventBus implements EventBus {
   }
 
   addSubscribers(subscribers: Array<DomainEventSubscriber<DomainEvent>>) {
-    subscribers.map(subscriber => subscriber.subscribedTo().map(event => this.subscribe(event, subscriber)));
+    subscribers.map(subscriber => subscriber.subscribedTo().map(event => this.subscribe(event.EVENT_NAME, subscriber)));
   }
 
   private subscribe(topic: string, subscriber: DomainEventSubscriber<DomainEvent>): void {

src/apps/mooc_backend/config/dependency-injection/Shared/application.yaml

@@ -1,5 +1,4 @@
 services:
-
   Mooc.shared.ConnectionManager:
     factory:
       class: ../../../../../Contexts/Shared/infrastructure/persistence/mongo/MongoClientFactory
@@ -13,3 +12,11 @@ services:
   Mooc.shared.EventBus:
     class: ../../../../../Contexts/Shared/infrastructure/EventBus/InMemoryAsyncEventBus
     arguments: []
+
+  Mooc.shared.EventBus.DomainEventMapping:
+    class: ../../../../../Contexts/Shared/infrastructure/EventBus/DomainEventMapping
+    arguments: ['!tagged domainEventSubscriber']
+
+  Mooc.shared.EventBus.DomainEventJsonDeserializer:
+    class: ../../../../../Contexts/Shared/infrastructure/EventBus/DomainEventJsonDeserializer
+    arguments: ['@Mooc.shared.EventBus.DomainEventMapping']

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

@@ -1,7 +1,7 @@
-import { InMemoryAsyncEventBus } from '../../../../src/Contexts/Shared/infrastructure/EventBus/InMemoryAsyncEventBus';
-import { DomainEventSubscriber } from '../../../../src/Contexts/Shared/domain/DomainEventSubscriber';
 import { DomainEvent } from '../../../../src/Contexts/Shared/domain/DomainEvent';
+import { DomainEventSubscriber } from '../../../../src/Contexts/Shared/domain/DomainEventSubscriber';
 import { Uuid } from '../../../../src/Contexts/Shared/domain/value-object/Uuid';
+import { InMemoryAsyncEventBus } from '../../../../src/Contexts/Shared/infrastructure/EventBus/InMemoryAsyncEventBus';
 
 describe('InMemoryAsyncEventBus', () => {
   let subscriber: DomainEventSubscriberDummy;
@@ -35,8 +35,8 @@ class DummyEvent extends DomainEvent {
 }
 
 class DomainEventSubscriberDummy implements DomainEventSubscriber<DummyEvent> {
-  subscribedTo(): string[] {
-    return [DummyEvent.EVENT_NAME];
+  subscribedTo(): any[] {
+    return [DummyEvent];
   }
 
   async on(domainEvent: DummyEvent) {

tests/apps/mooc_backend/features/step_definitions/evenBus.steps.ts

@@ -1,19 +1,13 @@
 import { Given } from 'cucumber';
 import container from '../../../../../src/apps/mooc_backend/config/dependency-injection';
 import { EventBus } from '../../../../../src/Contexts/Shared/domain/EventBus';
-import { CourseCreatedDomainEvent } from '../../../../../src/Contexts/Mooc/Courses/domain/CourseCreatedDomainEvent';
+import { DomainEventJsonDeserializer } from '../../../../../src/Contexts/Shared/infrastructure/EventBus/DomainEventJsonDeserializer';
 
-Given('I send an event to the event bus:', async (event: any) => {
-  const eventBus = container.get('Mooc.shared.EventBus') as EventBus;
-  const jsonEvent = JSON.parse(event).data;
+const eventBus = container.get('Mooc.shared.EventBus') as EventBus;
+const deserializer = container.get('Mooc.shared.EventBus.DomainEventJsonDeserializer') as DomainEventJsonDeserializer;
 
-  const domainEvent = CourseCreatedDomainEvent.fromPrimitives(
-    jsonEvent.attributes.id,
-    jsonEvent.attributes,
-    jsonEvent.id,
-    jsonEvent.occurred_on
-  );
+Given('I send an event to the event bus:', async (event: any) => {
+  const domainEvent = deserializer.deserialize(event);
 
   await eventBus.publish([domainEvent]);
 });
-