graphql-compose/es/storage.js

GraphQL schema builder from different data sources with middleware extensions.

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

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

import { GraphQLObjectType, GraphQLSchema, getNamedType } from 'graphql';
import TypeComposer from './typeComposer';

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 TypeComposer)) {
        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] = TypeComposer.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 Set();

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

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

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

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

      var relations = typeComposer.getRelations();
      var relationFieldNames = Object.keys(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();
      Object.keys(fields).forEach(function (fieldName) {
        var typeAndField = typeComposer.getTypeName() + '.' + fieldName;
        var fieldType = getNamedType(fields[fieldName].type);
        if (fieldType instanceof GraphQLObjectType && !createdRelations.has(typeAndField)) {
          createdRelations.add(typeAndField);
          _this.buildRelations(new TypeComposer(fieldType), createdRelations);
        }
      });
    }
  }, {
    key: 'removeEmptyTypes',
    value: function removeEmptyTypes(typeComposer) {
      var _this2 = this;

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

      var fields = typeComposer.getFields();
      Object.keys(fields).forEach(function (fieldName) {
        var fieldType = fields[fieldName].type;
        if (fieldType instanceof GraphQLObjectType) {
          var _typeName = fieldType.name;
          if (!passedTypes.has(_typeName)) {
            passedTypes.add(_typeName);
            var tc = new TypeComposer(fieldType);
            if (Object.keys(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;
}();

export default ComposeStorage;