@motif/core/lib/Controller.js

'use strict';

const _ = require('lodash');
const jwt = require('jsonwebtoken');
const path = require('path');

const debug = require( 'debug' )( 'motif:controller' );

const Model = require('./Model');

class Controller {

    get service() {
        return this._service;
    }

    get config() {
        return this._service._config;
    }

    get contentType() {
        return this._service.contentType;
    }

    get db() {
        return this._dbConnection ? this._dbConnection.client : null;
    }

    registerModels( modelClasses ) {
        modelClasses.forEach( (modelClass) => {
            let className = modelClass.prototype.constructor.name;
            let key = className.replace("Model", "");
            let model = new modelClass();
            let design = model.createDesign();

            this._models[key] = {
                name: key,
                constructor: modelClass,
                design: design
            };
        });
    }

    model( key, connection ) {
        let modelData = this._models[key];
        if (!modelData) {
            return null;
        }

        let design = modelData.design;
        let model = new modelData.constructor();
        model.setCollection( design.createCollection( connection ) );
        return model;
    }

    constructor( { service, dbConnection, models } ) {

        debug( "controller", service, dbConnection );

        this._service = service;
        this._dbConnection = typeof dbConnection === "string" ? Model.dbConnection(dbConnection) : dbConnection;
        this._models = {};

        this._authConfig = {
            tokenSecret: this._service.config.tokenSecret,
            tokenAlgorithm: this._service.config.tokenAlgorithm,
            refreshsTokenIn: this._service.config.refreshsTokenIn,
            expiresTokenIn: this._service.config.expiresTokenIn,
        };

        // Auto Binding
        const controller = this;
        const propertyNames = Object.getOwnPropertyNames(this.constructor.prototype);
        _.each(propertyNames, (propertyName) => {
            if (propertyName.indexOf('on') === 0) {
                this[propertyName] = this[propertyName].bind(controller);
            }
        });
    }

    verifyParams( request, fields ) {

        let errorFields = [];
        let params = request.params || {};

        debug( "verifyParams", fields, params );

        _.each(fields, (field) => {
            if ( typeof field === 'string') {
                let param = request.method.toUpperCase() === 'GET' || request.method.toUpperCase() === 'DELETE'
                                ? ( request.query[name] ? request.query[name] : params[name] )
                                : ( request.body[field] ? request.body[field] : params[field] );

                // debug( "request.method", request.method );
                // debug( "request.query", request.query );
                // debug( "request.body", request.body );
                debug( "param", name, param );

                if (field.optional !== true && !param) {
                    errorFields.push(field);
                }
                params[field] = param;
            }
            else {
                let { name, type } = field;
                let param = request.method.toUpperCase() === 'GET' || request.method.toUpperCase() === 'DELETE'
                                ? ( request.query[name] ? request.query[name] : params[name] )
                                : ( request.body[name] ? request.body[name] : params[name] );

                // debug( "request.method", request.method );
                // debug( "request.query", request.query );
                // debug( "request.body", request.body );
                debug( "param", name, param );

                if (field.optional !== true ) {
                    if (!param) {
                        errorFields.push(name);
                    }
                    else {
                        let isValid = true;
                        switch(type) {
                            default:
                            case 'string':
                                if (!_.isString(param) ) isValid = false;
                                break;
                            case 'number':
                                if (!_.isNumber(param) ) isValid = false;
                                break;
                            case 'array':
                                if (!_.isArray(param) ) isValid = false;
                                break;
                            case 'object':
                                if (!_.isObject(param) ) isValid = false;
                                break;
                            case 'file':
                            case 'boolean':
                                break;
                                break;
                        }
                        if (!isValid) {
                            errorFields.push(name);
                        }
                    }
                }

                params[name] = param;
            }
        });

        request.params = params;

        debug( "errorFields", errorFields, params );

        return errorFields.length > 0 ? false : true;
    }

    checkParams(request, response, params, next) {
        debug( "checkParams", params );

        if ( !this.verifyParams( request, params ) ) {
            return this.onError( response, "INSUFFICIENT_PARAMS", {} );
        }

        next();
    }

    generateToken( userInfo ) {

        const config = this._authConfig;

        debug( "generateToken", userInfo, config );

        const token = jwt.sign(userInfo, config.tokenSecret, {
            algorithm: config.tokenAlgorithm,
            expiresIn: config.expiresTokenIn
        });

        return token;
    }

    isValidToken( token, refresh, callback ) {

        debug( "isValidToken", token, refresh );

        const config = this._authConfig;

        jwt.verify( token, config.tokenSecret, ( err, decode ) => {
            if ( err ) {
                callback( { isValid: false, error: err } );
                return;
            }

            const exp = new Date( decode.exp * 1000 );
            const now = Date.now();

            if ( exp < now ) {
                let error = new Error( 'Expired Token' );
                callback( { isValid: false, error } );
                return;
            }

            if ( refresh === true ) {
                const refreshsIn = (config.expiresTokenIn - config.refreshsTokenIn);
                const isNeedToRefresh = (exp - refreshsIn) < now ? true : false;

                if (isNeedToRefresh) {
                    const newToken = this.generateToken( decode );
                    callback( { isValid: true, newToken, userInfo: decode } );
                    return;
                }
            }

            callback( { isValid:true, userInfo: decode } );
        });
    }

    getAccessToken( request ) {

        const authorization = request.headers['authorization'];

        debug( "getAccessToken", authorization );

        if (authorization) {
            if (typeof authorization !== 'string') {
                return null;
            }

            const matches = authorization.match(/(\S+)\s+(\S+)/);
            const authHeaders = matches && { scheme: matches[1], value: matches[2] };

            debug( "authHeaders", authHeaders );

            if (authHeaders.scheme.toLowerCase() === 'bearer') {
                return authHeaders.value;
            }
        }
        else if (request.headers['x-access-token']){
            return request.headers['x-access-token'];
        }

        return null;
    }

    parseToken(request, response, next) {

        let token = this.getAccessToken(request);

        if (token) {
            request.token = token;

            this.isValidToken(token, false, ({error, isValid, newToken, userInfo }) => {
                if (userInfo) {
                    request.userInfo = userInfo;
                }
                next();
            });
        }
        else {
            next();
        }
    }

    checkToken(request, response, refresh, next) {

        let token = this.getAccessToken(request);

        debug( "checkToken", token );

        if (!token) {
            return this.onError( response, "NEED_LOGIN", {} );
        }

        request.token = token;

        this.isValidToken(token, refresh, ({error, isValid, newToken, userInfo }) => {
            if (error) {
                return this.onError( response, error.message, {} );
            }

            if (isValid === false) {
                return this.onError( response, "INVALID_TOKEN", {} );
            }

            if (!userInfo) {
                return this.onError( response, "NEED_LOGIN", {} );
            }

            if (newToken) {
                request.newToken = newToken;
            }

            request.userInfo = userInfo;

            next();
        });
    }

    generateRouters( options ) {
        let { router, service, routers } = options;

        routers.forEach((routerOption) => {
            const { controllers, params, permissions, description } = routerOption;

            const routePath = routerOption.path;
            const method = routerOption.method.toLowerCase();

            if (!router[method] || !['get', 'post', 'put', 'delete'].includes(method)) {
                throw new Error('invalid method ' + routePath);
            }

            if (controllers.length === 0 || typeof controllers[0] !== 'function') {
                throw new Error('invalid controller ' + routePath + " method " + method);
            }

            let middlewares = [];

            if (params) {
                middlewares.push((request, response, next) => {
                    this.checkParams(request, response, params, next );
                });
            }

            if (permissions) {
                if (permissions.includes("token") || permissions.includes("admin")) {
                    middlewares.push((request, response, next) => {
                        this.checkToken(request, response, permissions.includes("refreshToken"), next );
                    });
                }
                else {
                    middlewares.push((request, response, next) => {
                        this.parseToken(request, response, next );
                    });
                }
            }

            const args = [routePath, ...middlewares, ...controllers];

            debug( "register router", method, args );

            router[method].apply(router, args);

            routerOption.routePath = path.join(this._service.path, routePath);
            routerOption.group = this._service.name;
            routerOption.tags = this._tags || routerOption.tags || [];

            process.motif._routerPaths.push( routerOption );
        });

        debug( "generateRouters", process.motif._routerPaths.length );
    }

    jsonResponse( response, data ) {
        data = data || {};

        debug( "jsonResponse", data );

        response.set({'content-type': this.contentType});
        response.json(data);
    }

    onSuccess( response, data ) {
        this.jsonResponse(response, {status: "success", data: data});
    }

    onError( response, message, data ) {

        debug("error", message );

        this.jsonResponse(response, {status: "error", error: message, data: data});
    }
}

module.exports = Controller;