graphql-compose/lib/storage.js

GraphQL schema builder from different data sources with middleware extensions.

'use strict';

var _keys = require('babel-runtime/core-js/object/keys');

var _keys2 = _interopRequireDefault(_keys);

var _set = require('babel-runtime/core-js/set');

var _set2 = _interopRequireDefault(_set);

var _defineProperty = require('babel-runtime/core-js/object/define-property');

var _defineProperty2 = _interopRequireDefault(_defineProperty);

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; (0, _defineProperty2.default)(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _graphql = require('graphql');

var _typeComposer = require('./typeComposer');

var _typeComposer2 = _interopRequireDefault(_typeComposer);

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

    this.types = {};
  }

  _createClass(ComposeStorage, [{
    key: 'has',
    value: function has(typeName) {
      return !!this.types[typeName];
    }
  }, {
    key: 'add',
    value: function add(typeComposer) {
      if (!(typeComposer instanceof _typeComposer2.default)) {
        throw new Error('You must provide instance of TypeComposer');
      }

      this.types[typeComposer.getTypeName()] = typeComposer;
    }
  }, {
    key: 'clear',
    value: function clear() {
      this.types = {};
    }
  }, {
    key: 'get',
    value: function get(typeName) {
      if (!this.has(typeName)) {
        this.types[typeName] = _typeComposer2.default.create(typeName);
      }
      return this.types[typeName];
    }
  }, {
    key: 'rootQuery',
    value: function rootQuery() {
      return this.get('Query');
    }
  }, {
    key: 'rootMutation',
    value: function rootMutation() {
      return this.get('Mutation');
    }
  }, {
    key: 'resolvers',
    value: function resolvers(typeName) {
      return this.get(typeName).getResolvers();
    }
  }, {
    key: 'resolver',
    value: function resolver(typeName, resolverName) {
      return this.get(typeName).getResolver(resolverName);
    }
  }, {
    key: 'buildSchema',
    value: function buildSchema() {
      var roots = {};

      var createdRelations = new _set2.default();

      if (this.has('Query')) {
        var tc = this.get('Query');
        this.buildRelations(tc, createdRelations);
        this.removeEmptyTypes(tc, new _set2.default());
        roots.query = tc.getType();
      }

      if (this.has('Mutation')) {
        var _tc = this.get('Mutation');
        this.buildRelations(_tc, createdRelations);
        this.removeEmptyTypes(_tc, new _set2.default());
        roots.mutation = _tc.getType();
      }

      if ((0, _keys2.default)(roots).length === 0) {
        throw new Error('Can not build schema. Must be initialized at least one ' + 'of the following types: RootQuery, RootMutation.');
      }

      return new _graphql.GraphQLSchema(roots);
    }
  }, {
    key: 'buildRelations',
    value: function buildRelations(typeComposer, createdRelations) {
      var _this = this;

      var relations = typeComposer.getRelations();
      var relationFieldNames = (0, _keys2.default)(relations);

      relationFieldNames.forEach(function (relationFieldName) {
        var typeAndField = typeComposer.getTypeName() + '.' + relationFieldName;

        var existedField = typeComposer.getField(relationFieldName);
        if (existedField && !existedField._gqcIsRelation) {
          if (!createdRelations.has(typeAndField)) {
            // eslint-disable-next-line
            console.log('GQC: Skip building relation \'' + typeAndField + '\', ' + 'cause this type already has field with such name. ' + 'If you want create relation, you should remove this ' + 'field before run the schema build.');
          }
        } else {
          typeComposer.buildRelation(relationFieldName);
        }
      });

      var fields = typeComposer.getFields();
      (0, _keys2.default)(fields).forEach(function (fieldName) {
        var typeAndField = typeComposer.getTypeName() + '.' + fieldName;
        var fieldType = (0, _graphql.getNamedType)(fields[fieldName].type);
        if (fieldType instanceof _graphql.GraphQLObjectType && !createdRelations.has(typeAndField)) {
          createdRelations.add(typeAndField);
          _this.buildRelations(new _typeComposer2.default(fieldType), createdRelations);
        }
      });
    }
  }, {
    key: 'removeEmptyTypes',
    value: function removeEmptyTypes(typeComposer) {
      var _this2 = this;

      var passedTypes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new _set2.default();

      var fields = typeComposer.getFields();
      (0, _keys2.default)(fields).forEach(function (fieldName) {
        var fieldType = fields[fieldName].type;
        if (fieldType instanceof _graphql.GraphQLObjectType) {
          var _typeName = fieldType.name;
          if (!passedTypes.has(_typeName)) {
            passedTypes.add(_typeName);
            var tc = new _typeComposer2.default(fieldType);
            if ((0, _keys2.default)(tc.getFields()).length > 0) {
              _this2.removeEmptyTypes(tc, passedTypes);
            } else {
              // eslint-disable-next-line
              console.log('GQC: Delete field \'' + typeComposer.getTypeName() + '.' + fieldName + '\' ' + ('with type \'' + tc.getTypeName() + '\', cause it does not have fields.'));
              delete fields[fieldName];
            }
          }
        }
      });
      typeComposer.setFields(fields);
    }
  }]);

  return ComposeStorage;
}();

exports.default = ComposeStorage;