feat(server): Add express server option

package.json

@@ -36,6 +36,7 @@
     "chalk": "^1.1.3",
     "core-js": "^2.4.0",
     "dotenv": "^2.0.0",
+    "express": "^4.13.4",
     "hapi": "^13.4.0",
     "lodash": "^4.12.0",
     "moment": "^2.13.0",
@@ -56,4 +57,4 @@
   "directories": {
     "doc": "docs"
   }
-}
+}

src/server/controllers/request.ts

@@ -1,6 +1,7 @@
 import { Request as HapiRequest } from 'hapi';
+import { Request as ExpressRequest } from 'express';
 
-export type OriginalRequest = HapiRequest;
+export type OriginalRequest = HapiRequest|ExpressRequest;
 
 export class Request {
 

src/server/main.ts

@@ -15,6 +15,7 @@ import { RemoteCli } from './services/remoteCli.service';
 import { Logger } from '../common/services/logger.service';
 import { ConsoleLogger } from '../common/services/consoleLogger.service';
 import { DebugLogMiddleware } from './middleware/debugLog.middleware';
+import { ExpressServer } from './servers/express.server';
 export {provide} from '@angular/core';
 /**
  * The core injector is exported so implementations can pick up already registered injectables
@@ -26,7 +27,8 @@ export const coreInjector = ReflectiveInjector.resolveAndCreate([
   Database,
   RemoteCli,
   DebugLogMiddleware,
-  provide(Server, {useClass: HapiServer}),
+  // provide(Server, {useClass: HapiServer}),
+  provide(Server, {useClass: ExpressServer}),
   provide(Logger, {useClass: ConsoleLogger}),
 ]);
 

src/server/servers/abstract.server.spec.ts

@@ -5,6 +5,10 @@ import { Injectable } from '@angular/core';
 
 @Injectable()
 export class ServerMock extends Server {
+
+  public getEngine(): any {
+    return undefined;
+  }
 
   constructor(logger: Logger, remoteCli: RemoteCli) {
     super(logger, remoteCli);

src/server/servers/abstract.server.ts

@@ -5,6 +5,7 @@ import { Server as Hapi } from 'hapi';
 import { Response } from '../controllers/response';
 import { Request } from '../controllers/request';
 import { PromiseFactory } from '../../common/util/serialPromise';
+import { Application as Express } from 'express';
 
 export type HttpMethod = 'GET' | 'PUT' | 'PATCH' | 'POST' | 'DELETE';
 
@@ -19,22 +20,26 @@ export interface RouteConfig {
 @Injectable()
 export abstract class Server {
 
+  protected host:string;
+  protected port:number;
+
   public configuredRoutes: RouteConfig[] = [];
   /**
    * Logger instance for the class, initialized with `server` source
    */
    protected logger: Logger;
-  /**
-   * The implementation of the underlying engine, could be hapi, koa, express etc
-   */
-   protected engine: Hapi|any;
 
   constructor(loggerBase: Logger, remoteCli: RemoteCli) {
 
     this.logger = loggerBase.source('server');
 
+    //@todo pull this config from process.env via .env variables
+    this.host = 'localhost';
+    this.port = 3000;
+
     this.initialize();
 
+
     remoteCli.start(3001);
   }
 
@@ -64,8 +69,10 @@ export abstract class Server {
    * Retrieves the underlying engine for custom calls
    * @returns {Hapi|any}
    */
-  public getEngine(): any {
-    return this.engine;
+  public abstract getEngine():Hapi|Express|any;
+
+  public getHost(){
+    return `http://${this.host}:${this.port}`;
   }
 
   public getRoutes(): RouteConfig[] {

src/server/servers/express.server.ts

@@ -0,0 +1,89 @@
+import { Injectable } from '@angular/core';
+import { Server, RouteConfig } from './abstract.server';
+import { RemoteCli } from '../services/remoteCli.service';
+import { Logger } from '../../common/services/logger.service';
+import { Response } from '../controllers/response';
+import { Request } from '../controllers/request';
+import * as express from 'express';
+import { Application, Request as ExpressRequest, Response as ExpressResponse } from 'express';
+
+@Injectable()
+export class ExpressServer extends Server {
+
+  private engine: Application;
+
+  constructor(logger: Logger, remoteCli: RemoteCli) {
+    super(logger, remoteCli);
+  }
+
+  /**
+   * @inherit
+   * @returns {Application}
+   */
+  public getEngine(): Application {
+    return this.engine;
+  }
+
+  /**
+   * @inherit
+   * @returns {Express}
+   */
+  protected initialize() {
+    this.engine = express();
+
+    return this;
+  }
+
+  /**
+   * @inherit
+   * @returns {any}
+   * @param routeConfig
+   */
+  protected registerRouteWithEngine(routeConfig: RouteConfig): this {
+
+    console.log(this.engine);
+
+    this.engine[routeConfig.method.toLowerCase()](routeConfig.path, (req: ExpressRequest, res: ExpressResponse) => {
+
+      let request  = new Request(req);
+      let response = new Response();
+
+      return routeConfig.callStackHandler(request, response)
+        .then((response: Response) => {
+          this.logger.debug('Responding with', response);
+
+          return this.send(response, res);
+        })
+        .catch((err) => this.sendErr(err, res));
+
+    });
+
+    return this;
+  }
+
+  /**
+   * @inherit
+   * @returns {Promise<ExpressServer>}
+   */
+  public start(): Promise<this> {
+    return new Promise((resolve, reject) => {
+      this.engine.listen(this.port, this.host, resolve);
+    })
+      .then(() => this);
+  }
+
+  private send(response: Response, res: ExpressResponse):void {
+
+    res.status(response.statusCode);
+
+    for (var [key, value] of response.headers.entries()) {
+      res.header(key, value);
+    }
+
+    res.send(response.body);
+  }
+
+  private sendErr(err:any, res: ExpressResponse):void {
+    res.send(err);
+  }
+}

src/server/servers/hapi.server.ts

@@ -11,10 +11,20 @@ import { IRoute } from 'hapi';
 @Injectable()
 export class HapiServer extends Server {
 
+  private engine: Hapi;
+
   constructor(logger: Logger, remoteCli: RemoteCli) {
     super(logger, remoteCli);
   }
 
+  /**
+   * @inherit
+   * @returns {Hapi}
+   */
+  public getEngine(): Hapi {
+    return this.engine;
+  }
+
   /**
    * @inherit
    * @returns {HapiServer}
@@ -23,8 +33,8 @@ export class HapiServer extends Server {
     this.engine = new Hapi();
 
     this.engine.connection({
-      host: 'localhost',
-      port: 3000
+      host: this.host,
+      port: this.port
     });
     return this;
   }
@@ -65,11 +75,20 @@ export class HapiServer extends Server {
 
   /**
    * @inherit
-   * @returns {IThenable<HapiServer>|PromiseLike<HapiServer>|Promise<HapiServer>|IPromise<HapiServer>}
+   * @returns {Promise<HapiServer>}
    */
   public start(): Promise<this> {
-    return this.engine.start()
+
+    return new Promise((resolve, reject) => {
+      this.engine.start((err) => {
+        if (err){
+          return reject(err);
+        }
+        return resolve();
+      });
+    })
       .then(() => this);
+
   }
 
 }

typings.json

@@ -1,16 +1,20 @@
 {
   "globalDependencies": {
     "dotenv": "registry:dt/dotenv#2.0.0+20160327131627",
+    "express": "registry:dt/express#4.0.0+20160317120654",
+    "express-serve-static-core": "registry:dt/express-serve-static-core#0.0.0+20160602151406",
     "hapi": "registry:dt/hapi#13.0.0+20160423150146",
     "lodash": "registry:dt/lodash#3.10.0+20160330154726",
     "moment-node": "registry:dt/moment-node#2.11.1+20160511043338",
     "node": "registry:dt/node#6.0.0+20160514165920",
     "sequelize": "registry:dt/sequelize#3.4.1+20160423143634",
+    "serve-static": "registry:dt/serve-static#0.0.0+20160606155157",
     "socket.io": "registry:dt/socket.io#1.4.4+20160317120654",
     "umzug": "registry:dt/umzug#1.8.0+20160316171810",
     "validator": "registry:dt/validator#4.5.1+20160316155526"
   },
   "dependencies": {
-    "chalk": "registry:npm/chalk#1.0.0+20160211003958"
+    "chalk": "registry:npm/chalk#1.0.0+20160211003958",
+    "mime": "registry:npm/mime#1.3.0+20160423043021"
   }
 }