@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;
  }

  async defaultModel(connection) {
    let model = new Model();
    let design = new DAO.Design({
      type: this._dbConnection.type,
      databaseConnection: this._dbConnection
    });

    try {
      await design.initialize();
    } catch (e) {
      console.log(e);
    }

    model.setCollection(design.createCollection(connection));
    return model;
  }

  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;
  }

  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});
  }

  constructor({service, dbConnection}) {
    debug("controller", service, dbConnection);

    this._service = service;
    this._dbConnection =
      typeof dbConnection === "string"
        ? Model.dbConnection(dbConnection)
        : dbConnection;
    this._models = process.motif.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);
      }
    });
  }
}

module.exports = Controller;