refactor(controller):Removed required dependency Server from abstract…

… controller

BREAKING CHANGE:

The `Server` injected dependency is no longer required for all controllers as it is now passed into the `registerRoutes(server: Server)` method on bootstrap.
All controllers should remove the server variable passed to super:

 Before:
 ```typescript
 class ExampleController extends AbstractController {
   constructor(server: Server, logger: Logger){
     super(server, logger);
   }
 }
 ```
 After:
 ```typescript
 class ExampleController extends AbstractController {
   constructor(logger: Logger){
     super(logger);
   }
 }
 ```

src/server/bootstrap/controllers.bootstrapper.spec.ts

@@ -22,8 +22,8 @@ const providers: any[] = [
 @Injectable()
 class TestController extends AbstractController {
 
-  constructor(server: Server, logger: Logger) {
-    super(server, logger);
+  constructor(logger: Logger) {
+    super(logger);
   }
 
   @Route('GET', '/test')

src/server/bootstrap/controllers.bootstrapper.ts

@@ -6,6 +6,7 @@ import { EntityBootstrapper } from './entity.bootstrapper';
 import { AbstractController } from '../controllers/abstract.controller';
 import { RegistryEntityStatic } from '../../common/registry/entityRegistry';
 import { ControllerMetadata } from '../../common/metadata/metadata';
+import { Server } from '../servers/abstract.server';
 
 /**
  * Provides bootstrapping of the @[[Controller]] entities
@@ -20,12 +21,13 @@ export class ControllerBootstrapper extends EntityBootstrapper {
   }
 
   public bootstrap(): void {
+    const server = this.injector.get(Server);
     this.entities.forEach((resolvedController: RegistryEntityStatic<ControllerMetadata>) => {
 
       let controller = this.getInstance<AbstractController>(resolvedController);
 
       controller.registerInjector(this.injector)
-        .registerRoutes();
+        .registerRoutes(server);
 
     });
   }

src/server/controllers/abstract.controller.spec.ts

@@ -15,8 +15,8 @@ import { UnavailableForLegalReasonsException } from '../exeptions/exceptions';
 @Injectable()
 class TestController extends AbstractController {
 
-  constructor(server: Server, logger: Logger) {
-    super(server, logger);
+  constructor(logger: Logger) {
+    super(logger);
   }
 
   @Route('GET', '/test')
@@ -52,7 +52,7 @@ describe('Controller', () => {
   it('Registers a route that returns a response', async(inject([TestController, Server],
     (c: TestController, s: Server) => {
 
-      c.registerRoutes();
+      c.registerRoutes(s);
 
       const callStackHandler = s.configuredRoutes.find((r: RouteConfig) => r.methodName == 'test').callStackHandler;
 
@@ -72,7 +72,7 @@ describe('Controller', () => {
   it('Registers a route that returns an http error response', async(inject([TestController, Server],
     (c: TestController, s: Server) => {
 
-      c.registerRoutes();
+      c.registerRoutes(s);
 
       const callStackHandler = s.configuredRoutes.find((r: RouteConfig) => r.methodName == 'httpError').callStackHandler;
 
@@ -95,7 +95,7 @@ describe('Controller', () => {
   it('Registers a route that falls back to an http error respnse', async(inject([TestController, Server],
     (c: TestController, s: Server) => {
 
-      c.registerRoutes();
+      c.registerRoutes(s);
 
       const callStackHandler = s.configuredRoutes.find((r: RouteConfig) => r.methodName == 'unknownError').callStackHandler;
 

src/server/controllers/abstract.controller.ts

@@ -11,14 +11,8 @@ import { Response } from './response';
 import { Request } from './request';
 import { initializeMiddlewareRegister } from '../middleware/middleware.decorator';
 import { HttpException, InternalServerErrorException } from '../exeptions/exceptions';
-import {
-  RegistryEntityStatic,
-  RegistryEntityConstructor, RegistryEntity
-} from '../../common/registry/entityRegistry';
-import {
-  ModelMetadata, ControllerMetadata,
-  initializeMetadata
-} from '../../common/metadata/metadata';
+import { RegistryEntityStatic, RegistryEntity } from '../../common/registry/entityRegistry';
+import { ControllerMetadata } from '../../common/metadata/metadata';
 
 export interface MethodDefinition {
   method: HttpMethod;
@@ -64,7 +58,7 @@ export abstract class AbstractController extends RegistryEntity<ControllerMetada
   /** Instance of injector used for the registration of @Injectable middleware */
   private injector: Injector;
 
-  constructor(protected server: Server, logger: Logger) {
+  constructor(logger: Logger) {
     super();
     this.logger = logger.source(this.constructor.name);
   }
@@ -134,10 +128,10 @@ export abstract class AbstractController extends RegistryEntity<ControllerMetada
   }
 
   /**
-   * Register all routes defined in this controller (or any extending instances)
+   * Register all routes defined in this controller (or any extending instances) with the server
    * @returns {AbstractController}
    */
-  public registerRoutes(): this {
+  public registerRoutes(server: Server): this {
 
     this.actionMethods.forEach((methodDefinition: MethodDefinition, methodSignature: string) => {
 
@@ -166,7 +160,7 @@ export abstract class AbstractController extends RegistryEntity<ControllerMetada
         }
       }
 
-      this.server.register({
+      server.register({
         methodName: methodSignature,
         method: methodDefinition.method,
         path: `${process.env.API_BASE}/${this.getMetadata().routeBase}${methodDefinition.route}`,

src/server/controllers/resource.controller.spec.ts

@@ -48,8 +48,8 @@ class FruitMockStore extends MockStore<Fruit> {
 @Injectable()
 class TestController extends ResourceController<Fruit> {
 
-  constructor(server: Server, logger: Logger, fruitStore: FruitStore) {
-    super(server, logger, fruitStore);
+  constructor(logger: Logger, fruitStore: FruitStore) {
+    super(logger, fruitStore);
   }
 
 }
@@ -71,7 +71,7 @@ describe('Resource Controller', () => {
   it('Registers a route to retrieve an entity', async(inject([TestController, Server],
     (c: TestController, s: Server) => {
 
-      c.registerRoutes();
+      c.registerRoutes(s);
 
       const callStackHandler = s.configuredRoutes.find((r: RouteConfig) => r.methodName == 'getOne').callStackHandler;
 
@@ -96,7 +96,7 @@ describe('Resource Controller', () => {
   it('Registers a route to retrieve many entities', async(inject([TestController, Server],
     (c: TestController, s: Server) => {
 
-      c.registerRoutes();
+      c.registerRoutes(s);
 
       const callStackHandler = s.configuredRoutes.find((r: RouteConfig) => r.methodName == 'getMany').callStackHandler;
 
@@ -120,7 +120,7 @@ describe('Resource Controller', () => {
   it('Registers a route put one entity', async(inject([TestController, Server],
     (c: TestController, s: Server) => {
 
-      c.registerRoutes();
+      c.registerRoutes(s);
 
       const callStackHandler = s.configuredRoutes.find((r: RouteConfig) => r.methodName == 'putOne').callStackHandler;
 

src/server/controllers/resource.controller.ts

@@ -20,8 +20,8 @@ import { Collection } from '../../common/models/collection';
 @Injectable()
 export abstract class ResourceController<M extends AbstractModel> extends AbstractController {
 
-  constructor(server: Server, logger: Logger, protected modelStore:AbstractStore<M>) {
-    super(server, logger);
+  constructor(logger: Logger, protected modelStore:AbstractStore<M>) {
+    super(logger);
   }
 
   /**

src/server/controllers/route.decorator.spec.ts

@@ -18,8 +18,8 @@ import { Controller } from '../../common/registry/decorators';
 })
 class TestController extends AbstractController {
 
-  constructor(server: Server, logger: Logger) {
-    super(server, logger);
+  constructor(logger: Logger) {
+    super(logger);
   }
 
   @Route('PUT', '/test/:id')
@@ -46,7 +46,7 @@ describe('@Route decorator', () => {
       (c: TestController, i: Injector, s: Server) => {
 
         let controller = c.registerInjector(i)
-          .registerRoutes();
+          .registerRoutes(s);
 
         const routeConfig: RouteConfig = s.getRoutes()
           .find((route: RouteConfig) => route.methodName == 'testMethod');

src/server/middleware/debugLog.middleware.spec.ts

@@ -16,8 +16,8 @@ import { debugLog, DebugLogMiddleware } from './debugLog.middleware';
 @Injectable()
 class MiddlewareController extends AbstractController {
 
-  constructor(server: Server, logger: Logger) {
-    super(server, logger);
+  constructor(logger: Logger) {
+    super(logger);
   }
 
   @Route('GET', '/test')
@@ -68,7 +68,7 @@ describe('debugLog middleware', () => {
       (c: MiddlewareController, i: Injector, s: Server) => {
 
         controller = c.registerInjector(i)
-          .registerRoutes();
+          .registerRoutes(s);
 
         const callStackHandler: any = s.getRoutes()
           .find((route: RouteConfig) => route.methodName == 'testMethod').callStackHandler;

src/server/middleware/middleware.spec.ts

@@ -28,8 +28,8 @@ function middlewareFixture(input: string): IsolatedMiddlewareFactory {
 @Injectable()
 class MiddlewareController extends AbstractController {
 
-  constructor(server: Server, logger: Logger) {
-    super(server, logger);
+  constructor(logger: Logger) {
+    super(logger);
   }
 
   @Route('GET', '/test')
@@ -58,10 +58,10 @@ describe('Middleware Decorators', () => {
   });
 
   it('defines registeredMiddleware on the controller',
-    inject([MiddlewareController, ReflectiveInjector],
-      (c: MiddlewareController, i: ReflectiveInjector) => {
+    inject([MiddlewareController, ReflectiveInjector, Server],
+      (c: MiddlewareController, i: ReflectiveInjector, s: Server) => {
 
-        controller = c.registerRoutes()
+        controller = c.registerRoutes(s)
           .registerInjector(i);
 
         expect(controller.getMetadata().middleware)
@@ -77,7 +77,7 @@ describe('Middleware Decorators', () => {
     inject([MiddlewareController, ReflectiveInjector, Server],
       (c: MiddlewareController, i: ReflectiveInjector, s: Server) => {
 
-        controller = c.registerRoutes()
+        controller = c.registerRoutes(s)
           .registerInjector(i);
 
         const callStack: any = s.getRoutes()
@@ -102,7 +102,7 @@ describe('Middleware Decorators', () => {
     async(inject([MiddlewareController, ReflectiveInjector, Server],
       (c: MiddlewareController, i: ReflectiveInjector, s: Server) => {
 
-        controller = c.registerRoutes()
+        controller = c.registerRoutes(s)
           .registerInjector(i);
 
         const callStackHandler: any = s.getRoutes()