graphql 14.0.0 → 14.1.1

package/utilities/buildASTSchema.mjs

@@ -1,13 +1,12 @@
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 /**
  * Copyright (c) 2015-present, Facebook, Inc.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict
+ * 
  */
+import objectValues from '../polyfills/objectValues';
 import invariant from '../jsutils/invariant';
 import keyMap from '../jsutils/keyMap';
 import keyValMap from '../jsutils/keyValMap';
@@ -49,26 +48,36 @@ export function buildASTSchema(documentAST, options) {
   }
 
   var schemaDef;
-  var typeDefs = [];
   var nodeMap = Object.create(null);
   var directiveDefs = [];
-
-  for (var i = 0; i < documentAST.definitions.length; i++) {
-    var def = documentAST.definitions[i];
-
-    if (def.kind === Kind.SCHEMA_DEFINITION) {
-      schemaDef = def;
-    } else if (isTypeDefinitionNode(def)) {
-      var typeName = def.name.value;
-
-      if (nodeMap[typeName]) {
-        throw new Error("Type \"".concat(typeName, "\" was defined more than once."));
+  var _iteratorNormalCompletion = true;
+  var _didIteratorError = false;
+  var _iteratorError = undefined;
+
+  try {
+    for (var _iterator = documentAST.definitions[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var def = _step.value;
+
+      if (def.kind === Kind.SCHEMA_DEFINITION) {
+        schemaDef = def;
+      } else if (isTypeDefinitionNode(def)) {
+        nodeMap[def.name.value] = def;
+      } else if (def.kind === Kind.DIRECTIVE_DEFINITION) {
+        directiveDefs.push(def);
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
       }
-
-      typeDefs.push(def);
-      nodeMap[typeName] = def;
-    } else if (def.kind === Kind.DIRECTIVE_DEFINITION) {
-      directiveDefs.push(def);
     }
   }
 
@@ -77,8 +86,8 @@ export function buildASTSchema(documentAST, options) {
     mutation: nodeMap.Mutation,
     subscription: nodeMap.Subscription
   };
-  var definitionBuilder = new ASTDefinitionBuilder(nodeMap, options, function (typeRef) {
-    throw new Error("Type \"".concat(typeRef.name.value, "\" not found in document."));
+  var definitionBuilder = new ASTDefinitionBuilder(nodeMap, options, function (typeName) {
+    throw new Error("Type \"".concat(typeName, "\" not found in document."));
   });
   var directives = directiveDefs.map(function (def) {
     return definitionBuilder.buildDirective(def);
@@ -109,7 +118,7 @@ export function buildASTSchema(documentAST, options) {
     query: operationTypes.query ? definitionBuilder.buildType(operationTypes.query) : null,
     mutation: operationTypes.mutation ? definitionBuilder.buildType(operationTypes.mutation) : null,
     subscription: operationTypes.subscription ? definitionBuilder.buildType(operationTypes.subscription) : null,
-    types: typeDefs.map(function (node) {
+    types: objectValues(nodeMap).map(function (node) {
       return definitionBuilder.buildType(node);
     }),
     directives: directives,
@@ -120,37 +129,26 @@ export function buildASTSchema(documentAST, options) {
 
   function getOperationTypes(schema) {
     var opTypes = {};
-    var _iteratorNormalCompletion = true;
-    var _didIteratorError = false;
-    var _iteratorError = undefined;
+    var _iteratorNormalCompletion2 = true;
+    var _didIteratorError2 = false;
+    var _iteratorError2 = undefined;
 
     try {
-      for (var _iterator = schema.operationTypes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-        var operationType = _step.value;
-        var _typeName = operationType.type.name.value;
-        var operation = operationType.operation;
-
-        if (opTypes[operation]) {
-          throw new Error("Must provide only one ".concat(operation, " type in schema."));
-        }
-
-        if (!nodeMap[_typeName]) {
-          throw new Error("Specified ".concat(operation, " type \"").concat(_typeName, "\" not found in document."));
-        }
-
-        opTypes[operation] = operationType.type;
+      for (var _iterator2 = schema.operationTypes[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+        var operationType = _step2.value;
+        opTypes[operationType.operation] = operationType.type;
       }
     } catch (err) {
-      _didIteratorError = true;
-      _iteratorError = err;
+      _didIteratorError2 = true;
+      _iteratorError2 = err;
     } finally {
       try {
-        if (!_iteratorNormalCompletion && _iterator.return != null) {
-          _iterator.return();
+        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+          _iterator2.return();
         }
       } finally {
-        if (_didIteratorError) {
-          throw _iteratorError;
+        if (_didIteratorError2) {
+          throw _iteratorError2;
         }
       }
     }
@@ -162,14 +160,6 @@ export var ASTDefinitionBuilder =
 /*#__PURE__*/
 function () {
   function ASTDefinitionBuilder(typeDefinitionsMap, options, resolveType) {
-    _defineProperty(this, "_typeDefinitionsMap", void 0);
-
-    _defineProperty(this, "_options", void 0);
-
-    _defineProperty(this, "_resolveType", void 0);
-
-    _defineProperty(this, "_cache", void 0);
-
     this._typeDefinitionsMap = typeDefinitionsMap;
     this._options = options;
     this._resolveType = resolveType; // Initialize to the GraphQL built in scalars and introspection types.
@@ -187,7 +177,7 @@ function () {
     if (!this._cache[typeName]) {
       if (node.kind === Kind.NAMED_TYPE) {
         var defNode = this._typeDefinitionsMap[typeName];
-        this._cache[typeName] = defNode ? this._makeSchemaDef(defNode) : this._resolveType(node);
+        this._cache[typeName] = defNode ? this._makeSchemaDef(defNode) : this._resolveType(node.name.value);
       } else {
         this._cache[typeName] = this._makeSchemaDef(node);
       }
@@ -209,38 +199,60 @@ function () {
     return this.buildType(typeNode);
   };
 
-  _proto.buildDirective = function buildDirective(directiveNode) {
+  _proto.buildDirective = function buildDirective(directive) {
+    var _this = this;
+
+    var locations = directive.locations.map(function (_ref) {
+      var value = _ref.value;
+      return value;
+    });
     return new GraphQLDirective({
-      name: directiveNode.name.value,
-      description: getDescription(directiveNode, this._options),
-      locations: directiveNode.locations.map(function (node) {
-        return node.value;
+      name: directive.name.value,
+      description: getDescription(directive, this._options),
+      locations: locations,
+      args: keyByNameNode(directive.arguments || [], function (arg) {
+        return _this.buildArg(arg);
       }),
-      args: directiveNode.arguments && this._makeInputValues(directiveNode.arguments),
-      astNode: directiveNode
+      astNode: directive
     });
   };
 
   _proto.buildField = function buildField(field) {
+    var _this2 = this;
+
     return {
       // Note: While this could make assertions to get the correctly typed
       // value, that would throw immediately while type system validation
       // with validateSchema() will produce more actionable results.
       type: this._buildWrappedType(field.type),
       description: getDescription(field, this._options),
-      args: field.arguments && this._makeInputValues(field.arguments),
+      args: keyByNameNode(field.arguments || [], function (arg) {
+        return _this2.buildArg(arg);
+      }),
       deprecationReason: getDeprecationReason(field),
       astNode: field
     };
   };
 
+  _proto.buildArg = function buildArg(value) {
+    // Note: While this could make assertions to get the correctly typed
+    // value, that would throw immediately while type system validation
+    var type = this._buildWrappedType(value.type);
+
+    return {
+      type: type,
+      description: getDescription(value, this._options),
+      defaultValue: valueFromAST(value.defaultValue, type),
+      astNode: value
+    };
+  };
+
   _proto.buildInputField = function buildInputField(value) {
     // Note: While this could make assertions to get the correctly typed
     // value, that would throw immediately while type system validation
     var type = this._buildWrappedType(value.type);
 
     return {
-      name: value.name.value,
       type: type,
       description: getDescription(value, this._options),
       defaultValue: valueFromAST(value.defaultValue, type),
@@ -256,129 +268,114 @@ function () {
     };
   };
 
-  _proto._makeSchemaDef = function _makeSchemaDef(def) {
-    switch (def.kind) {
+  _proto._makeSchemaDef = function _makeSchemaDef(astNode) {
+    switch (astNode.kind) {
       case Kind.OBJECT_TYPE_DEFINITION:
-        return this._makeTypeDef(def);
+        return this._makeTypeDef(astNode);
 
       case Kind.INTERFACE_TYPE_DEFINITION:
-        return this._makeInterfaceDef(def);
+        return this._makeInterfaceDef(astNode);
 
       case Kind.ENUM_TYPE_DEFINITION:
-        return this._makeEnumDef(def);
+        return this._makeEnumDef(astNode);
 
       case Kind.UNION_TYPE_DEFINITION:
-        return this._makeUnionDef(def);
+        return this._makeUnionDef(astNode);
 
       case Kind.SCALAR_TYPE_DEFINITION:
-        return this._makeScalarDef(def);
+        return this._makeScalarDef(astNode);
 
       case Kind.INPUT_OBJECT_TYPE_DEFINITION:
-        return this._makeInputObjectDef(def);
+        return this._makeInputObjectDef(astNode);
 
       default:
-        throw new Error("Type kind \"".concat(def.kind, "\" not supported."));
+        throw new Error("Type kind \"".concat(astNode.kind, "\" not supported."));
     }
   };
 
-  _proto._makeTypeDef = function _makeTypeDef(def) {
-    var _this = this;
-
-    var interfaces = def.interfaces;
-    return new GraphQLObjectType({
-      name: def.name.value,
-      description: getDescription(def, this._options),
-      fields: function fields() {
-        return _this._makeFieldDefMap(def);
-      },
-      // Note: While this could make early assertions to get the correctly
-      // typed values, that would throw immediately while type system
-      // validation with validateSchema() will produce more actionable results.
-      interfaces: interfaces ? function () {
-        return interfaces.map(function (ref) {
-          return _this.buildType(ref);
-        });
-      } : [],
-      astNode: def
-    });
-  };
-
-  _proto._makeFieldDefMap = function _makeFieldDefMap(def) {
-    var _this2 = this;
-
-    return def.fields ? keyValMap(def.fields, function (field) {
-      return field.name.value;
-    }, function (field) {
-      return _this2.buildField(field);
-    }) : {};
-  };
-
-  _proto._makeInputValues = function _makeInputValues(values) {
+  _proto._makeTypeDef = function _makeTypeDef(astNode) {
     var _this3 = this;
 
-    return keyValMap(values, function (value) {
-      return value.name.value;
-    }, function (value) {
-      return _this3.buildInputField(value);
+    var interfaceNodes = astNode.interfaces;
+    var fieldNodes = astNode.fields; // Note: While this could make assertions to get the correctly typed
+    // values below, that would throw immediately while type system
+    // validation with validateSchema() will produce more actionable results.
+
+    var interfaces = interfaceNodes && interfaceNodes.length > 0 ? function () {
+      return interfaceNodes.map(function (ref) {
+        return _this3.buildType(ref);
+      });
+    } : [];
+    var fields = fieldNodes && fieldNodes.length > 0 ? function () {
+      return keyByNameNode(fieldNodes, function (field) {
+        return _this3.buildField(field);
+      });
+    } : Object.create(null);
+    return new GraphQLObjectType({
+      name: astNode.name.value,
+      description: getDescription(astNode, this._options),
+      interfaces: interfaces,
+      fields: fields,
+      astNode: astNode
     });
   };
 
-  _proto._makeInterfaceDef = function _makeInterfaceDef(def) {
+  _proto._makeInterfaceDef = function _makeInterfaceDef(astNode) {
     var _this4 = this;
 
+    var fieldNodes = astNode.fields;
+    var fields = fieldNodes && fieldNodes.length > 0 ? function () {
+      return keyByNameNode(fieldNodes, function (field) {
+        return _this4.buildField(field);
+      });
+    } : Object.create(null);
     return new GraphQLInterfaceType({
-      name: def.name.value,
-      description: getDescription(def, this._options),
-      fields: function fields() {
-        return _this4._makeFieldDefMap(def);
-      },
-      astNode: def
-    });
-  };
-
-  _proto._makeEnumDef = function _makeEnumDef(def) {
-    return new GraphQLEnumType({
-      name: def.name.value,
-      description: getDescription(def, this._options),
-      values: this._makeValueDefMap(def),
-      astNode: def
+      name: astNode.name.value,
+      description: getDescription(astNode, this._options),
+      fields: fields,
+      astNode: astNode
     });
   };
 
-  _proto._makeValueDefMap = function _makeValueDefMap(def) {
+  _proto._makeEnumDef = function _makeEnumDef(astNode) {
     var _this5 = this;
 
-    return def.values ? keyValMap(def.values, function (enumValue) {
-      return enumValue.name.value;
-    }, function (enumValue) {
-      return _this5.buildEnumValue(enumValue);
-    }) : {};
+    var valueNodes = astNode.values || [];
+    return new GraphQLEnumType({
+      name: astNode.name.value,
+      description: getDescription(astNode, this._options),
+      values: keyByNameNode(valueNodes, function (value) {
+        return _this5.buildEnumValue(value);
+      }),
+      astNode: astNode
+    });
   };
 
-  _proto._makeUnionDef = function _makeUnionDef(def) {
+  _proto._makeUnionDef = function _makeUnionDef(astNode) {
     var _this6 = this;
 
-    var types = def.types;
+    var typeNodes = astNode.types; // Note: While this could make assertions to get the correctly typed
+    // values below, that would throw immediately while type system
+    // validation with validateSchema() will produce more actionable results.
+
+    var types = typeNodes && typeNodes.length > 0 ? function () {
+      return typeNodes.map(function (ref) {
+        return _this6.buildType(ref);
+      });
+    } : [];
     return new GraphQLUnionType({
-      name: def.name.value,
-      description: getDescription(def, this._options),
-      // Note: While this could make assertions to get the correctly typed
-      // values below, that would throw immediately while type system
-      // validation with validateSchema() will produce more actionable results.
-      types: types ? function () {
-        return types.map(function (ref) {
-          return _this6.buildType(ref);
-        });
-      } : [],
-      astNode: def
+      name: astNode.name.value,
+      description: getDescription(astNode, this._options),
+      types: types,
+      astNode: astNode
     });
   };
 
-  _proto._makeScalarDef = function _makeScalarDef(def) {
+  _proto._makeScalarDef = function _makeScalarDef(astNode) {
     return new GraphQLScalarType({
-      name: def.name.value,
-      description: getDescription(def, this._options),
-      astNode: def,
+      name: astNode.name.value,
+      description: getDescription(astNode, this._options),
+      astNode: astNode,
       serialize: function serialize(value) {
         return value;
       }
@@ -388,23 +385,34 @@ function () {
   _proto._makeInputObjectDef = function _makeInputObjectDef(def) {
     var _this7 = this;
 
+    var fields = def.fields;
     return new GraphQLInputObjectType({
       name: def.name.value,
       description: getDescription(def, this._options),
-      fields: function fields() {
-        return def.fields ? _this7._makeInputValues(def.fields) : {};
-      },
+      fields: fields ? function () {
+        return keyByNameNode(fields, function (field) {
+          return _this7.buildInputField(field);
+        });
+      } : Object.create(null),
       astNode: def
     });
   };
 
   return ASTDefinitionBuilder;
 }();
+
+function keyByNameNode(list, valFn) {
+  return keyValMap(list, function (_ref2) {
+    var name = _ref2.name;
+    return name.value;
+  }, valFn);
+}
 /**
  * Given a field or enum value node, returns the string value for the
  * deprecation reason.
  */
 
+
 function getDeprecationReason(node) {
   var deprecated = getDirectiveValues(GraphQLDeprecatedDirective, node);
   return deprecated && deprecated.reason;

package/utilities/buildClientSchema.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.buildClientSchema = buildClientSchema;
 
+var _inspect = _interopRequireDefault(require("../jsutils/inspect"));
+
 var _invariant = _interopRequireDefault(require("../jsutils/invariant"));
 
 var _keyMap = _interopRequireDefault(require("../jsutils/keyMap"));
@@ -33,7 +35,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict
+ * 
  */
 
 /**
@@ -86,7 +88,7 @@ function buildClientSchema(introspection, options) {
     }
 
     if (!typeRef.name) {
-      throw new Error('Unknown type reference: ' + JSON.stringify(typeRef));
+      throw new Error('Unknown type reference: ' + (0, _inspect.default)(typeRef));
     }
 
     return getNamedType(typeRef.name);
@@ -110,13 +112,13 @@ function buildClientSchema(introspection, options) {
 
   function getInputType(typeRef) {
     var type = getType(typeRef);
-    !(0, _definition.isInputType)(type) ? (0, _invariant.default)(0, 'Introspection must provide input type for arguments.') : void 0;
+    !(0, _definition.isInputType)(type) ? (0, _invariant.default)(0, 'Introspection must provide input type for arguments, but received: ' + (0, _inspect.default)(type) + '.') : void 0;
     return type;
   }
 
   function getOutputType(typeRef) {
     var type = getType(typeRef);
-    !(0, _definition.isOutputType)(type) ? (0, _invariant.default)(0, 'Introspection must provide output type for fields.') : void 0;
+    !(0, _definition.isOutputType)(type) ? (0, _invariant.default)(0, 'Introspection must provide output type for fields, but received: ' + (0, _inspect.default)(type) + '.') : void 0;
     return type;
   }
 
@@ -155,7 +157,7 @@ function buildClientSchema(introspection, options) {
       }
     }
 
-    throw new Error('Invalid or incomplete introspection result. Ensure that a full ' + 'introspection query is used in order to build a client schema:' + JSON.stringify(type));
+    throw new Error('Invalid or incomplete introspection result. Ensure that a full ' + 'introspection query is used in order to build a client schema:' + (0, _inspect.default)(type));
   }
 
   function buildScalarDef(scalarIntrospection) {
@@ -170,13 +172,15 @@ function buildClientSchema(introspection, options) {
 
   function buildObjectDef(objectIntrospection) {
     if (!objectIntrospection.interfaces) {
-      throw new Error('Introspection result missing interfaces: ' + JSON.stringify(objectIntrospection));
+      throw new Error('Introspection result missing interfaces: ' + (0, _inspect.default)(objectIntrospection));
     }
 
     return new _definition.GraphQLObjectType({
       name: objectIntrospection.name,
       description: objectIntrospection.description,
-      interfaces: objectIntrospection.interfaces.map(getInterfaceType),
+      interfaces: function interfaces() {
+        return objectIntrospection.interfaces.map(getInterfaceType);
+      },
       fields: function fields() {
         return buildFieldDefMap(objectIntrospection);
       }
@@ -195,19 +199,21 @@ function buildClientSchema(introspection, options) {
 
   function buildUnionDef(unionIntrospection) {
     if (!unionIntrospection.possibleTypes) {
-      throw new Error('Introspection result missing possibleTypes: ' + JSON.stringify(unionIntrospection));
+      throw new Error('Introspection result missing possibleTypes: ' + (0, _inspect.default)(unionIntrospection));
     }
 
     return new _definition.GraphQLUnionType({
       name: unionIntrospection.name,
       description: unionIntrospection.description,
-      types: unionIntrospection.possibleTypes.map(getObjectType)
+      types: function types() {
+        return unionIntrospection.possibleTypes.map(getObjectType);
+      }
     });
   }
 
   function buildEnumDef(enumIntrospection) {
     if (!enumIntrospection.enumValues) {
-      throw new Error('Introspection result missing enumValues: ' + JSON.stringify(enumIntrospection));
+      throw new Error('Introspection result missing enumValues: ' + (0, _inspect.default)(enumIntrospection));
     }
 
     return new _definition.GraphQLEnumType({
@@ -226,7 +232,7 @@ function buildClientSchema(introspection, options) {
 
   function buildInputObjectDef(inputObjectIntrospection) {
     if (!inputObjectIntrospection.inputFields) {
-      throw new Error('Introspection result missing inputFields: ' + JSON.stringify(inputObjectIntrospection));
+      throw new Error('Introspection result missing inputFields: ' + (0, _inspect.default)(inputObjectIntrospection));
     }
 
     return new _definition.GraphQLInputObjectType({
@@ -240,14 +246,14 @@ function buildClientSchema(introspection, options) {
 
   function buildFieldDefMap(typeIntrospection) {
     if (!typeIntrospection.fields) {
-      throw new Error('Introspection result missing fields: ' + JSON.stringify(typeIntrospection));
+      throw new Error('Introspection result missing fields: ' + (0, _inspect.default)(typeIntrospection));
     }
 
     return (0, _keyValMap.default)(typeIntrospection.fields, function (fieldIntrospection) {
       return fieldIntrospection.name;
     }, function (fieldIntrospection) {
       if (!fieldIntrospection.args) {
-        throw new Error('Introspection result missing field args: ' + JSON.stringify(fieldIntrospection));
+        throw new Error('Introspection result missing field args: ' + (0, _inspect.default)(fieldIntrospection));
       }
 
       return {
@@ -277,7 +283,11 @@ function buildClientSchema(introspection, options) {
 
   function buildDirective(directiveIntrospection) {
     if (!directiveIntrospection.args) {
-      throw new Error('Introspection result missing directive args: ' + JSON.stringify(directiveIntrospection));
+      throw new Error('Introspection result missing directive args: ' + (0, _inspect.default)(directiveIntrospection));
+    }
+
+    if (!directiveIntrospection.locations) {
+      throw new Error('Introspection result missing directive locations: ' + (0, _inspect.default)(directiveIntrospection));
     }
 
     return new _directives.GraphQLDirective({