WIP

Author: aliondev

src/Contexts/Shared/domain/Command.ts

@@ -1,7 +1,3 @@
 export abstract class Command {
-  readonly commandName: string;
-
-  constructor(commandName: string) {
-    this.commandName = commandName;
-  }
+  static COMMAND_NAME: string;
 }

src/Contexts/Shared/domain/CommandHandler.ts

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

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

@@ -1,9 +1,41 @@
 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);
+  }
+}
 
 export class InMemoryCommandBus implements CommandBus {
+  constructor(private commandHandlersInformation: CommandHandlersInformation) {
+  }
+
   dispatch(command: Command): void {
-    throw new NoHandlerForMessageError(command);
+    const handler = this.commandHandlersInformation.getHandler(command);
+
+    if (!handler) {
+      throw new NoHandlerForMessageError(command);
+    }
+
+    handler.handle(command);
   }
-}
+}

tests/Contexts/Shared/infrastructure/CommandBus/InMemoryCommandBus.test.ts

@@ -3,9 +3,19 @@ import { Command } from '../../../../../src/Contexts/Shared/domain/Command';
 import { NoHandlerForMessageError } from '../../../../../src/Contexts/Shared/infrastructure/CommandBus/NoHandlerForMessageError';
 
 class UnhandledCommand extends Command {
-  constructor() {
-    super('UnhandledCommandName');
-  }
+  static COMMAND_NAME = 'unhandled.command';
+}
+
+class HandledCommand extends Command {
+  static COMMAND_NAME = 'handled.command';
+}
+
+interface CommandHandler {
+  handle(command: Command): void;
+}
+
+class MyCommandHandler implements CommandHandler {
+  handle(command: HandledCommand): void {}
 }
 
 describe('InMemoryCommandBus', () => {
@@ -21,4 +31,15 @@ describe('InMemoryCommandBus', () => {
       done();
     }
   });
+
+  it('accepts a command with handler', done => {
+    const handledCommand = new HandledCommand();
+    const myCommandHandler = new MyCommandHandler();
+    const commandBus = new InMemoryCommandBus([myCommandHandler]);
+
+    try {
+      commandBus.dispatch(handledCommand);
+      done();
+    } catch (error) { }
+  });
 });