refactored middlewares

Author: hirsch88

src/api/controllers/UserController.ts

@@ -3,15 +3,22 @@ import { Controller, Get, Post, Put, Delete, RequestParam, RequestBody, Response
 import { my } from 'my-express';
 import { UserService } from '../services/UserService';
 import { Types } from '../../constants/Types';
-import { Service } from '../../constants/Targets';
-import { authenticate, populateUser } from '../middlewares';
+import { Service, Middleware } from '../../constants/Targets';
+// import { authenticate, populateUser } from '../middlewares';
+import { AuthenticateMiddleware } from '../middlewares/AuthenticateMiddleware';
+import { PopulateUserMiddleware } from '../middlewares/PopulateUserMiddleware';
+import { ioc } from '../../core/IoC';
+
+// Get middlewares
+const authenticate = ioc.Container.getNamed<AuthenticateMiddleware>(Types.Middleware, Middleware.AuthenticateMiddleware);
+const populateUser = ioc.Container.getNamed<PopulateUserMiddleware>(Types.Middleware, Middleware.PopulateUserMiddleware);
 
 /**
  * UserController is in charge of the user resource and should
  * provide all crud actions.
  */
 @injectable()
-@Controller('/user', authenticate)
+@Controller('/user', authenticate.use)
 export class UserController {
 
     constructor( @inject(Types.Service) @named(Service.UserService) private userService: UserService) { }
@@ -28,7 +35,7 @@ export class UserController {
         return res.created(user.toJSON());
     }
 
-    @Get('/me', populateUser)
+    @Get('/me', populateUser.use)
     public async findMe( @Request() req: my.Request, @Response() res: my.Response): Promise<any> {
         return res.found(req.user);
     }

src/api/middlewares/AuthenticateMiddleware.ts

@@ -0,0 +1,74 @@
+import { injectable, inject, named } from 'inversify';
+import * as Request from 'request';
+import { my } from 'my-express';
+import { Log } from '../../core/log';
+import { Types } from '../../constants/Types';
+import { Lib, Core } from '../../constants/Targets';
+
+
+@injectable()
+export class AuthenticateMiddleware {
+
+    public log: Log;
+
+    constructor(
+        @inject(Types.Core) @named(Core.Log) Logger: typeof Log,
+        @inject(Types.Lib) @named(Lib.Request) private request: typeof Request
+    ) {
+        this.log = new Logger('api:middleware:AuthenticateMiddleware');
+    }
+
+
+    public use = (req: my.Request, res: my.Response, next: my.NextFunction): void => {
+        // console.log(this.request());
+        // return next();
+        const token = this.getToken(req);
+
+        if (token === null) {
+            this.log.warn('No token given');
+            return res.failed(403, 'You are not allowed to request this resource!');
+        }
+        this.log.debug('Token is provided');
+
+        // Request user info at auth0 with the provided token
+        this.request({
+            method: 'POST',
+            url: `${process.env.AUTH0_HOST}/tokeninfo`,
+            form: {
+                id_token: token
+            }
+        }, (error: any, response: Request.RequestResponse, body: any) => {
+            // Verify if the requests was successful and append user
+            // information to our extended express request object
+            if (!error && response.statusCode === 200) {
+                req.tokeninfo = JSON.parse(body);
+                this.log.info(`Retrieved user ${req.tokeninfo.email}`);
+                return next();
+            }
+
+            // Catch auth0 exception and return it as it is
+            this.log.warn(`Could not retrieve the user, because of`, body);
+            let statusCode = 401;
+            if (response && response.statusCode) {
+                statusCode = response.statusCode;
+            } else {
+                this.log.warn('It seems your oauth server is down!');
+            }
+            res.failed(statusCode, body);
+
+        });
+    }
+
+    private getToken(req: my.Request): string | null {
+        const authorization = req.headers.authorization;
+
+        // Retrieve the token form the Authorization header
+        if (authorization && authorization.split(' ')[0] === 'Bearer') {
+            return authorization.split(' ')[1];
+        }
+
+        // No token was provided by the client
+        return null;
+    }
+
+}

src/api/middlewares/PopulateUserMiddleware.ts

@@ -0,0 +1,41 @@
+import { injectable, inject, named } from 'inversify';
+import * as Request from 'request';
+import { my } from 'my-express';
+import { Log } from '../../core/log';
+import { UserService } from '../services/UserService';
+import { Types } from '../../constants/Types';
+import { Service, Core } from '../../constants/Targets';
+
+
+@injectable()
+export class PopulateUserMiddleware {
+
+    public log: Log;
+
+    constructor(
+        @inject(Types.Core) @named(Core.Log) Logger: typeof Log,
+        @inject(Types.Service) @named(Service.UserService) private userService: UserService
+    ) {
+        this.log = new Logger('api:middleware:PopulateUserMiddleware');
+    }
+
+
+    public use = (req: my.Request, res: my.Response, next: my.NextFunction): void => {
+        // Check if the authenticate middleware was successful
+        if (!req.tokeninfo || !req.tokeninfo.user_id) {
+            return res.failed(400, 'Missing token information!');
+        }
+        // Find user from the token and store him in the request object
+        this.userService.findByUserId(req.tokeninfo.user_id)
+            .then((user) => {
+                req.user = user.toJSON();
+                this.log.debug(`populated user with the id=${req.user.id} to the request object`);
+                next();
+            })
+            .catch((error) => {
+                this.log.warn(`could not populate user to the request object`);
+                next(error);
+            });
+    }
+
+}

src/api/middlewares/authenticate.ts

@@ -35,5 +35,6 @@ export const Repository = {
 };
 
 export const Middleware = {
-    AuthenticateMiddleware: 'AuthenticateMiddleware'
+    AuthenticateMiddleware: 'AuthenticateMiddleware',
+    PopulateUserMiddleware: 'PopulateUserMiddleware'
 };

src/api/middlewares/index.ts

@@ -6,8 +6,26 @@
  * will then be bonded to the express structure with their defined routes.
  */
 
-import { Container } from 'inversify';
+import { Container, decorate, injectable } from 'inversify';
 import { ioc } from './core/IoC';
+import { Types } from './constants/Types';
+import { Lib } from './constants/Targets';
+
+import * as request from 'request';
+
+
+ioc.configureLib((container: Container) => {
+
+    decorate(injectable(), request);
+
+    container
+        .bind<any>(Types.Lib)
+        .toConstantValue(request)
+        .whenTargetNamed(Lib.Request);
+
+    return container;
+});
+
 
 ioc.configure((container: Container) => {
 

src/api/middlewares/populateUser.ts

@@ -11,7 +11,7 @@ import * as glob from 'glob';
 import { interfaces } from 'inversify-express-utils';
 import { Container } from 'inversify';
 import { Types } from '../constants/Types';
-import { Core, Controller, Model, Service, Repository } from '../constants/Targets';
+import { Core, Controller, Model, Service, Repository, Middleware } from '../constants/Targets';
 
 import { events, EventEmitter } from './api/events';
 import { Log } from './log';
@@ -22,6 +22,7 @@ const log = new Log('core:IoC');
 class IoC {
 
     public container: Container;
+    public libConfiguration: (container: Container) => Container;
     public customConfiguration: (container: Container) => Container;
 
     constructor() {
@@ -36,13 +37,20 @@ class IoC {
         this.customConfiguration = configuration;
     }
 
+    public configureLib(configuration: (container: Container) => Container): void {
+        this.libConfiguration = configuration;
+    }
+
     public async bindModules(): Promise<void> {
         this.bindCore();
-        await this.bindControllers();
+
+        this.container = this.libConfiguration(this.container);
 
         await this.bindModels();
         await this.bindRepositories();
         await this.bindServices();
+        await this.bindMiddlewares();
+        await this.bindControllers();
 
         this.container = this.customConfiguration(this.container);
     }
@@ -79,6 +87,15 @@ class IoC {
         });
     }
 
+    private bindMiddlewares(): Promise<void> {
+        return this.bindFiles('/middlewares/**/*Middleware.ts', Middleware, (name: any, value: any) => {
+            this.container
+                .bind<any>(Types.Middleware)
+                .to(value)
+                .whenTargetNamed(name);
+        });
+    }
+
     private bindControllers(): Promise<void> {
         return this.bindFiles('/controllers/**/*Controller.ts', Controller, (name: any, value: any) => {
             this.container