yahoi/dist/lib/ActionContext.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; }; }();

var _ParameterBag = require('./ParameterBag');

var _ParameterBag2 = _interopRequireDefault(_ParameterBag);

var _joi = require('joi');

var _joi2 = _interopRequireDefault(_joi);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _Renderer = require('./Renderer');

var Renderer = _interopRequireWildcard(_Renderer);

var _ResponderTypes = require('./ResponderTypes');

var Responders = _interopRequireWildcard(_ResponderTypes);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

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 ActionContext = function () {
  function ActionContext(props) {
    _classCallCheck(this, ActionContext);

    this.res = props.res;
    this.req = props.req;
    this.action = props.action;
    this.controller = props.controller;
    this.response = null;
    this.renderer = props.renderer;
    this.app = props.app;
    this.config = props.config;
    this.__reject = props.reject;
    this.parameterBag = new _ParameterBag2.default({
      parameters: props.req.query,
      body: props.req.body,
      routeParams: typeof props.match != 'undefined' ? props.match.match : {},
      autoReject: this.autoValidationReject.bind(this)
    });
    this.Joi = _joi2.default;
    this.__send = props.send;
    this.__sendHasBeenCalled = false;
  }

  // String


  _createClass(ActionContext, [{
    key: 'renderString',
    value: function renderString(str, data) {
      return new Renderer.StringRenderer({ string: str, data: data }).render();
    }
  }, {
    key: 'sendString',
    value: function sendString(str, data) {
      var _this = this;

      this.renderString(str, data).then(function (renderedString) {
        var Responder = new Responders.StringResponder({
          string: renderedString
        });
        _this.response = Responder;
        _this.__send(_this);
      }).catch(function (e) {
        _this.__send(String(e));
      });
    }

    // Raw

  }, {
    key: 'send',
    value: function send(body) {
      try {
        var Responder = new Responders.RawResponder({
          body: body
        });
        this.response = Responder;
        this.__send(this);
      } catch (e) {
        this.__send(String(e));
      }
    }

    // Json

  }, {
    key: 'renderJson',
    value: function renderJson(data) {
      return new Renderer.JsonRenderer({ data: data }).render();
    }
  }, {
    key: 'sendJson',
    value: function sendJson(data) {
      var _this2 = this;

      this.renderJson(data).then(function (renderedJson) {
        var Responder = new Responders.JsonResponder({
          data: renderedJson
        });
        _this2.response = Responder;
        _this2.__send(_this2);
      }).catch(function (e) {
        _this2.__send(String(e));
      });
    }

    // View

  }, {
    key: 'renderView',
    value: function renderView(templatePath, data) {
      return new Renderer.ViewRenderer({ filePath: _path2.default.resolve(this.controller.getViewDirectory(), templatePath), data: data }).render();
    }
  }, {
    key: 'sendView',
    value: function sendView(templatePath, data) {
      var _this3 = this;

      this.renderView(templatePath, data).then(function (renderedView) {
        var Responder = new Responders.ViewResponder({
          body: renderedView
        });
        _this3.response = Responder;
        _this3.__send(_this3);
      }).catch(function (e) {
        _this3.__send(String(e));
      });
    }

    //Client

  }, {
    key: 'renderClient',
    value: function renderClient(props) {
      console.log('r c');
      return new Renderer.ClientRenderer({
        projectPath: _path2.default.resolve(this.controller.getProjectDirectory()),
        state: props.state || {},
        req: this.req,
        targetView: props.view || 'Client/index'
      }).render();
    }
  }, {
    key: 'sendClient',
    value: function sendClient(props) {
      var _this4 = this;

      this.renderClient(props).then(function (renderedClient) {
        var Responder = new Responders.ClientResponder({
          body: renderedClient
        });
        _this4.response = Responder;
        _this4.__send(_this4);
      }).catch(function (e) {
        _this4.__send(String(e));
      });
    }
  }, {
    key: 'require',
    value: function require(schema) {
      this.parameterBag.setSchema(schema);
    }
  }, {
    key: 'autoValidationReject',
    value: function autoValidationReject(validationResult) {
      this.sendJson({ validationResult: validationResult });
    }
  }, {
    key: 'getEnvironment',
    value: function getEnvironment() {
      return this.app.getEnvironment();
    }
  }, {
    key: 'getService',
    value: function getService(name) {
      return this.app.getService(name);
    }

    /*
      
      sendComponent(componentPath) {
        this.response = new ResponseTypes.RenderComponent(path.resolve(this.controller.getComponentDirectory(), componentPath))
        this.__send(this);
      }
      
    */

  }, {
    key: 'setResponse',
    value: function setResponse(response) {
      this.response = response;
    }
  }, {
    key: 'getResponse',
    value: function getResponse() {
      return this.response;
    }
  }, {
    key: 'redirect',
    value: function redirect(url, props) {
      var Responder = new Responders.RedirectResponder({
        url: url
      });
      this.response = Responder;
      this.__send(this);
    }
  }, {
    key: 'reject',
    value: function reject(e) {
      this.__reject(e);
    }
  }, {
    key: 'run',
    value: function run() {
      try {
        this.action(this.parameterBag);
      } catch (e) {
        console.log('rejecting due to error');
        this.__reject(e);
      }
    }
  }]);

  return ActionContext;
}();

exports.default = ActionContext;