soya/lib/Application.js

'use strict';

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

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

var _Compiler = require('./compiler/Compiler');

var _Compiler2 = _interopRequireDefault(_Compiler);

var _Router = require('./router/Router');

var _Router2 = _interopRequireDefault(_Router);

var _EntryPoint = require('./EntryPoint');

var _EntryPoint2 = _interopRequireDefault(_EntryPoint);

var _ServerHttpRequest = require('./http/ServerHttpRequest');

var _ServerHttpRequest2 = _interopRequireDefault(_ServerHttpRequest);

var _Provider = require('./Provider.js');

var _Provider2 = _interopRequireDefault(_Provider);

var _CookieJar = require('./http/CookieJar.js');

var _CookieJar2 = _interopRequireDefault(_CookieJar);

var _ServerCookieJar = require('./http/ServerCookieJar.js');

var _ServerCookieJar2 = _interopRequireDefault(_ServerCookieJar);

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _http = require('http');

var _http2 = _interopRequireDefault(_http);

var _domain = require('domain');

var _domain2 = _interopRequireDefault(_domain);

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

/**
 * Orchestrates all the things that makes the application server run:
 *
 * 1. Gets the list of entry points from ComponentRegister.
 * 2. Compiles the code with the given Compiler implementation.
 * 3. Create and run the server.
 * 4. Handles the requests.
 *
 * In handling the requests:
 *
 * 1. Passes request and response to middlewares generated by Compiler.
 * 2. If not handled, Compiler middlewares will call next, which will pass
 *    the torch to soya middleware.
 * 3. Soya middleware will ask Router which page to run, ask Page to render,
 *    ask Compiler to assemble HTML and send response.
 *
 * Uses node-js domain for error handling.
 *
 * TODO: Make every process async with Promise?
 *
 * This object is stateless, should not store ANY request-specific states.
 *
 * @SERVER
 */
var Application = function () {

  /**
   * @param {Logger} logger
   * @param {ComponentRegister} componentRegister
   * @param {Object} routes
   * @param {Router} router
   * @param {Compiler} compiler
   * @param {ErrorHandler} errorHandler
   * @param {ReverseRouter} reverseRouter
   * @param {Object} frameworkConfig
   * @param {Object} serverConfig
   * @param {Object} clientConfig
   */


  /**
   * The idea is to have middleware system that is compatible with express
   * middlewares. Since express middlewares are just functions accepting req,
   * res, and next - it should not be hard to make it compatible.
   * Kudos to the express team to make such an awesome framework btw.
   *
   * @type {Array<Function>}
   */


  /**
   * @type {Provider}
   */


  /**
   * @type {ErrorHandler}
   */


  /**
   * @type {ComponentRegister}
   */


  /**
   * @type {Compiler}
   */


  /**
   * @type {Object}
   */


  /**
   * @type {Router}
   */
  function Application(logger, componentRegister, routes, router, reverseRouter, errorHandler, compiler, frameworkConfig, serverConfig, clientConfig) {
    _classCallCheck(this, Application);

    // Change register to real client registration function.
    this._addReplace(frameworkConfig, 'soya/lib/client/Register', 'soya/lib/client/RegisterClient');

    // Change react renderer to client version.
    this._addReplace(frameworkConfig, 'soya/lib/page/react/ReactRenderer', 'soya/lib/page/react/ReactRendererClient');

    // Allow users to run code blocks on server or client.
    this._addReplace(frameworkConfig, 'soya/lib/scope', 'soya/lib/scope-client');

    // Replace custom node registration function for client.
    if (frameworkConfig.routerNodeRegistrationAbsolutePath) {
      this._addReplace(frameworkConfig, 'soya/lib/server/registerRouterNodes', frameworkConfig.routerNodeRegistrationAbsolutePath);
    }

    this._logger = logger;
    this._serverCreated = false;
    this._componentRegister = componentRegister;
    this._compiler = compiler;
    this._frameworkConfig = frameworkConfig;
    this._serverConfig = serverConfig;
    this._clientConfig = clientConfig;
    this._router = router;
    this._errorHandler = errorHandler;
    this._pages = {};
    this._routeForPages = {};
    this._entryPoints = [];
    this._pageClasses = {};
    this._provider = new _Provider2.default(serverConfig, reverseRouter, true);
    this._absoluteClientDepFile = _path2.default.join(this._frameworkConfig.absoluteProjectDir, 'build/dep.json');

    var cookieJar = new _CookieJar2.default();
    var i,
        pageCmpt,
        page,
        pageComponents = componentRegister.getPages();
    var routeRequirements, j, routeId;

    for (i in pageComponents) {
      if (!pageComponents.hasOwnProperty(i)) continue;
      pageCmpt = pageComponents[i];

      // Create entry point.
      this._entryPoints.push(new _EntryPoint2.default(pageCmpt.name, pageCmpt.absDir));
      this._pageClasses[pageCmpt.name] = pageCmpt.clazz;

      try {
        // Instantiate page. We try to instantiate page at startup to find
        // potential problems with each page. This allows us to detect factory
        // naming clash early on while also allowing the start-up process to
        // populate Provider with ready to use dependencies.
        page = new pageCmpt.clazz(this._provider, cookieJar, true);
      } catch (e) {
        throw e;
      }

      this._routeForPages[pageCmpt.name] = {};
      if (typeof pageCmpt.clazz.getRouteRequirements == 'function') {
        routeRequirements = pageCmpt.clazz.getRouteRequirements();
        for (j = 0; j < routeRequirements.length; j++) {
          routeId = routeRequirements[j];
          if (!routes.hasOwnProperty(routeId)) {
            throw new Error('Page ' + pageCmpt.name + ' has dependencies to unknown route: ' + routeId + '.');
          }
          this._routeForPages[pageCmpt.name][routeId] = routes[routeId];
        }
      }
    }

    this._middlewares = [];
  }

  /**
   * @param {Object} frameworkConfig
   * @param {string} source
   * @param {string} replacement
   */


  /**
   * @type {boolean}
   */


  /**
   * @type {{[key: string]: Function}}
   */


  /**
   * @type {Logger}
   */


  /**
   * @type {Array<EntryPoint>}
   */


  /**
   * @type {CompileResult}
   */


  /**
   * @type {Object}
   */


  /**
   * @type {Object}
   */

  /**
   * @type {Object}
   */


  _createClass(Application, [{
    key: '_addReplace',
    value: function _addReplace(frameworkConfig, source, replacement) {
      frameworkConfig.clientReplace[source] = replacement;
      frameworkConfig.clientReplace[source + '.js'] = replacement;
    }

    /**
     * Compiles and then create an http server that handles requests.
     */

  }, {
    key: 'start',
    value: function start() {
      var _this = this;

      // If precompileClient true, try get page dependency map from previously generated dep.json to
      // fill this._compileResult
      if (this._frameworkConfig.precompileClient && _fs2.default.existsSync(this._absoluteClientDepFile)) {
        this._middlewares = this._compiler.run(this._entryPoints, null, false);
        this._compileResult = JSON.parse(_fs2.default.readFileSync(this._absoluteClientDepFile));
      } else {
        // Runs runtime compilation. This will update compilation result when
        // compilation is done, while returning array of compiler specific
        // middlewares for us.
        this._middlewares = this._compiler.run(this._entryPoints, function (compileResult) {
          _this._compileResult = compileResult;
        });
      }

      // Add soya middleware as the last one.
      this._middlewares.push(this.handle.bind(this));

      return this._middlewares;
    }

    /**
     * Do mostly the same work as start(), except this doesn't createServer() and write compile result to dep.json
     */

  }, {
    key: 'buildClient',
    value: function buildClient() {
      var _this2 = this;

      this._compiler.run(this._entryPoints, function (compileResult) {
        _fs2.default.writeFileSync(_this2._absoluteClientDepFile, JSON.stringify(compileResult), 'utf8');
      });
    }
  }, {
    key: 'createServer',
    value: function createServer() {
      var _this3 = this;

      if (this._serverCreated) {
        // No need to create more than one server.
        return;
      }

      // No need to listen twice.
      this._serverCreated = true;

      // TODO: Config can set timeout for http requests.
      _http2.default.createServer(function (request, response) {
        // Control for favicon
        if (request.method === 'GET' && request.url === '/favicon.ico') {
          var faviconPath = _path2.default.join(_this3._frameworkConfig.absoluteProjectDir, 'favicon.ico');
          if (_fs2.default.existsSync(faviconPath)) {
            response.writeHead(200, { 'Content-Type': 'image/x-icon' });
            response.end(_fs2.default.readFileSync(faviconPath), 'binary');
            return;
          }
        }
        var d = _domain2.default.create().on('error', function (error) {
          _this3.handleError(error, request, response);
        });
        d.run(function () {
          var index = 0;
          var runMiddleware = function runMiddleware() {
            var middleware = _this3._middlewares[index++];
            if (!middleware) return;
            middleware(request, response, runMiddleware);
          };

          // Run the first middleware.
          runMiddleware();
        });
      }).listen(this._frameworkConfig.port, function () {
        if (process && typeof process.send === 'function') process.send('ready');
        _this3._logger.info('Server listening at port: ' + _this3._frameworkConfig.port + '.');
      });
    }

    /**
     * @param {http.incomingMessage} request
     * @param {httpServerResponse} response
     * @param {?void} next
     */

  }, {
    key: 'handle',
    value: function handle(request, response, next) {
      // Directly over to next-js when it is next request
      if (request.url.indexOf("_next") !== -1) {
        next();
        return;
      }

      var httpRequest = new _ServerHttpRequest2.default(request, this._frameworkConfig.maxRequestBodyLength);
      var routeResult = this._router.route(httpRequest);
      // Over to next-js when page is not found
      if (routeResult == null) {
        next();
        return;
      }

      var pageClass = this._pageClasses[routeResult.pageName];
      if (!pageClass) {
        throw new Error('Unable to route request, page ' + routeResult.pageName + ' doesn\'t exist');
      }

      // Because we tried to instantiate all pages at start-up we can be sure
      // that pageClass exists.
      var cookieJar = new _ServerCookieJar2.default(request);
      var page = new pageClass(this._provider, cookieJar, true);
      var store = page.createStore(null);

      this._logger.debug('Rendering page: ' + routeResult.pageName + '.', null);
      page.render(httpRequest, routeResult.routeArgs, store, this._handleRenderResult.bind(this, routeResult, request, httpRequest, response, store, cookieJar));
    }

    /**
     * @param {RouteResult} routeResult
     * @param {http.incomingMessage} request
     * @param {ServerHttpRequest} httpRequest
     * @param {httpServerResponse} response
     * @param {void | Store} store
     * @param {ServerCookieJar} cookieJar
     * @param {RenderResult} renderResult
     */

  }, {
    key: '_handleRenderResult',
    value: function _handleRenderResult(routeResult, request, httpRequest, response, store, cookieJar, renderResult) {
      var _this4 = this;

      var pageDep = this._compileResult.pages[routeResult.pageName];
      if (!pageDep) {
        throw new Error('Unable to render page server side, dependencies unknown for entry point: ' + routeResult.componentName);
      }

      var promise = Promise.resolve(null);

      if (store) {
        if (store._shouldRenderBeforeServerHydration()) {
          store._startRender();
          // Render first to let all segment and query requirements registered
          // to the store. This is weird and sort of wasteful, but we haven't
          // found a better way yet.
          renderResult.contentRenderer.render(routeResult.routeArgs, this._routeForPages[routeResult.pageName], this._clientConfig, null, pageDep);
          store._endRender();
        }

        //this._logger.debug('Store requirements gathered, start hydration.', null, store);
        promise = store.hydrate();
      }

      var handlePromiseError = function handlePromiseError(error) {
        // Just in case user store code doesn't reject with Error object.
        error = _this4._ensureError(error);
        _this4.handleError(error, request, response);
      };

      var storeResolve = function storeResolve() {
        var state = null;
        if (store) {
          state = store._getState();
          //this._logger.debug('Finish hydration.', null, state);
          store._startRender();
        }

        var htmlResult = renderResult.contentRenderer.render(routeResult.routeArgs, _this4._routeForPages[routeResult.pageName], _this4._clientConfig, state, pageDep);

        if (store) store._endRender();

        response.statusCode = renderResult.httpStatusCode;
        response.statusMessage = renderResult.httpStatusMessage;

        // TODO: Calculating content length as utf8 is hard-coded. This might be harmful, maybe move as configuration of the compiler?
        response.setHeader('Content-Length', Buffer.byteLength(htmlResult, 'utf8'));
        response.setHeader('Content-Type', 'text/html;charset=UTF-8');

        // Set result headers.
        var key,
            headerData = renderResult.httpHeaders.getAll();
        for (key in headerData) {
          if (!headerData.hasOwnProperty(key)) continue;
          response.setHeader(key, headerData[key]);
        }

        // Set result cookies.
        var cookieValues = cookieJar.generateHeaderValues();
        if (cookieValues.length > 0) {
          response.setHeader('Set-Cookie', cookieValues);
        }

        // Set result content.
        response.end(htmlResult);
      };

      promise.then(storeResolve).catch(handlePromiseError);
    }

    /**
     * @param {Error} error
     * @param {http.incomingRequest} request
     * @param {httpServerResponse} response
     */

  }, {
    key: 'handleError',
    value: function handleError(error, request, response) {
      if (response.headersSent) {
        this._errorHandler.responseSentError(error, request, response);
        return;
      }

      this._errorHandler.responseNotSentError(error, request, response);
    }

    /**
     * @param {any} error
     * @return {Error}
     */

  }, {
    key: '_ensureError',
    value: function _ensureError(error) {
      if (error instanceof Error) return error;
      if (typeof error == 'string') return new Error(error);
      return new Error('Error when resolving store promise! Unable to convert reject arg: ' + error);
    }
  }]);

  return Application;
}();

exports.default = Application;
//# sourceMappingURL=Application.js.map