A bit of refactor and better types

Created the DomainEventClass to reflect that each DomainEvent
constructor has that type. To do that DomainEvent has been extended
with the static properties that will be accesed in each DomainEvent
class.

Author: davidmatas

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

@@ -1,3 +1,4 @@
+import { DomainEventClass } from '../../../../Shared/domain/DomainEvent';
 import { DomainEventSubscriber } from '../../../../Shared/domain/DomainEventSubscriber';
 import { CourseCreatedDomainEvent } from '../../../Courses/domain/CourseCreatedDomainEvent';
 import { CourseId } from '../../../Shared/domain/Courses/CourseId';
@@ -6,7 +7,7 @@ import { CoursesCounterIncrementer } from './CoursesCounterIncrementer';
 export class IncrementCoursesCounterOnCourseCreated implements DomainEventSubscriber<CourseCreatedDomainEvent> {
   constructor(private incrementer: CoursesCounterIncrementer) {}
 
-  subscribedTo(): any[] {
+  subscribedTo(): DomainEventClass[] {
     return [CourseCreatedDomainEvent];
   }
 

src/Contexts/Shared/domain/DomainEvent.ts

@@ -1,6 +1,8 @@
 import { Uuid } from './value-object/Uuid';
 
 export abstract class DomainEvent {
+  static EVENT_NAME: string;
+  static fromPrimitives: (...args: any[]) => any;
   readonly aggregateId: string;
   readonly eventId: string;
   readonly occurredOn: Date;
@@ -15,3 +17,5 @@ export abstract class DomainEvent {
 
   abstract toPrimitive(): Object;
 }
+
+export type DomainEventClass = Partial<typeof DomainEvent>;

src/Contexts/Shared/domain/DomainEventSubscriber.ts

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

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

@@ -17,7 +17,7 @@ export class DomainEventJsonDeserializer {
       throw new Error(`The event ${eventName} doesn't exist or has no subscribers`);
     }
 
-    return eventClass.fromPrimitives(
+    return eventClass.fromPrimitives!(
       eventData.attributes.id,
       eventData.attributes,
       eventData.id,

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

@@ -1,21 +1,36 @@
+import { DomainEventClass } from '../../domain/DomainEvent';
 import { DomainEventSubscriber } from '../../domain/DomainEventSubscriber';
 
+type Mapping = Map<string, DomainEventClass>;
+
 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;
-    }, {});
+  mapping: Mapping;
+
+  constructor(mapping: DomainEventSubscriber<any>[]) {
+    this.mapping = mapping.reduce(this.eventsExtractor(), new Map<string, DomainEventClass>());
+  }
+
+  private eventsExtractor() {
+    return (map: Mapping, subscriber: DomainEventSubscriber<any>) => {
+      subscriber.subscribedTo().forEach(this.eventNameExtractor(map));
+      return map;
+    };
   }
 
-  for(name: string) {
-    if (!this.mapping[name]) {
+  private eventNameExtractor(map: Mapping): (domainEvent: DomainEventClass) => void {
+    return domainEvent => {
+      const eventName = domainEvent.EVENT_NAME!;
+      map.set(eventName, domainEvent);
+    };
+  }
+
+  for(name: string): DomainEventClass {
+    const domainEvent = this.mapping.get(name);
+
+    if (!domainEvent) {
       throw new Error(`The Domain Event Class for ${name} doesn't exists or have no subscribers`);
     }
-    return this.mapping[name];
+
+    return domainEvent;
   }
 }

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

@@ -17,7 +17,7 @@ export class EventEmitterBus extends EventEmitter {
 
   private registerSubscriber(subscriber: DomainEventSubscriber<DomainEvent>) {
     subscriber.subscribedTo().map(event => {
-      this.on(event.EVENT_NAME, subscriber.on);
+      this.on(event.EVENT_NAME!, subscriber.on);
     });
   }
 

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

@@ -27,7 +27,9 @@ export class InMemorySyncEventBus implements EventBus {
   }
 
   addSubscribers(subscribers: Array<DomainEventSubscriber<DomainEvent>>) {
-    subscribers.map(subscriber => subscriber.subscribedTo().map(event => this.subscribe(event.EVENT_NAME, subscriber)));
+    subscribers.map(subscriber =>
+      subscriber.subscribedTo().map(event => this.subscribe(event.EVENT_NAME!, subscriber))
+    );
   }
 
   private subscribe(topic: string, subscriber: DomainEventSubscriber<DomainEvent>): void {