wip: subscribe to symbol

Author: rsaladocid

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/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(): T;
+  handle(command: T): void;
+}

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

@@ -0,0 +1,24 @@
+import { Command } from '../../domain/Command';
+import { CommandHandler } from '../../domain/CommandHandler';
+
+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 getCommandHandler(command: Command): CommandHandler<Command> | undefined {
+    return this.commandHandlersMap.get(command.constructor);
+  }
+}

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

@@ -1,36 +1,13 @@
-import { CommandBus } from './../../domain/CommandBus';
 import { Command } from '../../domain/Command';
+import { CommandBus } from './../../domain/CommandBus';
+import { CommandHandlersInformation } from './CommandHandlersInformation';
 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) {
-  }
+  constructor(private commandHandlersInformation: CommandHandlersInformation) {}
 
   dispatch(command: Command): void {
-    const handler = this.commandHandlersInformation.getHandler(command);
+    const handler = this.commandHandlersInformation.getCommandHandler(command);
 
     if (!handler) {
       throw new NoHandlerForMessageError(command);

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

@@ -2,6 +2,6 @@ import { Command } from '../../domain/Command';
 
 export class NoHandlerForMessageError extends Error {
   constructor(command: Command) {
-    super(`There is not handler for command of type ${command.commandName}`);
+    super(`There is not handler for command of type ${command.constructor.name}`);
   }
-}
+}

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

@@ -1,5 +1,7 @@
-import { InMemoryCommandBus } from '../../../../../src/Contexts/Shared/infrastructure/CommandBus/InMemoryCommandBus';
 import { Command } from '../../../../../src/Contexts/Shared/domain/Command';
+import { CommandHandler } from '../../../../../src/Contexts/Shared/domain/CommandHandler';
+import { CommandHandlersInformation } from '../../../../../src/Contexts/Shared/infrastructure/CommandBus/CommandHandlersInformation';
+import { InMemoryCommandBus } from '../../../../../src/Contexts/Shared/infrastructure/CommandBus/InMemoryCommandBus';
 import { NoHandlerForMessageError } from '../../../../../src/Contexts/Shared/infrastructure/CommandBus/NoHandlerForMessageError';
 
 class UnhandledCommand extends Command {
@@ -10,36 +12,38 @@ class HandledCommand extends Command {
   static COMMAND_NAME = 'handled.command';
 }
 
-interface CommandHandler {
-  handle(command: Command): void;
-}
+class MyCommandHandler implements CommandHandler<HandledCommand> {
+  subscribedTo(): HandledCommand {
+    return HandledCommand;
+  }
 
-class MyCommandHandler implements CommandHandler {
   handle(command: HandledCommand): void {}
 }
 
 describe('InMemoryCommandBus', () => {
-  it('throws an error if dispatches a command without handler', (done) => {
+  it('throws an error if dispatches a command without handler', done => {
     const unhandledCommand = new UnhandledCommand();
-    const commandBus = new InMemoryCommandBus();
+    const commandHandlersInformation = new CommandHandlersInformation([]);
+    const commandBus = new InMemoryCommandBus(commandHandlersInformation);
 
     try {
       commandBus.dispatch(unhandledCommand);
     } catch (error) {
       expect(error).toBeInstanceOf(NoHandlerForMessageError);
-      expect(error.message).toBe('There is not handler for command of type UnhandledCommandName');
+      expect(error.message).toBe('There is not handler for command of type UnhandledCommand');
       done();
     }
   });
 
   it('accepts a command with handler', done => {
     const handledCommand = new HandledCommand();
     const myCommandHandler = new MyCommandHandler();
-    const commandBus = new InMemoryCommandBus([myCommandHandler]);
+    const commandHandlersInformation = new CommandHandlersInformation([myCommandHandler]);
+    const commandBus = new InMemoryCommandBus(commandHandlersInformation);
 
     try {
       commandBus.dispatch(handledCommand);
       done();
-    } catch (error) { }
+    } catch (error) {}
   });
 });