yahoi/dist/lib/Server.js

Yet Another Highly Opinionated Isomorphic Framework

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = undefined;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

require('./conditional-babel-polyfill');

var _express = require('express');

var _express2 = _interopRequireDefault(_express);

var _readdir = require('readdir');

var _readdir2 = _interopRequireDefault(_readdir);

var _bodyParser = require('body-parser');

var _bodyParser2 = _interopRequireDefault(_bodyParser);

var _cookieParser = require('cookie-parser');

var _cookieParser2 = _interopRequireDefault(_cookieParser);

var _compression = require('compression');

var _compression2 = _interopRequireDefault(_compression);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _ErrorController = require('./../Controller/ErrorController');

var _ErrorController2 = _interopRequireDefault(_ErrorController);

var _TranslationController = require('./../Controller/TranslationController');

var _TranslationController2 = _interopRequireDefault(_TranslationController);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var ENVIRONMENT_PATH = "Environments/";
var ROUTERS_PATH = "Routing/";
var Controller_PATH = "Controller/";
var Services_PATH = "Services/";

var Server = function () {
  function Server(props) {
    _classCallCheck(this, Server);

    this.__props = props;
    this.__environment = this.loadEnvironment(props.env);
    this.__services = this.loadServices(props.env);
    this.__controller = this.loadController(props.env);

    // Default Error Controller
    var defaultErrorController = new _ErrorController2.default({ app: this });
    defaultErrorController.setViewDirectory(_path2.default.resolve(__dirname, '..', 'Views'));
    defaultErrorController.setProjectDirectory(_path2.default.resolve(__dirname, '..'));
    defaultErrorController.setComponentDirectory(_path2.default.resolve(__dirname, '..', 'Components'));
    defaultErrorController.setContainerDirectory(_path2.default.resolve(__dirname, '..', 'Containers'));
    this.__controller['__defaultErrorController'] = defaultErrorController;

    // Default Translation Controller
    var defaultTranslationController = new _TranslationController2.default({ app: this });
    defaultTranslationController.setViewDirectory(_path2.default.resolve(__dirname, '..', 'Views'));
    defaultTranslationController.setProjectDirectory(_path2.default.resolve(__dirname, '..'));
    defaultTranslationController.setComponentDirectory(_path2.default.resolve(__dirname, '..', 'Components'));
    defaultTranslationController.setContainerDirectory(_path2.default.resolve(__dirname, '..', 'Containers'));
    this.__controller['DefaultTranslation'] = defaultTranslationController;

    this.__routers = this.loadRouters(props.env);
    this.__expressApp = (0, _express2.default)();

    this.__expressApp.use(_bodyParser2.default.urlencoded({ extended: true }));
    this.__expressApp.use(_bodyParser2.default.json());
    this.__expressApp.use((0, _cookieParser2.default)());

    this.getController = this.getController.bind(this);

    this.__defaultRouter = new this.__routers['Default']({ app: this });

    this.__defaultRouter.addRoute({ path: '/Translations', router: 'DefaultTranslation' });

    if (typeof process.env.NODE_ENV != 'undefined' && process.env.NODE_ENV == 'development') {
      // Development
      var enableHmrMidWare = require('./dev/expressMiddleware.js');
      enableHmrMidWare(this, this.__expressApp);
    } else {
      // Production
      this.__expressApp.use((0, _compression2.default)());
    }
  }

  _createClass(Server, [{
    key: 'getDefaultRouter',
    value: function getDefaultRouter() {
      return this.__defaultRouter;
    }
  }, {
    key: 'getController',
    value: function getController(name) {
      if (typeof this.__controller[name] == 'undefined') {
        throw Error('Controller could not be found: ' + name);
      }
      return this.__controller[name];
    }
  }, {
    key: 'getService',
    value: function getService(name) {
      return this.__services[name];
    }
  }, {
    key: 'loadRouters',
    value: function loadRouters() {
      var _this = this;

      try {
        var routers = {};
        _readdir2.default.readSync(this.getProjectPath() + '/' + ROUTERS_PATH).map(function (routerFile) {
          if (routerFile.indexOf('.js') > 0) {
            var routerName = routerFile.substr(0, routerFile.length - 9);
            routers[routerName] = require(_this.getProjectPath() + '/' + ROUTERS_PATH + routerFile).default;
          }
        });

        // build-in
        _readdir2.default.readSync(__dirname + '/../Routing').map(function (routerFile) {

          if (routerFile.indexOf('.js') > 0) {
            var routerName = routerFile.substr(0, routerFile.length - 9);

            routers[routerName] = require(__dirname + '/../Routing/' + routerFile).default;
          }
        });

        //      console.log('initialized routers', routers);
        return routers;
      } catch (e) {
        throw e;
      }
    }
  }, {
    key: 'loadController',
    value: function loadController() {
      var _this2 = this;

      try {
        var controller = {};
        _readdir2.default.readSync(this.getProjectPath() + '/' + Controller_PATH).map(function (controllerFile) {
          if (controllerFile.indexOf('Controller.js') > 0) {
            var cntrlName = controllerFile.substr(0, controllerFile.length - 13);
            var controllerObj = new (require(_this2.getProjectPath() + '/' + Controller_PATH + controllerFile).default)({ app: _this2 });
            controllerObj.setViewDirectory(_path2.default.resolve(_this2.getProjectPath(), 'Views'));
            controllerObj.setProjectDirectory(_this2.getProjectPath());
            controllerObj.setComponentDirectory(_path2.default.resolve(_this2.getProjectPath(), 'Components'));
            controllerObj.setContainerDirectory(_path2.default.resolve(_this2.getProjectPath(), 'Containers'));
            controller[cntrlName] = controllerObj;
          }
        });
        return controller;
      } catch (e) {
        throw e;
      }
    }
  }, {
    key: 'loadServices',
    value: function loadServices() {
      var _this3 = this;

      try {
        var services = {};
        _readdir2.default.readSync(this.getProjectPath() + '/' + Services_PATH).map(function (serviceFile) {
          if (serviceFile.indexOf('Service.js') > 0) {
            var serviceName = serviceFile.substr(0, serviceFile.length - 10);
            var serviceObj = new (require(_this3.getProjectPath() + '/' + Services_PATH + serviceFile).default)({ app: _this3 });
            //          controllerObj.setViewDirectory(path.resolve(this.getProjectPath(), 'Views'));
            serviceObj.setProjectDirectory(_this3.getProjectPath());
            serviceObj.setComponentDirectory(_path2.default.resolve(_this3.getProjectPath(), 'Components'));
            serviceObj.setContainerDirectory(_path2.default.resolve(_this3.getProjectPath(), 'Containers'));
            services[serviceName] = serviceObj;
          }
        });
        return services;
      } catch (e) {
        throw e;
      }
    }
  }, {
    key: 'createRouter',
    value: function createRouter(name, props) {

      if (typeof this.__routers[name] == 'undefined') {
        throw Error('Router ' + name + ' not found');
      }
      return new this.__routers[name](props);
    }
  }, {
    key: 'getProjectPath',
    value: function getProjectPath() {
      return this.__props.projectPath;
    }
  }, {
    key: 'getEnvironment',
    value: function getEnvironment() {
      return this.__environment;
    }
  }, {
    key: 'loadEnvironment',
    value: function loadEnvironment(name) {
      try {
        return require(this.getProjectPath() + '/' + ENVIRONMENT_PATH + name).default;
      } catch (e) {
        throw e;
      }
    }
  }, {
    key: 'start',
    value: function start() {
      var _this4 = this;

      this.__expressApp.use('/Public', _express2.default.static(this.getProjectPath() + '/Public'));

      /*
          this.__expressApp.use('/Translations/get', (req, res) => {
      
              this.getController('__defaultTranslationController')
                  .renderAction('get', req, res)
                  .then(actionContext => {
                    try {
                      actionContext.getResponse().respond(req, res);
                    } catch(e) {
                      res.send('[1] Internal Server Error: ' + String(e));
                    }
                  })
                  .catch(e => {
                    res.send('[2] Internal Server Error: ' + String(e));
              	  })
            
            
            
          })
      */

      //this.__expressApp.use('/Translations', express.static(`${this.getProjectPath()}/Translations`))

      this.__expressApp.all("*", function (req, res) {
        var matchResult = _this4.getDefaultRouter().match(req);
        if (matchResult) {
          matchResult.route.renderAction(req, res, matchResult).then(function (actionContext) {
            try {
              actionContext.getResponse().respond(req, res);
            } catch (e) {
              res.send('Error: ' + String(e));
            }
          }).catch(function (e) {
            req.query = {
              error: e,
              controllerName: matchResult.route.getControllerName(),
              actionName: matchResult.route.getActionName()
            };

            _this4.getController('__defaultErrorController').renderAction('actionError', req, res).then(function (actionContext) {
              try {
                actionContext.getResponse().respond(req, res);
              } catch (e) {
                res.send('[1] Internal Server Error: ' + String(e));
              }
            }).catch(function (e) {
              res.send('[2] Internal Server Error: ' + String(e));
            });
          });
        } else {
          _this4.getController('__defaultErrorController').renderAction('noRoute', req, res).then(function (actionContext) {
            try {
              actionContext.getResponse().respond(req, res);
            } catch (e) {
              console.log('Internal Server Error:', e);
              res.send('Internal Server Error: ' + String(e));
            }
          }).catch(function (e) {
            console.log('renderedError', e);
          });
        }
      });

      this.__expressApp.listen(this.getEnvironment().server.port, function () {
        console.log('Server started: ' + process.env.NODE_ENV);
        console.log('Project Path: ', _this4.getProjectPath());
        console.log('Port: ', _this4.getEnvironment().server.port);
      });
    }
  }]);

  return Server;
}();

exports.default = Server;