Merge pull request #65 from CodelyTV/part_four_command_bus

Part four command bus

Author: ivanportillo

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

@@ -6,6 +6,12 @@ import { CourseName } from '../domain/CourseName';
 import { CourseDuration } from '../domain/CourseDuration';
 import { EventBus } from '../../../Shared/domain/EventBus';
 
+type Params = {
+  courseId: CourseId;
+  courseName: CourseName;
+  courseDuration: CourseDuration;
+};
+
 export class CourseCreator {
   private repository: CourseRepository;
   private eventBus: EventBus;
@@ -15,11 +21,11 @@ export class CourseCreator {
     this.eventBus = eventBus;
   }
 
-  async run(request: CreateCourseRequest): Promise<void> {
+  async run({ courseId, courseName, courseDuration }: Params): Promise<void> {
     const course = Course.create(
-      new CourseId(request.id),
-      new CourseName(request.name),
-      new CourseDuration(request.duration)
+      courseId,
+      courseName,
+      courseDuration
     );
 
     await this.repository.save(course);

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

@@ -0,0 +1,20 @@
+import { Command } from '../../../Shared/domain/Command';
+
+type Params = {
+    id: string;
+    name: string;
+    duration: string;
+};
+
+export class CreateCourseCommand extends Command {
+    id: string;
+    name: string;
+    duration: string;
+
+    constructor({ id, name, duration }: Params) {
+        super();
+        this.id = id;
+        this.name = name;
+        this.duration = duration;
+    }
+}

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

@@ -0,0 +1,22 @@
+import { CreateCourseCommand } from './CreateCourseCommand';
+import { CommandHandler } from '../../../Shared/domain/CommandHandler';
+import { CourseCreator } from './CourseCreator';
+import { Command } from '../../../Shared/domain/Command';
+import { CourseId } from '../../Shared/domain/Courses/CourseId';
+import { CourseName } from '../domain/CourseName';
+import { CourseDuration } from '../domain/CourseDuration';
+
+export class CreateCourseCommandHandler implements CommandHandler<CreateCourseCommand> {
+    constructor(private courseCreator: CourseCreator) {}
+
+    subscribedTo(): Command {
+        return CreateCourseCommand;
+    }
+
+    async handle(command: CreateCourseCommand): Promise<void> {
+        const courseId = new CourseId(command.id);
+        const courseName = new CourseName(command.name);
+        const courseDuration = new CourseDuration(command.duration);
+        await this.courseCreator.run({ courseId, courseName, courseDuration });
+    }
+}

src/Contexts/Shared/domain/Command.ts

@@ -1,3 +1 @@
-export abstract class Command {
-  static COMMAND_NAME: string;
-}
+export abstract class Command {}

src/Contexts/Shared/domain/CommandBus.ts

@@ -1,5 +1,5 @@
 import { Command } from './Command';
 
 export interface CommandBus {
-  dispatch(command: Command): void;
+  dispatch(command: Command): Promise<void>;
 }

src/Contexts/Shared/domain/CommandHandler.ts

@@ -1,7 +1,6 @@
-import { Command } from "./Command";
+import { Command } from './Command';
 
 export interface CommandHandler<T extends Command> {
-    subscribedTo(): T;
-
-    handle(command: T): void;
-}
+  subscribedTo(): Command;
+  handle(command: T): Promise<void>;
+}

src/Contexts/Shared/domain/CommandNotRegisteredError.ts

@@ -0,0 +1,7 @@
+import { Command } from './Command';
+
+export class CommandNotRegisteredError extends Error {
+  constructor(command: Command) {
+    super(`The command <${command.constructor.name}> hasn't a command handler associated`);
+  }
+}

src/Contexts/Shared/infrastructure/CommandBus/CommandHandlersInformation.ts

@@ -0,0 +1,31 @@
+import { Command } from '../../domain/Command';
+import { CommandHandler } from '../../domain/CommandHandler';
+import { CommandNotRegisteredError } from '../../domain/CommandNotRegisteredError';
+
+export class CommandHandlersInformation {
+  private commandHandlersMap: Map<Command, CommandHandler<Command>>;
+
+  constructor(commandHandlers: Array<CommandHandler<Command>>) {
+    this.commandHandlersMap = this.formatHandlers(commandHandlers);
+  }
+
+  private formatHandlers(commandHandlers: Array<CommandHandler<Command>>): Map<Command, CommandHandler<Command>> {
+    const handlersMap = new Map();
+
+    commandHandlers.forEach(commandHandler => {
+      handlersMap.set(commandHandler.subscribedTo(), commandHandler);
+    });
+
+    return handlersMap;
+  }
+
+  public search(command: Command): CommandHandler<Command> {
+    const commandHandler = this.commandHandlersMap.get(command.constructor);
+
+    if (!commandHandler) {
+      throw new CommandNotRegisteredError(command);
+    }
+
+    return commandHandler;
+  }
+}

src/Contexts/Shared/infrastructure/CommandBus/InMemoryCommandBus.ts

@@ -1,41 +1,13 @@
-import { CommandBus } from './../../domain/CommandBus';
 import { Command } from '../../domain/Command';
-import { NoHandlerForMessageError } from './NoHandlerForMessageError';
-import { CommandHandler } from '../../domain/CommandHandler';
-
-export class CommandHandlersInformation {
-  private commandHandlersMap: Map<string, CommandHandler<Command>>;
-
-  constructor(commandHandlers: Array<CommandHandler<Command>>) {
-    this.commandHandlersMap = this.formatHandlers(commandHandlers);
-  }
-
-  private formatHandlers(commandHandlers: Array<CommandHandler<Command>>) {
-    const handlersMap = new Map();
-
-    commandHandlers.forEach(commandHandler => {
-      handlersMap.set(commandHandler.subscribedTo(), commandHandler);
-    });
-
-    return handlersMap;
-  }
-
-  public getHandler(command: Command) {
-    return this.commandHandlersMap.get(command.constructor.name);
-  }
-}
+import { CommandBus } from './../../domain/CommandBus';
+import { CommandHandlersInformation } from './CommandHandlersInformation';
 
 export class InMemoryCommandBus implements CommandBus {
-  constructor(private commandHandlersInformation: CommandHandlersInformation) {
-  }
-
-  dispatch(command: Command): void {
-    const handler = this.commandHandlersInformation.getHandler(command);
+  constructor(private commandHandlersInformation: CommandHandlersInformation) {}
 
-    if (!handler) {
-      throw new NoHandlerForMessageError(command);
-    }
+  async dispatch(command: Command): Promise<void> {
+    const handler = this.commandHandlersInformation.search(command);
 
-    handler.handle(command);
+    await handler.handle(command);
   }
 }