feat(routing): implemented basic routing with decorators and separate…

…d demo out of core logic for later extraction

_demo/README.md

@@ -0,0 +1,3 @@
+# Notice
+This directory need to be extracted out to ubiquits/ubiquits as a proper
+framework demo once the build toolchain is worked out.

_demo/api/bootstrap.ts

@@ -0,0 +1,5 @@
+import { server } from './main';
+
+server.start().then(() => {
+  console.log('Server running at:', server.getEngine().info.uri);
+});

_demo/api/controllers/index.ts

@@ -0,0 +1,2 @@
+export {TestController} from './test.controller';
+export {SimpleController} from './simple.controller';

_demo/api/controllers/simple.controller.ts

@@ -0,0 +1,20 @@
+import { Injectable } from '@angular/core';
+import { Server } from '../../../api/servers/abstract.server';
+import { AbstractController } from '../../../api/controllers/abstract.controller';
+import { RouteBase } from '../../../api/controllers/routeBase.decorator';
+import { Action } from '../../../api/controllers/action.decorator';
+
+@Injectable()
+@RouteBase('simple')
+export class SimpleController extends AbstractController {
+
+  constructor(server: Server) {
+    super(server);
+  }
+
+  @Action('GET', '/test/{id}')
+  public test() {
+    return 'hello world';
+  }
+
+}

_demo/api/controllers/test.controller.ts

@@ -0,0 +1,16 @@
+import { Injectable } from '@angular/core';
+import { Server } from '../../../api/servers/abstract.server';
+import { AbstractController } from '../../../api/controllers/abstract.controller';
+import { RouteBase } from '../../../api/controllers/routeBase.decorator';
+
+@Injectable()
+@RouteBase('test')
+export class TestController extends AbstractController {
+
+  constructor(server: Server) {
+    super(server);
+
+    console.log('route base is ', this.routeBase);
+  }
+
+}

_demo/api/main.ts

@@ -0,0 +1,20 @@
+import { coreInjector } from '../../api/main';
+import { ReflectiveInjector, ResolvedReflectiveProvider } from '@angular/core';
+import { Server } from '../../api/servers/abstract.server';
+import * as Controllers from './controllers';
+import * as _ from 'lodash';
+
+// console.log('typeof ControllerMap', typeof ControllerMap);
+
+// const controllers = ControllerMap.values();
+
+let resolvedProviders = ReflectiveInjector.resolve(_.values(Controllers));
+
+let injector = ReflectiveInjector.fromResolvedProviders(resolvedProviders, coreInjector);
+
+export const server: Server = injector.get(Server);
+
+resolvedProviders.forEach((resolvedControllerProvider: ResolvedReflectiveProvider) => {
+  console.log('initializing', resolvedControllerProvider.key);
+  injector.instantiateResolved(resolvedControllerProvider);
+});

api/controllers/abstract.controller.ts

@@ -0,0 +1,79 @@
+import { Server } from '../servers/abstract.server';
+import { Injectable } from '@angular/core';
+import { Request as HapiRequest, IReply, Response } from 'hapi';
+import * as _ from 'lodash';
+import { Cat } from '../../common/models/index';
+import { Action } from './action.decorator';
+
+export interface Request extends HapiRequest {
+
+}
+
+export interface RouteParam {
+  key: string;
+  value: string;
+}
+
+export type ActionType = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+
+export interface MethodDefinition {
+  method: ActionType;
+  route: string;
+}
+
+export interface MethodDictionary {
+  [methodSignature: string]: MethodDefinition;
+}
+
+@Injectable()
+export abstract class AbstractController {
+
+  protected __actionMethods: Map<string, MethodDefinition>;
+
+  protected routeBase: string;
+
+  constructor(protected server: Server) {
+    this.registerRoutes();
+  }
+
+  public registerActionMethod(methodSignature: string, method: ActionType, route: string) {
+    if (!this.__actionMethods) {
+      this.__actionMethods = new Map<string, MethodDefinition>();
+    }
+
+    const methodDefinition: MethodDefinition = {
+      method,
+      route
+    };
+
+    this.__actionMethods.set(methodSignature, methodDefinition);
+  }
+
+  @Action('GET', '/{id}')
+  public getOne(request: Request, ...routeParams: RouteParam[]) {
+
+    const greeting = new Cat().greet();
+
+    return {id: routeParams[0], greeting};
+  }
+
+  public registerRoutes(): void {
+
+    this.__actionMethods.forEach((methodDefinition: MethodDefinition, methodSignature: string) => {
+
+      this.server.register({
+        method: methodDefinition.method,
+        path: `/${this.routeBase}${methodDefinition.route}`,
+        handler: (request: Request, reply: IReply): Response => {
+
+          let response = this[methodSignature](request, ...request.paramsArray);
+
+          return reply(response);
+        }
+      });
+
+    });
+
+  }
+
+}

api/controllers/action.decorator.ts

@@ -0,0 +1,8 @@
+import { ActionType } from './abstract.controller';
+export function Action(method: ActionType, route: string) {
+
+  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+
+    target.registerActionMethod(propertyKey, method, route);
+  };
+}

api/controllers/routeBase.decorator.ts

@@ -0,0 +1,12 @@
+export function RouteBase(base: string) {
+
+  console.log('decorating!');
+
+  return function (target: Function) {
+
+    (<any>target).prototype.routeBase = base;
+
+    // Reflect.defineMetadata('RouteBase', base, target);
+
+  };
+}

api/main.ts

@@ -1,13 +1,12 @@
 import 'es6-shim';
 import 'reflect-metadata';
 import { ReflectiveInjector, provide } from '@angular/core';
-import { Server, HapiServer } from './server';
-import { TestController } from './test';
-let injector = ReflectiveInjector.resolveAndCreate([
-  TestController,
+import { Server } from './servers/abstract.server';
+import { HapiServer } from './servers/hapi.server';
+import { AbstractController } from './controllers/abstract.controller';
+
+export const coreInjector = ReflectiveInjector.resolveAndCreate([
+  AbstractController,
   provide(Server, {useClass: HapiServer}),
 ]);
 
-export const server: HapiServer = injector.get(Server);
-
-injector.get(TestController);

api/servers/abstract.server.ts

@@ -0,0 +1,21 @@
+import { IRouteConfiguration } from 'hapi';
+
+export abstract class Server {
+
+  constructor() {
+    this.initialize();
+  }
+
+  protected server: any;
+
+  public abstract register(config: IRouteConfiguration): void;
+
+  protected abstract initialize(): this;
+
+  public abstract start(): Promise<this>;
+
+  public getEngine(): any {
+    return this.server;
+  }
+
+}

api/servers/hapi.server.ts

@@ -0,0 +1,24 @@
+import { Server as Hapi, IRouteConfiguration } from 'hapi';
+import { Server } from './abstract.server';
+
+export class HapiServer extends Server {
+
+  protected initialize() {
+    this.server = new Hapi();
+
+    this.server.connection({
+      host: 'localhost',
+      port: 3000
+    });
+    return this;
+  }
+
+  public register(config: IRouteConfiguration): void {
+    return this.server.route(config);
+  }
+
+  public start(): Promise<this> {
+    return this.server.start().then(() => this);
+  }
+
+}

gulpfile.js

@@ -15,13 +15,14 @@ var path = require('path');
 // /*  Variables */
 let tsProject = tsc.createProject('./tsconfig.api.json');
 let sourceFiles = [
+  './_demo/api/**/*.ts',
   './api/**/*.ts',
   './common/**/*.ts',
   './typings/**/*.d.ts',
   '!./typings/index.d.ts',
   '!./typings/**/es6-shim/*.d.ts',
 ];
-let testFiles = ['./api/**/*.spec.ts'];
+let testFiles = ['./api/**/*.spec.ts', './_demo/api/**/*.spec.ts'];
 let outDir = require('./tsconfig.api.json').compilerOptions.outDir;
 let entryPoint = './localhost.js';
 
@@ -172,6 +173,7 @@ gulp.task('nodemon', ['build'], () => {
     'ext': 'js json ts',
     watch: [
       'api',
+      '_demo',
       'common'
     ],
     nodeArgs: [

localhost.js

@@ -1,4 +1,4 @@
-const API = require('./build/api/api/main.js');
+const API = require('./build/api/_demo/api/main.js');
 const server = API.server;
 
 const WebpackPlugin = require('hapi-webpack-plugin');
@@ -23,15 +23,11 @@ const hot = {
 /**
  * Register plugin and start server
  */
-server.getHapi().register({
+server.getEngine().register({
   register: WebpackPlugin,
   options: {compiler, assets, hot}
 });
 
-server.start((err) => {
-
-  if (err) {
-    throw err;
-  }
-  console.log('Server running at:', server.getHapi().info.uri);
+server.start().then(() => {
+  console.log('Server running at:', server.getEngine().info.uri);
 });

tslint.json

@@ -17,7 +17,6 @@
     "no-eval": true,
     "no-arg": true,
     "no-internal-module": true,
-    "no-trailing-whitespace": true,
     "no-bitwise": true,
     "no-shadowed-variable": true,
     "no-unused-expression": true,