First working implementation with tests

Author: Mateusz Kołecki

.gitignore

@@ -0,0 +1,3 @@
+dist/
+node_modules/
+package-lock.json

command-bus.ts

@@ -0,0 +1,39 @@
+{
+  "name": "commander",
+  "version": "0.1.0",
+  "description": "Command Bus For TypeScript",
+  "license": "MIT",
+  "main": "dist/src/index.js",
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "test": "npm run build && npm run run-test",
+    "build": "rm -rf dist && tsc",
+    "run-test": "mocha --file dist/test/setup.js  'dist/test/**/*.test.js'",
+    "watch-test": "mocha --require ts-node/register --watch --watch-extensions ts --file test/setup.ts 'test/**/*.test.ts'"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/snapshotpl/commander.git"
+  },
+  "keywords": [
+    "command",
+    "bus",
+    "typescript",
+    "commander"
+  ],
+  "devDependencies": {
+    "@types/chai": "^4.1.3",
+    "@types/chai-as-promised": "^7.1.0",
+    "@types/mocha": "^5.2.0",
+    "@types/node": "^10.0.10",
+    "@types/sinon": "^4.3.3",
+    "chai": "^4.1.2",
+    "chai-as-promised": "^7.1.1",
+    "mocha": "^5.1.1",
+    "sinon": "^5.0.7",
+    "ts-node": "^6.0.3",
+    "typescript": "^2.8.3"
+  }
+}

package.json

@@ -0,0 +1,10 @@
+
+export interface Command { } // marking interface
+
+export interface Handler<C extends Command> {
+    handle(command: C): Promise<any>;
+}
+
+export interface CommandBus {
+    handle(command: Command): Promise<any>
+}

src/commandBus.ts

@@ -0,0 +1,35 @@
+import { Middleware } from './middlewares';
+import { CommandBus, Command } from './commandBus';
+
+type ExecutionChain = (command: Command) => Promise<any>;
+
+export class Commander implements CommandBus {
+
+    private executionChain: ExecutionChain;
+
+    constructor(middlewares: Middleware[]) {
+        this.executionChain = this.createExecutionChain(middlewares);
+    }
+
+    public async handle(command: Command): Promise<any> {
+        return await this.executionChain(command);
+    }
+
+    private createExecutionChain(middlewares: Middleware[]): ExecutionChain {
+        const last = () => {
+            // last callback in chain is no-op
+            return Promise.resolve();
+        };
+
+        const reducer = (
+            next: ExecutionChain,
+            middleware: Middleware
+        ): ExecutionChain => {
+            return (command: Command): Promise<any> => {
+                return middleware.run(command, () => next(command));
+            }
+        };
+
+        return middlewares.reverse().reduce(reducer, last);
+    }
+}

src/commander.ts

@@ -0,0 +1,3 @@
+
+export * from './commander';
+export * from './commandBus';

src/index.ts

@@ -0,0 +1,17 @@
+
+import { Middleware, NextMiddleware } from './index';
+import { Command, Handler } from '../commandBus';
+import { HandlerResolver } from '../resolvers'
+
+export class CommandExecutionMiddleware implements Middleware {
+    constructor(
+        private handlerResolver: HandlerResolver
+    ) { }
+
+    public async run(command: Command, next: NextMiddleware): Promise<any> {
+        const handler: Handler<Command> = this.handlerResolver.resolve(command);
+        const result = await handler.handle(command);
+        await next();
+        return result;
+    }
+}

src/middlewares/commandExecution.ts

@@ -0,0 +1,44 @@
+
+import { Middleware, NextMiddleware } from './index';
+import { Command } from '../commandBus';
+
+
+export interface CommandLogger {
+    log(level: string, msg: string): CommandLogger;
+    log(level: string, msg: string, meta: any): CommandLogger;
+    log(level: string, msg: string, ...meta: any[]): CommandLogger;
+}
+
+export interface CommandLoggerOptions {
+    level?: string;
+    errorLevel?: string;
+}
+
+export class CommandLoggerMiddleware implements Middleware {
+    private logger: CommandLogger;
+    private level: string;
+    private errorLevel: string;
+
+    constructor(logger: CommandLogger, options: CommandLoggerOptions = {}) {
+        this.logger = logger;
+        this.level = options.level || 'info';
+        this.errorLevel = options.errorLevel || 'error';
+    }
+
+    public async run(command: Command, next: NextMiddleware): Promise<any> {
+        const start = Date.now();
+        const commandName = command.constructor.name;
+
+        this.logger.log(this.level, 'Command %s dispatched', commandName);
+
+        try {
+            return await next();
+        } catch (err) {
+            this.logger.log(this.errorLevel, 'Command %s error. %s', commandName, err);
+            throw err;
+        } finally {
+            const time = Date.now() - start;
+            this.logger.log(this.level, 'Command %s time %dms', commandName, time);
+        }
+    }
+}

src/middlewares/commandLogger.ts

@@ -0,0 +1,11 @@
+
+import { Command } from '../commandBus';
+
+export type NextMiddleware = () => Promise<any>;
+
+export interface Middleware {
+    run(command: Command, next: NextMiddleware): Promise<any>;
+}
+
+export * from './commandLogger';
+export * from './commandExecution';

src/middlewares/index.ts

@@ -0,0 +1,8 @@
+
+import { Handler, Command } from '../commandBus';
+
+export interface HandlerResolver {
+    resolve<C extends Command>(command: C): Handler<C>
+}
+
+export * from './memory';