react-apollo-graphql/lib/server.js

Get rid of decorators and use Apollo GraphQL queries and mutations in the simple and readable way.

'use strict';

exports.__esModule = true;
exports.getDataFromTree = undefined;

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

var _assign = require('babel-runtime/core-js/object/assign');

var _assign2 = _interopRequireDefault(_assign);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var getDataFromTree = exports.getDataFromTree = function () {
  var _ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee(element) {
    var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    var Component, props, childContext, child, instance, promises;
    return _regenerator2.default.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            if (!(element == null)) {
              _context.next = 2;
              break;
            }

            return _context.abrupt('return');

          case 2:

            // get type of element
            Component = element.type;

            // a functional stateless component or a class

            if (!(typeof Component === 'function')) {
              _context.next = 26;
              break;
            }

            // create props
            props = (0, _assign2.default)({}, Component.defaultProps, element.props);
            childContext = context;
            child = void 0;

            if (!(Component.prototype && Component.prototype.isReactComponent)) {
              _context.next = 21;
              break;
            }

            instance = new Component(props, context);
            // In case the user doesn't pass these to super in the constructor

            instance.props = instance.props || props;
            instance.context = instance.context || context;

            // Override setState to just change the state, not queue up an update.
            //   (we can't do the default React thing as we aren't mounted "properly"
            //   however, we don't need to re-render as well only support setState in
            //   componentWillMount, which happens *before* render).
            instance.setState = function (state, cb) {
              if (typeof state === 'function') {
                instance.state = (0, _assign2.default)({}, instance.state, state(instance.state));
              } else {
                instance.state = (0, _assign2.default)({}, instance.state, state);
              }

              if (typeof cb === 'function') {
                cb();
              }
            };

            if (instance.componentWillMount) {
              instance.componentWillMount();
            }

            if (instance.getChildContext) {
              childContext = (0, _assign2.default)({}, context, instance.getChildContext());
            }

            // is this GraphQL component?

            if (!(element.type === _2.default)) {
              _context.next = 17;
              break;
            }

            _context.next = 17;
            return _promise2.default.all(instance.getObservers().map(function (observer) {
              return new _promise2.default(function (resolve, reject) {
                try {
                  observer.result().then(function () {
                    return resolve();
                  }, function () {
                    return resolve();
                  });
                } catch (e) {
                  reject(e);
                }
              });
            }));

          case 17:

            // now call render, we have everything resolved and updated so it should return a child
            // then call this function on child
            child = instance.render();

            if (element.type === _2.default) {
              // unmount GraphQL component so we can clean up subscriptipns
              instance.componentWillUnmount();
            }
            _context.next = 22;
            break;

          case 21:
            // just a stateless functional
            child = Component(props, context);

          case 22:
            _context.next = 24;
            return getDataFromTree(child, childContext);

          case 24:
            _context.next = 31;
            break;

          case 26:
            if (!(element.props && element.props.children)) {
              _context.next = 31;
              break;
            }

            promises = [];


            _react.Children.forEach(element.props.children, function (child) {
              if (child) {
                promises.push(getDataFromTree(child, context));
              }
            });

            _context.next = 31;
            return _promise2.default.all(promises);

          case 31:
          case 'end':
            return _context.stop();
        }
      }
    }, _callee, this);
  }));

  return function getDataFromTree(_x2) {
    return _ref.apply(this, arguments);
  };
}();

var _ = require('./');

var _2 = _interopRequireDefault(_);

var _react = require('react');

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