Publish recorded events at the CourseCreator

Author: vilasmaciel

package-lock.json

@@ -40,7 +40,7 @@
     "mandrill-api": "^1.0.45",
     "node-dependency-injection": "^2.4.2",
     "ts-node": "^8.3.0",
-    "typescript": "^3.4.5",
+    "typescript": "^3.7.2",
     "uuid": "^3.3.3",
     "winston": "^3.2.1"
   },

package.json

@@ -1,16 +1,24 @@
 import CourseRepository from '../domain/CourseRepository';
 import Course from '../domain/Course';
+import { CourseId } from '../domain/CourseId';
+import { CourseName } from '../domain/CourseName';
+import { CourseDuration } from '../domain/CourseDuration';
+import { EventBus } from '../../../Shared/domain/EventBus';
 
 export default class CourseCreator {
   private repository: CourseRepository;
+  private eventBus: EventBus;
 
-  constructor(repository: CourseRepository) {
+  constructor(repository: CourseRepository, eventBus: EventBus) {
     this.repository = repository;
+    this.eventBus = eventBus;
   }
 
-  async run(id: string, name: string, duration: string): Promise<void> {
+  async run(id: CourseId, name: CourseName, duration: CourseDuration): Promise<void> {
     const course = new Course(id, name, duration);
 
-    return this.repository.save(course);
+    await this.repository.save(course);
+
+    this.eventBus.publish(course.pullDomainEvents());
   }
 }

src/Contexts/Mooc/Courses/application/CourseCreator.ts

@@ -0,0 +1,17 @@
+import { DomainEvent } from '../../../Shared/domain/DomainEvent';
+
+export abstract class AggregateRoot {
+  private domainEvents: Array<DomainEvent>;
+
+  constructor() {
+    this.domainEvents = [];
+  }
+
+  pullDomainEvents(): Array<DomainEvent> {
+    return this.domainEvents;
+  }
+
+  record(event: DomainEvent): void {
+    this.domainEvents.push(event);
+  }
+}

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

@@ -1,11 +1,32 @@
-export default class Course {
-  readonly id: string;
-  readonly name: string;
-  readonly duration: string;
+import { AggregateRoot } from './AggregateRoot';
+import { CourseCreatedDomainEvent } from './CourseCreatedDomainEvent';
+import { CourseId } from './CourseId';
+import { CourseName } from './CourseName';
+import { CourseDuration } from './CourseDuration';
 
-  constructor(id: string, name: string, duration: string) {
+export default class Course extends AggregateRoot {
+  readonly id: CourseId;
+  readonly name: CourseName;
+  readonly duration: CourseDuration;
+
+  constructor(id: CourseId, name: CourseName, duration: CourseDuration) {
+    super();
     this.id = id;
     this.name = name;
     this.duration = duration;
   }
+
+  static create(id: CourseId, name: CourseName, duration: CourseDuration): Course {
+    const course = new Course(id, name, duration);
+
+    course.record(
+      new CourseCreatedDomainEvent({
+        id: course.id.value(),
+        duration: course.duration.value(),
+        name: course.name.value()
+      })
+    );
+
+    return course;
+  }
 }

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

@@ -0,0 +1,54 @@
+import { DomainEvent } from '../../../Shared/domain/DomainEvent';
+
+type CreateCourseDomainEventBody = {
+  readonly duration: number;
+  readonly name: string;
+};
+
+export class CourseCreatedDomainEvent extends DomainEvent {
+  static readonly EVENT_NAME = 'course.created';
+
+  readonly duration: number;
+  readonly name: string;
+
+  constructor({
+    id,
+    eventId,
+    duration,
+    name,
+    occurredOn
+  }: {
+    id: string;
+    eventId?: string;
+    duration: number;
+    name: string;
+    occurredOn?: Date;
+  }) {
+    super(CourseCreatedDomainEvent.EVENT_NAME, id, eventId, occurredOn);
+    this.duration = duration;
+    this.name = name;
+  }
+
+  toPrimitive(): CreateCourseDomainEventBody {
+    const { name, duration } = this;
+    return {
+      name,
+      duration
+    };
+  }
+
+  static fromPrimitive(
+    aggregateId: string,
+    body: CreateCourseDomainEventBody,
+    eventId: string,
+    occurredOn: Date
+  ): CourseCreatedDomainEvent {
+    return new CourseCreatedDomainEvent({
+      id: aggregateId,
+      duration: body.duration,
+      name: body.name,
+      eventId,
+      occurredOn
+    });
+  }
+}

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

@@ -0,0 +1,3 @@
+import { ValueObject } from '../../../Shared/domain/ValueObject';
+
+export class CourseDuration extends ValueObject<number> {}

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

@@ -0,0 +1,3 @@
+import { ValueObject } from '../../../Shared/domain/ValueObject';
+
+export class CourseId extends ValueObject<string> {}

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

@@ -0,0 +1,3 @@
+import { ValueObject } from '../../../Shared/domain/ValueObject';
+
+export class CourseName extends ValueObject<string> {}

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

@@ -8,7 +8,7 @@ export default class FileCourseRepository implements CourseRepository {
   private FILE_PATH = `${__dirname}/courses`;
 
   async save(course: Course): Promise<void> {
-    const filePath = this.filePath(course.id);
+    const filePath = this.filePath(course.id.value());
     const data = BSON.serialize(course);
 
    return fs.writeFileSync(filePath, data);