mio-server/services/moduleComposer.js

// Modules Initializer and Loader
'use strict';

const cluster = require('cluster');
const config = require('./config')();
const winston = require('winston');
const chalk = require('chalk');
const fs = require('fs');
const path = require('path');
const express = require('express');
const access = require('mio-roles');
const extensionParser = require('mio-extensions');
const services = require('mio-services');
const wait = require('wait.for');

// List of modules
global.mio.modules = [];

// Print Once
function _printOnce(){
  return (cluster.isMaster || (cluster.worker && cluster.worker.id==1));
}

// Load Module META
function loadMETA(moduleName, logName){
  var mod = {
    name: moduleName
  };

  mod.path = path.join(global.mio.appPath, 'modules', moduleName);

  // Load configs
  mod.config = require('./config')(moduleName).get(moduleName);

  // Set Module Version
  if(mod.config && mod.config.version){
    mod.version = mod.config.version;
  }

  // Load localizations
  var i18nOptions = {
    path: path.join(mod.path, 'i18n'),
    prefix: mod.name
  };
  if(mod.config && mod.config.i18n && mod.config.i18n.defaultLocale){
    i18nOptions.defaultLocale = mod.config.i18n.defaultLocale;
  }
  mod._i18n = require('mio-i18n')(i18nOptions);
  mod.i18n = function(key, defaultValue, vars){
    return mod._i18n.get(key, defaultValue, vars, i18nOptions.defaultLocale || 'en', mod.name);
  };

  // Extension parser/Render
  mod.render = extensionParser.render;

  // Create logger
  var _transports = [];
  if(process.env.NODE_ENV!='test'){
    _transports.push(new (winston.transports.Console)());
  }

  var _logPath = path.join(mod.path, 'log');
  logName = logName || mod.name;
  if(fs.existsSync(_logPath)){
    _transports.push(new (winston.transports.File)({ filename: path.join(_logPath, logName+'.log') }));
  }

  var _logOptions = { transports: _transports };

  if(mod.config && mod.config.log && mod.config.log.level){
    _logOptions.level = mod.config.log.level;
  }

  mod.log = new (winston.Logger)(_logOptions);

  return mod;
}

// Load module as API component and load as lib if needed
function load(moduleName){
  var mod = loadMETA(moduleName);

  // Load service connector or service in internal mode
  if(mod.config && mod.config.mode){
    mod.mode = mod.config.mode;
  }else{
    mod.mode = 'internal';
  }

  // Make default empty template
  mod.rpc = (cmd, opts, cb)=>{
    var msg = cmd+'() not implemented';
    mod.log.error(msg);
    if(cb){
      cb(msg);
    }
  };

  // Create module client for internal mode
  if(mod.mode == 'internal'){
    try {
      mod._rpc = require(path.join(mod.path, 'service', 'rpc.js'))(mod);

      for (var method in mod._rpc) {
        mod[method] = mod._rpc[method];
      }
    } catch (e) {
      mod.noRPC = true;
    }
  }

  // Create module client for external mode
  if(mod.mode == 'external'){
    // Get MQ server from global config
    var mqServerConfig = {
      server: 'localhost'
    };
    if(config.get().mq){
      mqServerConfig = config.get().mq;
    }

    var _useCache = false;
    if(config.get(moduleName).RPC && config.get(moduleName).RPC.useCache){
      _useCache = config.get(moduleName).RPC.useCache;
    }

    // Crete client
    wait.launchFiber(()=>{
      try {
        mod._cli = wait.for(services.client, {server: mqServerConfig.server, expires: 15000, useCache: _useCache});
      } catch (e) {
        mod.log.error(e);
      }

      mod.rpc = function(cmd, opts, cb){
        mod._cli.call(mod.name, cmd, opts, cb);
      };

      // Create methods for RPC calls
      if(fs.existsSync(path.join(mod.path, 'service', 'rpc.js'))){
        var _file = fs.readFileSync(path.join(mod.path, 'service', 'rpc.js') , {encoding: 'utf8'});
        var _exp = _file.match(/module.exports[\s\S]*return\s*\{[\s\S]*(?=\})/m);
        if(_exp && _exp[0]){
          _exp = _exp[0];
          _exp = _exp.match(/return\s?\{[\s\S]*(?=\})/m);
          if(_exp && _exp[0]){
            _exp = _exp[0];
            _exp = _exp.replace('{','').replace('return','').replace(/\s\n?/m,'');
            var _cmd = _exp.split(',');
            if(_cmd && _cmd.length){
              _cmd = _cmd.map((item)=>{
                return item.split(':')[1].trim();
              });
              _cmd.map((_tmpCmd)=>{
                mod[_tmpCmd] = function(opts, cb){
                  mod._cli.call(mod.name, _tmpCmd, opts, cb);
                };
              });
            }
          }
        }
      }

    });
  }

  // Load API controller
  var _controllerPath = path.join(mod.path, 'api', 'controller.js');
  if(fs.existsSync(_controllerPath)){
    mod.controller = require(_controllerPath)(mod);
  }

  // Load Policy controlled
  var _policyPath = path.join(mod.path, 'api', 'policy.js');
  if(mod.controller && fs.existsSync(_policyPath)){
    mod.policy = require(_policyPath);
  }

  // Create routes based on configs
  var _routesPath = path.join(mod.path, 'api', 'routes.json');
  if(mod.controller && fs.existsSync(_routesPath)){
    var _routesConfig = require(_routesPath);
    var _router = express.Router();

    for (var _method in _routesConfig) {
      if (_routesConfig.hasOwnProperty(_method)) {
        if(mod.controller && mod.controller[_method]){
          var versionPrefix = '';
          if(mod.version){
            versionPrefix = '/v'+mod.version;
          }

          var _param = _routesConfig[_method].param;
          if(_param){
            _router['param'](_param, mod.controller[_method]);
          }else{
            var _routePath = _routesConfig[_method].route;
            var _roles = _routesConfig[_method].roles;
            for (var i = 0; i < _routesConfig[_method].methods.length; i++) {
              var _httpMethod = _routesConfig[_method].methods[i];

              if(!Array.isArray(_routePath)){
                _routePath = [_routePath];
              }

              _routePath = _routePath.map((item)=>{
                return versionPrefix+'/'+mod.name+item+'.:ext?';
              });

              for (var j = 0; j < _routePath.length; j++) {
                if(_roles){
                  _router['route'](_routePath[j]).all([mod.policy, access(_roles)])[_httpMethod](mod.controller[_method]);
                }else{
                  _router['route'](_routePath[j])[_httpMethod](mod.controller[_method]);
                }
              }
            }
          }
        }
      }
    }

    mod.routes = _router;
  }

  global.mio.modules[mod.name] = mod;

  var _rpcMode = mod.noRPC?'':'with RPC';
  if(_printOnce()){
    winston.info(chalk.green(mod.name),'started in',chalk.blue(mod.mode),'mode',_rpcMode);
  }
}

// List available modules
function listModules(){
  var _modules = fs.readdirSync(path.join(global.mio.appPath, 'modules'));
  if(_modules && _modules.length){
    _modules = _modules.filter((modName)=>{
      return modName.substring(0, 1) != '.';
    });
  }
  return _modules;
}

// List available external modules
function listExternalModules(){
  var _modules = listModules();
  var _external = [];

  for (var i = 0; i < _modules.length; i++) {
    var cfg = require('./config')(_modules[i]).get(_modules[i]);
    if(cfg && cfg.mode && cfg.mode == 'external'){
      _external.push(_modules[i]);
    }
  }

  return _external;
}

// Load all modules in server and project dirs
function loadModules(){
  var _modules = listModules();

  if(_printOnce()){
    winston.info('Detected',chalk.blue(_modules.length),'modules:',chalk.blue(_modules));
  }

  for (var i = 0; i < _modules.length; i++) {
    load(_modules[i]);
  }
}

// Load and start module as independent microservice
function start(moduleName, options){
  // Load module meta
  var mod = loadMETA(moduleName, 'service');

  // Intro message
  winston.info('='.repeat(70));
  winston.info('Just', chalk.green('Make It Once'),'|',chalk.blue('MakeItOnce.net'));
  winston.info('-'.repeat(70));
  winston.info('Starting',moduleName,'service...');

  // Init cassandra
  var bigDataConf = config.get(moduleName).bigdata;
  if(bigDataConf && bigDataConf.use){
    mod.cassandra = require('./cassandra').init(bigDataConf);
  }

  // Init MongoDB
  if(options && options.mongoose){
    mod.mongoose = options.mongoose;
    var dbConf = config.get(moduleName).db;
    if(dbConf && (dbConf.use || (dbConf.server && dbConf.name))){
      require('./mongoose').init(options.mongoose, dbConf);
    }
  }

  // Get MQ server from global config
  var mqServerConfig = {
    server: 'localhost'
  };
  if(config.get().mq){
    mqServerConfig = config.get().mq;
  }

  // Load module
  wait.launchFiber(()=>{
    try {
      mod._srv = wait.for(services.service, {name: mod.name, server: mqServerConfig.server});
    } catch (e) {
      mod.log.error(e);
      process.exit(1);
    }

    try {
      mod._rpc = require(path.join(mod.path, 'service', 'rpc.js'))(mod);
    } catch (e) {
      mod.log.error('Module doesn\'t have RPC or it\'s invalid');
      mod.log.error(e);
      process.exit(1);
    }

    for (var method in mod._rpc) {
      if (mod._rpc.hasOwnProperty(method)) {
        mod._srv.listen(method, mod._rpc[method]);
      }
    }
  });

  // Make module accessable at object
  global.mio.modules[mod.name] = mod;
}

// Exports
module.exports = {
  modules: global.mio.modules,
  loadModules: loadModules,
  listModules: listModules,
  listExternalModules: listExternalModules,
  load: load,
  start: start
};