graphql 14.0.2 → 14.2.1

package/utilities/extendSchema.js

@@ -5,20 +5,22 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.extendSchema = extendSchema;
 
+var _flatMap = _interopRequireDefault(require("../polyfills/flatMap"));
+
+var _objectValues = _interopRequireDefault(require("../polyfills/objectValues"));
+
+var _inspect = _interopRequireDefault(require("../jsutils/inspect"));
+
 var _invariant = _interopRequireDefault(require("../jsutils/invariant"));
 
-var _keyMap = _interopRequireDefault(require("../jsutils/keyMap"));
+var _mapValue = _interopRequireDefault(require("../jsutils/mapValue"));
 
 var _keyValMap = _interopRequireDefault(require("../jsutils/keyValMap"));
 
-var _objectValues = _interopRequireDefault(require("../jsutils/objectValues"));
-
 var _buildASTSchema = require("./buildASTSchema");
 
 var _validate = require("../validation/validate");
 
-var _GraphQLError = require("../error/GraphQLError");
-
 var _schema = require("../type/schema");
 
 var _introspection = require("../type/introspection");
@@ -58,7 +60,7 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
  *
  */
 function extendSchema(schema, documentAST, options) {
-  !(0, _schema.isSchema)(schema) ? (0, _invariant.default)(0, 'Must provide valid GraphQLSchema') : void 0;
+  (0, _schema.assertSchema)(schema);
   !(documentAST && documentAST.kind === _kinds.Kind.DOCUMENT) ? (0, _invariant.default)(0, 'Must provide valid Document AST') : void 0;
 
   if (!options || !(options.assumeValid || options.assumeValidSDL)) {
@@ -66,729 +68,353 @@ function extendSchema(schema, documentAST, options) {
   } // Collect the type definitions and extensions found in the document.
 
 
-  var typeDefinitionMap = Object.create(null);
-  var typeExtensionsMap = Object.create(null); // New directives and types are separate because a directives and types can
+  var typeDefs = [];
+  var typeExtsMap = Object.create(null); // New directives and types are separate because a directives and types can
   // have the same name. For example, a type named "skip".
 
-  var directiveDefinitions = [];
+  var directiveDefs = [];
   var schemaDef; // Schema extensions are collected which may add additional operation types.
 
-  var schemaExtensions = [];
-
-  for (var i = 0; i < documentAST.definitions.length; i++) {
-    var def = documentAST.definitions[i];
-
-    if (def.kind === _kinds.Kind.SCHEMA_DEFINITION) {
-      schemaDef = def;
-    } else if (def.kind === _kinds.Kind.SCHEMA_EXTENSION) {
-      schemaExtensions.push(def);
-    } else if ((0, _predicates.isTypeDefinitionNode)(def)) {
-      // Sanity check that none of the defined types conflict with the
-      // schema's existing types.
-      var typeName = def.name.value;
-
-      if (schema.getType(typeName)) {
-        throw new _GraphQLError.GraphQLError("Type \"".concat(typeName, "\" already exists in the schema. It cannot also ") + 'be defined in this type definition.', [def]);
+  var schemaExts = [];
+  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 === _kinds.Kind.SCHEMA_DEFINITION) {
+        schemaDef = def;
+      } else if (def.kind === _kinds.Kind.SCHEMA_EXTENSION) {
+        schemaExts.push(def);
+      } else if ((0, _predicates.isTypeDefinitionNode)(def)) {
+        typeDefs.push(def);
+      } else if ((0, _predicates.isTypeExtensionNode)(def)) {
+        var extendedTypeName = def.name.value;
+        var existingTypeExts = typeExtsMap[extendedTypeName];
+        typeExtsMap[extendedTypeName] = existingTypeExts ? existingTypeExts.concat([def]) : [def];
+      } else if (def.kind === _kinds.Kind.DIRECTIVE_DEFINITION) {
+        directiveDefs.push(def);
       }
+    } // If this document contains no new types, extensions, or directives then
+    // return the same unmodified GraphQLSchema instance.
 
-      typeDefinitionMap[typeName] = def;
-    } else if ((0, _predicates.isTypeExtensionNode)(def)) {
-      // Sanity check that this type extension exists within the
-      // schema's existing types.
-      var extendedTypeName = def.name.value;
-      var existingType = schema.getType(extendedTypeName);
-
-      if (!existingType) {
-        throw new _GraphQLError.GraphQLError("Cannot extend type \"".concat(extendedTypeName, "\" because it does not ") + 'exist in the existing schema.', [def]);
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
       }
-
-      checkExtensionNode(existingType, def);
-      var existingTypeExtensions = typeExtensionsMap[extendedTypeName];
-      typeExtensionsMap[extendedTypeName] = existingTypeExtensions ? existingTypeExtensions.concat([def]) : [def];
-    } else if (def.kind === _kinds.Kind.DIRECTIVE_DEFINITION) {
-      var directiveName = def.name.value;
-      var existingDirective = schema.getDirective(directiveName);
-
-      if (existingDirective) {
-        throw new _GraphQLError.GraphQLError("Directive \"".concat(directiveName, "\" already exists in the schema. It ") + 'cannot be redefined.', [def]);
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
       }
-
-      directiveDefinitions.push(def);
     }
-  } // If this document contains no new types, extensions, or directives then
-  // return the same unmodified GraphQLSchema instance.
-
+  }
 
-  if (Object.keys(typeExtensionsMap).length === 0 && Object.keys(typeDefinitionMap).length === 0 && directiveDefinitions.length === 0 && schemaExtensions.length === 0 && !schemaDef) {
+  if (Object.keys(typeExtsMap).length === 0 && typeDefs.length === 0 && directiveDefs.length === 0 && schemaExts.length === 0 && !schemaDef) {
     return schema;
   }
 
-  var astBuilder = new _buildASTSchema.ASTDefinitionBuilder(typeDefinitionMap, options, function (typeRef) {
-    var typeName = typeRef.name.value;
-    var existingType = schema.getType(typeName);
-
-    if (existingType) {
-      return extendNamedType(existingType);
-    }
-
-    throw new _GraphQLError.GraphQLError("Unknown type: \"".concat(typeName, "\". Ensure that this type exists ") + 'either in the original schema, or is added in a type definition.', [typeRef]);
+  var schemaConfig = schema.toConfig();
+  var astBuilder = new _buildASTSchema.ASTDefinitionBuilder(options, function (typeName) {
+    var type = typeMap[typeName];
+    !type ? (0, _invariant.default)(0, "Unknown type: \"".concat(typeName, "\".")) : void 0;
+    return type;
+  });
+  var typeMap = (0, _keyValMap.default)(typeDefs, function (node) {
+    return node.name.value;
+  }, function (node) {
+    return astBuilder.buildType(node);
   });
-  var extendTypeCache = Object.create(null); // Get the extended root operation types.
+  var _iteratorNormalCompletion2 = true;
+  var _didIteratorError2 = false;
+  var _iteratorError2 = undefined;
+
+  try {
+    for (var _iterator2 = schemaConfig.types[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+      var existingType = _step2.value;
+      typeMap[existingType.name] = extendNamedType(existingType);
+    } // Get the extended root operation types.
+
+  } catch (err) {
+    _didIteratorError2 = true;
+    _iteratorError2 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+        _iterator2.return();
+      }
+    } finally {
+      if (_didIteratorError2) {
+        throw _iteratorError2;
+      }
+    }
+  }
 
   var operationTypes = {
-    query: extendMaybeNamedType(schema.getQueryType()),
-    mutation: extendMaybeNamedType(schema.getMutationType()),
-    subscription: extendMaybeNamedType(schema.getSubscriptionType())
+    query: schemaConfig.query && schemaConfig.query.name,
+    mutation: schemaConfig.mutation && schemaConfig.mutation.name,
+    subscription: schemaConfig.subscription && schemaConfig.subscription.name
   };
 
   if (schemaDef) {
-    var _iteratorNormalCompletion = true;
-    var _didIteratorError = false;
-    var _iteratorError = undefined;
+    var _iteratorNormalCompletion3 = true;
+    var _didIteratorError3 = false;
+    var _iteratorError3 = undefined;
 
     try {
-      for (var _iterator = schemaDef.operationTypes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-        var _ref2 = _step.value;
-        var operation = _ref2.operation,
-            type = _ref2.type;
-
-        if (operationTypes[operation]) {
-          throw new Error("Must provide only one ".concat(operation, " type in schema."));
-        } // 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.
-
-
-        operationTypes[operation] = astBuilder.buildType(type);
+      for (var _iterator3 = schemaDef.operationTypes[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+        var _ref2 = _step3.value;
+        var operation = _ref2.operation;
+        var type = _ref2.type;
+        operationTypes[operation] = type.name.value;
       }
     } catch (err) {
-      _didIteratorError = true;
-      _iteratorError = err;
+      _didIteratorError3 = true;
+      _iteratorError3 = err;
     } finally {
       try {
-        if (!_iteratorNormalCompletion && _iterator.return != null) {
-          _iterator.return();
+        if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+          _iterator3.return();
         }
       } finally {
-        if (_didIteratorError) {
-          throw _iteratorError;
+        if (_didIteratorError3) {
+          throw _iteratorError3;
         }
       }
     }
   } // Then, incorporate schema definition and all schema extensions.
 
 
-  for (var _i = 0; _i < schemaExtensions.length; _i++) {
-    var schemaExtension = schemaExtensions[_i];
+  var _arr = schemaExts;
 
-    if (schemaExtension.operationTypes) {
-      var _iteratorNormalCompletion12 = true;
-      var _didIteratorError12 = false;
-      var _iteratorError12 = undefined;
-
-      try {
-        for (var _iterator12 = schemaExtension.operationTypes[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
-          var _ref4 = _step12.value;
-          var operation = _ref4.operation,
-              type = _ref4.type;
-
-          if (operationTypes[operation]) {
-            throw new Error("Must provide only one ".concat(operation, " type in schema."));
-          } // 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.
+  for (var _i = 0; _i < _arr.length; _i++) {
+    var schemaExt = _arr[_i];
 
+    if (schemaExt.operationTypes) {
+      var _iteratorNormalCompletion4 = true;
+      var _didIteratorError4 = false;
+      var _iteratorError4 = undefined;
 
-          operationTypes[operation] = astBuilder.buildType(type);
+      try {
+        for (var _iterator4 = schemaExt.operationTypes[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+          var _ref4 = _step4.value;
+          var _operation = _ref4.operation;
+          var _type = _ref4.type;
+          operationTypes[_operation] = _type.name.value;
         }
       } catch (err) {
-        _didIteratorError12 = true;
-        _iteratorError12 = err;
+        _didIteratorError4 = true;
+        _iteratorError4 = err;
       } finally {
         try {
-          if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
-            _iterator12.return();
+          if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+            _iterator4.return();
           }
         } finally {
-          if (_didIteratorError12) {
-            throw _iteratorError12;
+          if (_didIteratorError4) {
+            throw _iteratorError4;
           }
         }
       }
     }
-  }
-
-  var schemaExtensionASTNodes = schemaExtensions ? schema.extensionASTNodes ? schema.extensionASTNodes.concat(schemaExtensions) : schemaExtensions : schema.extensionASTNodes;
-  var types = (0, _objectValues.default)(schema.getTypeMap()).map(function (type) {
-    return extendNamedType(type);
-  }).concat((0, _objectValues.default)(typeDefinitionMap).map(function (type) {
-    return astBuilder.buildType(type);
-  })); // Support both original legacy names and extended legacy names.
+  } // Support both original legacy names and extended legacy names.
 
-  var allowedLegacyNames = schema.__allowedLegacyNames.concat(options && options.allowedLegacyNames || []); // Then produce and return a Schema with these types.
 
+  var allowedLegacyNames = schemaConfig.allowedLegacyNames.concat(options && options.allowedLegacyNames || []); // Then produce and return a Schema with these types.
 
-  return new _schema.GraphQLSchema(_objectSpread({}, operationTypes, {
-    types: types,
+  return new _schema.GraphQLSchema({
+    // 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.
+    query: getMaybeTypeByName(operationTypes.query),
+    mutation: getMaybeTypeByName(operationTypes.mutation),
+    subscription: getMaybeTypeByName(operationTypes.subscription),
+    types: (0, _objectValues.default)(typeMap),
     directives: getMergedDirectives(),
-    astNode: schema.astNode,
-    extensionASTNodes: schemaExtensionASTNodes,
+    astNode: schemaDef || schemaConfig.astNode,
+    extensionASTNodes: schemaConfig.extensionASTNodes.concat(schemaExts),
     allowedLegacyNames: allowedLegacyNames
-  })); // Below are functions used for producing this schema that have closed over
+  }); // Below are functions used for producing this schema that have closed over
   // this scope and have access to the schema, cache, and newly defined types.
 
+  function replaceType(type) {
+    if ((0, _definition.isListType)(type)) {
+      return new _definition.GraphQLList(replaceType(type.ofType));
+    } else if ((0, _definition.isNonNullType)(type)) {
+      return new _definition.GraphQLNonNull(replaceType(type.ofType));
+    }
+
+    return replaceNamedType(type);
+  }
+
+  function replaceNamedType(type) {
+    return typeMap[type.name];
+  }
+
+  function getMaybeTypeByName(typeName) {
+    return typeName ? typeMap[typeName] : null;
+  }
+
   function getMergedDirectives() {
     var existingDirectives = schema.getDirectives().map(extendDirective);
     !existingDirectives ? (0, _invariant.default)(0, 'schema must have default directives') : void 0;
-    return existingDirectives.concat(directiveDefinitions.map(function (node) {
+    return existingDirectives.concat(directiveDefs.map(function (node) {
       return astBuilder.buildDirective(node);
     }));
   }
 
-  function extendMaybeNamedType(type) {
-    return type ? extendNamedType(type) : null;
-  }
-
   function extendNamedType(type) {
     if ((0, _introspection.isIntrospectionType)(type) || (0, _scalars.isSpecifiedScalarType)(type)) {
       // Builtin types are not extended.
       return type;
-    }
-
-    var name = type.name;
-
-    if (!extendTypeCache[name]) {
-      if ((0, _definition.isScalarType)(type)) {
-        extendTypeCache[name] = extendScalarType(type);
-      } else if ((0, _definition.isObjectType)(type)) {
-        extendTypeCache[name] = extendObjectType(type);
-      } else if ((0, _definition.isInterfaceType)(type)) {
-        extendTypeCache[name] = extendInterfaceType(type);
-      } else if ((0, _definition.isUnionType)(type)) {
-        extendTypeCache[name] = extendUnionType(type);
-      } else if ((0, _definition.isEnumType)(type)) {
-        extendTypeCache[name] = extendEnumType(type);
-      } else if ((0, _definition.isInputObjectType)(type)) {
-        extendTypeCache[name] = extendInputObjectType(type);
-      }
-    }
-
-    return extendTypeCache[name];
+    } else if ((0, _definition.isScalarType)(type)) {
+      return extendScalarType(type);
+    } else if ((0, _definition.isObjectType)(type)) {
+      return extendObjectType(type);
+    } else if ((0, _definition.isInterfaceType)(type)) {
+      return extendInterfaceType(type);
+    } else if ((0, _definition.isUnionType)(type)) {
+      return extendUnionType(type);
+    } else if ((0, _definition.isEnumType)(type)) {
+      return extendEnumType(type);
+    } else if ((0, _definition.isInputObjectType)(type)) {
+      return extendInputObjectType(type);
+    } // Not reachable. All possible types have been considered.
+
+    /* istanbul ignore next */
+
+
+    throw new Error("Unexpected type: \"".concat((0, _inspect.default)(type), "\"."));
   }
 
   function extendDirective(directive) {
-    return new _directives.GraphQLDirective({
-      name: directive.name,
-      description: directive.description,
-      locations: directive.locations,
-      args: extendArgs(directive.args),
-      astNode: directive.astNode
-    });
+    var config = directive.toConfig();
+    return new _directives.GraphQLDirective(_objectSpread({}, config, {
+      args: (0, _mapValue.default)(config.args, extendArg)
+    }));
   }
 
   function extendInputObjectType(type) {
-    var name = type.name;
-    var extensionASTNodes = typeExtensionsMap[name] ? type.extensionASTNodes ? type.extensionASTNodes.concat(typeExtensionsMap[name]) : typeExtensionsMap[name] : type.extensionASTNodes;
-    return new _definition.GraphQLInputObjectType({
-      name: name,
-      description: type.description,
+    var config = type.toConfig();
+    var extensions = typeExtsMap[config.name] || [];
+    var fieldNodes = (0, _flatMap.default)(extensions, function (node) {
+      return node.fields || [];
+    });
+    return new _definition.GraphQLInputObjectType(_objectSpread({}, config, {
       fields: function fields() {
-        return extendInputFieldMap(type);
+        return _objectSpread({}, (0, _mapValue.default)(config.fields, function (field) {
+          return _objectSpread({}, field, {
+            type: replaceType(field.type)
+          });
+        }), (0, _keyValMap.default)(fieldNodes, function (field) {
+          return field.name.value;
+        }, function (field) {
+          return astBuilder.buildInputField(field);
+        }));
       },
-      astNode: type.astNode,
-      extensionASTNodes: extensionASTNodes
-    });
-  }
-
-  function extendInputFieldMap(type) {
-    var newFieldMap = Object.create(null);
-    var oldFieldMap = type.getFields();
-
-    var _arr = Object.keys(oldFieldMap);
-
-    for (var _i2 = 0; _i2 < _arr.length; _i2++) {
-      var _fieldName = _arr[_i2];
-      var _field = oldFieldMap[_fieldName];
-      newFieldMap[_fieldName] = {
-        description: _field.description,
-        type: extendType(_field.type),
-        defaultValue: _field.defaultValue,
-        astNode: _field.astNode
-      };
-    } // If there are any extensions to the fields, apply those here.
-
-
-    var extensions = typeExtensionsMap[type.name];
-
-    if (extensions) {
-      var _iteratorNormalCompletion2 = true;
-      var _didIteratorError2 = false;
-      var _iteratorError2 = undefined;
-
-      try {
-        for (var _iterator2 = extensions[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-          var extension = _step2.value;
-          var _iteratorNormalCompletion3 = true;
-          var _didIteratorError3 = false;
-          var _iteratorError3 = undefined;
-
-          try {
-            for (var _iterator3 = extension.fields[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
-              var field = _step3.value;
-              var fieldName = field.name.value;
-
-              if (oldFieldMap[fieldName]) {
-                throw new _GraphQLError.GraphQLError("Field \"".concat(type.name, ".").concat(fieldName, "\" already exists in the ") + 'schema. It cannot also be defined in this type extension.', [field]);
-              }
-
-              newFieldMap[fieldName] = astBuilder.buildInputField(field);
-            }
-          } catch (err) {
-            _didIteratorError3 = true;
-            _iteratorError3 = err;
-          } finally {
-            try {
-              if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
-                _iterator3.return();
-              }
-            } finally {
-              if (_didIteratorError3) {
-                throw _iteratorError3;
-              }
-            }
-          }
-        }
-      } catch (err) {
-        _didIteratorError2 = true;
-        _iteratorError2 = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-            _iterator2.return();
-          }
-        } finally {
-          if (_didIteratorError2) {
-            throw _iteratorError2;
-          }
-        }
-      }
-    }
-
-    return newFieldMap;
+      extensionASTNodes: config.extensionASTNodes.concat(extensions)
+    }));
   }
 
   function extendEnumType(type) {
-    var name = type.name;
-    var extensionASTNodes = typeExtensionsMap[name] ? type.extensionASTNodes ? type.extensionASTNodes.concat(typeExtensionsMap[name]) : typeExtensionsMap[name] : type.extensionASTNodes;
-    return new _definition.GraphQLEnumType({
-      name: name,
-      description: type.description,
-      values: extendValueMap(type),
-      astNode: type.astNode,
-      extensionASTNodes: extensionASTNodes
+    var config = type.toConfig();
+    var extensions = typeExtsMap[type.name] || [];
+    var valueNodes = (0, _flatMap.default)(extensions, function (node) {
+      return node.values || [];
     });
-  }
-
-  function extendValueMap(type) {
-    var newValueMap = Object.create(null);
-    var oldValueMap = (0, _keyMap.default)(type.getValues(), function (value) {
-      return value.name;
-    });
-
-    var _arr2 = Object.keys(oldValueMap);
-
-    for (var _i3 = 0; _i3 < _arr2.length; _i3++) {
-      var _valueName = _arr2[_i3];
-      var _value = oldValueMap[_valueName];
-      newValueMap[_valueName] = {
-        name: _value.name,
-        description: _value.description,
-        value: _value.value,
-        deprecationReason: _value.deprecationReason,
-        astNode: _value.astNode
-      };
-    } // If there are any extensions to the values, apply those here.
-
-
-    var extensions = typeExtensionsMap[type.name];
-
-    if (extensions) {
-      var _iteratorNormalCompletion4 = true;
-      var _didIteratorError4 = false;
-      var _iteratorError4 = undefined;
-
-      try {
-        for (var _iterator4 = extensions[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
-          var extension = _step4.value;
-          var _iteratorNormalCompletion5 = true;
-          var _didIteratorError5 = false;
-          var _iteratorError5 = undefined;
-
-          try {
-            for (var _iterator5 = extension.values[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
-              var value = _step5.value;
-              var valueName = value.name.value;
-
-              if (oldValueMap[valueName]) {
-                throw new _GraphQLError.GraphQLError("Enum value \"".concat(type.name, ".").concat(valueName, "\" already exists in the ") + 'schema. It cannot also be defined in this type extension.', [value]);
-              }
-
-              newValueMap[valueName] = astBuilder.buildEnumValue(value);
-            }
-          } catch (err) {
-            _didIteratorError5 = true;
-            _iteratorError5 = err;
-          } finally {
-            try {
-              if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
-                _iterator5.return();
-              }
-            } finally {
-              if (_didIteratorError5) {
-                throw _iteratorError5;
-              }
-            }
-          }
-        }
-      } catch (err) {
-        _didIteratorError4 = true;
-        _iteratorError4 = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
-            _iterator4.return();
-          }
-        } finally {
-          if (_didIteratorError4) {
-            throw _iteratorError4;
-          }
-        }
-      }
-    }
-
-    return newValueMap;
+    return new _definition.GraphQLEnumType(_objectSpread({}, config, {
+      values: _objectSpread({}, config.values, (0, _keyValMap.default)(valueNodes, function (value) {
+        return value.name.value;
+      }, function (value) {
+        return astBuilder.buildEnumValue(value);
+      })),
+      extensionASTNodes: config.extensionASTNodes.concat(extensions)
+    }));
   }
 
   function extendScalarType(type) {
-    var name = type.name;
-    var extensionASTNodes = typeExtensionsMap[name] ? type.extensionASTNodes ? type.extensionASTNodes.concat(typeExtensionsMap[name]) : typeExtensionsMap[name] : type.extensionASTNodes;
-    return new _definition.GraphQLScalarType({
-      name: name,
-      description: type.description,
-      astNode: type.astNode,
-      extensionASTNodes: extensionASTNodes,
-      serialize: type.serialize,
-      parseValue: type.parseValue,
-      parseLiteral: type.parseLiteral
-    });
+    var config = type.toConfig();
+    var extensions = typeExtsMap[config.name] || [];
+    return new _definition.GraphQLScalarType(_objectSpread({}, config, {
+      extensionASTNodes: config.extensionASTNodes.concat(extensions)
+    }));
   }
 
   function extendObjectType(type) {
-    var name = type.name;
-    var extensionASTNodes = typeExtensionsMap[name] ? type.extensionASTNodes ? type.extensionASTNodes.concat(typeExtensionsMap[name]) : typeExtensionsMap[name] : type.extensionASTNodes;
-    return new _definition.GraphQLObjectType({
-      name: name,
-      description: type.description,
+    var config = type.toConfig();
+    var extensions = typeExtsMap[config.name] || [];
+    var interfaceNodes = (0, _flatMap.default)(extensions, function (node) {
+      return node.interfaces || [];
+    });
+    var fieldNodes = (0, _flatMap.default)(extensions, function (node) {
+      return node.fields || [];
+    });
+    return new _definition.GraphQLObjectType(_objectSpread({}, config, {
       interfaces: function interfaces() {
-        return extendImplementedInterfaces(type);
+        return [].concat(type.getInterfaces().map(replaceNamedType), interfaceNodes.map(function (node) {
+          return astBuilder.getNamedType(node);
+        }));
       },
       fields: function fields() {
-        return extendFieldMap(type);
+        return _objectSpread({}, (0, _mapValue.default)(config.fields, extendField), (0, _keyValMap.default)(fieldNodes, function (node) {
+          return node.name.value;
+        }, function (node) {
+          return astBuilder.buildField(node);
+        }));
       },
-      astNode: type.astNode,
-      extensionASTNodes: extensionASTNodes,
-      isTypeOf: type.isTypeOf
-    });
-  }
-
-  function extendArgs(args) {
-    return (0, _keyValMap.default)(args, function (arg) {
-      return arg.name;
-    }, function (arg) {
-      return {
-        type: extendType(arg.type),
-        defaultValue: arg.defaultValue,
-        description: arg.description,
-        astNode: arg.astNode
-      };
-    });
+      extensionASTNodes: config.extensionASTNodes.concat(extensions)
+    }));
   }
 
   function extendInterfaceType(type) {
-    var name = type.name;
-    var extensionASTNodes = typeExtensionsMap[name] ? type.extensionASTNodes ? type.extensionASTNodes.concat(typeExtensionsMap[name]) : typeExtensionsMap[name] : type.extensionASTNodes;
-    return new _definition.GraphQLInterfaceType({
-      name: type.name,
-      description: type.description,
+    var config = type.toConfig();
+    var extensions = typeExtsMap[config.name] || [];
+    var fieldNodes = (0, _flatMap.default)(extensions, function (node) {
+      return node.fields || [];
+    });
+    return new _definition.GraphQLInterfaceType(_objectSpread({}, config, {
       fields: function fields() {
-        return extendFieldMap(type);
+        return _objectSpread({}, (0, _mapValue.default)(config.fields, extendField), (0, _keyValMap.default)(fieldNodes, function (node) {
+          return node.name.value;
+        }, function (node) {
+          return astBuilder.buildField(node);
+        }));
       },
-      astNode: type.astNode,
-      extensionASTNodes: extensionASTNodes,
-      resolveType: type.resolveType
-    });
+      extensionASTNodes: config.extensionASTNodes.concat(extensions)
+    }));
   }
 
   function extendUnionType(type) {
-    var name = type.name;
-    var extensionASTNodes = typeExtensionsMap[name] ? type.extensionASTNodes ? type.extensionASTNodes.concat(typeExtensionsMap[name]) : typeExtensionsMap[name] : type.extensionASTNodes;
-    return new _definition.GraphQLUnionType({
-      name: name,
-      description: type.description,
+    var config = type.toConfig();
+    var extensions = typeExtsMap[config.name] || [];
+    var typeNodes = (0, _flatMap.default)(extensions, function (node) {
+      return node.types || [];
+    });
+    return new _definition.GraphQLUnionType(_objectSpread({}, config, {
       types: function types() {
-        return extendPossibleTypes(type);
+        return [].concat(type.getTypes().map(replaceNamedType), typeNodes.map(function (node) {
+          return astBuilder.getNamedType(node);
+        }));
       },
-      astNode: type.astNode,
-      resolveType: type.resolveType,
-      extensionASTNodes: extensionASTNodes
-    });
-  }
-
-  function extendPossibleTypes(type) {
-    var possibleTypes = type.getTypes().map(extendNamedType); // If there are any extensions to the union, apply those here.
-
-    var extensions = typeExtensionsMap[type.name];
-
-    if (extensions) {
-      var _iteratorNormalCompletion6 = true;
-      var _didIteratorError6 = false;
-      var _iteratorError6 = undefined;
-
-      try {
-        for (var _iterator6 = extensions[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
-          var extension = _step6.value;
-          var _iteratorNormalCompletion7 = true;
-          var _didIteratorError7 = false;
-          var _iteratorError7 = undefined;
-
-          try {
-            for (var _iterator7 = extension.types[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
-              var namedType = _step7.value;
-              // 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.
-              possibleTypes.push(astBuilder.buildType(namedType));
-            }
-          } catch (err) {
-            _didIteratorError7 = true;
-            _iteratorError7 = err;
-          } finally {
-            try {
-              if (!_iteratorNormalCompletion7 && _iterator7.return != null) {
-                _iterator7.return();
-              }
-            } finally {
-              if (_didIteratorError7) {
-                throw _iteratorError7;
-              }
-            }
-          }
-        }
-      } catch (err) {
-        _didIteratorError6 = true;
-        _iteratorError6 = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
-            _iterator6.return();
-          }
-        } finally {
-          if (_didIteratorError6) {
-            throw _iteratorError6;
-          }
-        }
-      }
-    }
-
-    return possibleTypes;
-  }
-
-  function extendImplementedInterfaces(type) {
-    var interfaces = type.getInterfaces().map(extendNamedType); // If there are any extensions to the interfaces, apply those here.
-
-    var extensions = typeExtensionsMap[type.name];
-
-    if (extensions) {
-      var _iteratorNormalCompletion8 = true;
-      var _didIteratorError8 = false;
-      var _iteratorError8 = undefined;
-
-      try {
-        for (var _iterator8 = extensions[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
-          var extension = _step8.value;
-          var _iteratorNormalCompletion9 = true;
-          var _didIteratorError9 = false;
-          var _iteratorError9 = undefined;
-
-          try {
-            for (var _iterator9 = extension.interfaces[Symbol.iterator](), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true) {
-              var namedType = _step9.value;
-              // 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.push(astBuilder.buildType(namedType));
-            }
-          } catch (err) {
-            _didIteratorError9 = true;
-            _iteratorError9 = err;
-          } finally {
-            try {
-              if (!_iteratorNormalCompletion9 && _iterator9.return != null) {
-                _iterator9.return();
-              }
-            } finally {
-              if (_didIteratorError9) {
-                throw _iteratorError9;
-              }
-            }
-          }
-        }
-      } catch (err) {
-        _didIteratorError8 = true;
-        _iteratorError8 = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion8 && _iterator8.return != null) {
-            _iterator8.return();
-          }
-        } finally {
-          if (_didIteratorError8) {
-            throw _iteratorError8;
-          }
-        }
-      }
-    }
-
-    return interfaces;
-  }
-
-  function extendFieldMap(type) {
-    var newFieldMap = Object.create(null);
-    var oldFieldMap = type.getFields();
-
-    var _arr3 = Object.keys(oldFieldMap);
-
-    for (var _i4 = 0; _i4 < _arr3.length; _i4++) {
-      var _fieldName2 = _arr3[_i4];
-      var _field2 = oldFieldMap[_fieldName2];
-      newFieldMap[_fieldName2] = {
-        description: _field2.description,
-        deprecationReason: _field2.deprecationReason,
-        type: extendType(_field2.type),
-        args: extendArgs(_field2.args),
-        astNode: _field2.astNode,
-        resolve: _field2.resolve
-      };
-    } // If there are any extensions to the fields, apply those here.
-
-
-    var extensions = typeExtensionsMap[type.name];
-
-    if (extensions) {
-      var _iteratorNormalCompletion10 = true;
-      var _didIteratorError10 = false;
-      var _iteratorError10 = undefined;
-
-      try {
-        for (var _iterator10 = extensions[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) {
-          var extension = _step10.value;
-          var _iteratorNormalCompletion11 = true;
-          var _didIteratorError11 = false;
-          var _iteratorError11 = undefined;
-
-          try {
-            for (var _iterator11 = extension.fields[Symbol.iterator](), _step11; !(_iteratorNormalCompletion11 = (_step11 = _iterator11.next()).done); _iteratorNormalCompletion11 = true) {
-              var field = _step11.value;
-              var fieldName = field.name.value;
-
-              if (oldFieldMap[fieldName]) {
-                throw new _GraphQLError.GraphQLError("Field \"".concat(type.name, ".").concat(fieldName, "\" already exists in the ") + 'schema. It cannot also be defined in this type extension.', [field]);
-              }
-
-              newFieldMap[fieldName] = astBuilder.buildField(field);
-            }
-          } catch (err) {
-            _didIteratorError11 = true;
-            _iteratorError11 = err;
-          } finally {
-            try {
-              if (!_iteratorNormalCompletion11 && _iterator11.return != null) {
-                _iterator11.return();
-              }
-            } finally {
-              if (_didIteratorError11) {
-                throw _iteratorError11;
-              }
-            }
-          }
-        }
-      } catch (err) {
-        _didIteratorError10 = true;
-        _iteratorError10 = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion10 && _iterator10.return != null) {
-            _iterator10.return();
-          }
-        } finally {
-          if (_didIteratorError10) {
-            throw _iteratorError10;
-          }
-        }
-      }
-    }
-
-    return newFieldMap;
+      extensionASTNodes: config.extensionASTNodes.concat(extensions)
+    }));
   }
 
-  function extendType(typeDef) {
-    if ((0, _definition.isListType)(typeDef)) {
-      return (0, _definition.GraphQLList)(extendType(typeDef.ofType));
-    }
-
-    if ((0, _definition.isNonNullType)(typeDef)) {
-      return (0, _definition.GraphQLNonNull)(extendType(typeDef.ofType));
-    }
-
-    return extendNamedType(typeDef);
+  function extendField(field) {
+    return _objectSpread({}, field, {
+      type: replaceType(field.type),
+      args: (0, _mapValue.default)(field.args, extendArg)
+    });
   }
-}
-
-function checkExtensionNode(type, node) {
-  switch (node.kind) {
-    case _kinds.Kind.OBJECT_TYPE_EXTENSION:
-      if (!(0, _definition.isObjectType)(type)) {
-        throw new _GraphQLError.GraphQLError("Cannot extend non-object type \"".concat(type.name, "\"."), [node]);
-      }
 
-      break;
-
-    case _kinds.Kind.INTERFACE_TYPE_EXTENSION:
-      if (!(0, _definition.isInterfaceType)(type)) {
-        throw new _GraphQLError.GraphQLError("Cannot extend non-interface type \"".concat(type.name, "\"."), [node]);
-      }
-
-      break;
-
-    case _kinds.Kind.ENUM_TYPE_EXTENSION:
-      if (!(0, _definition.isEnumType)(type)) {
-        throw new _GraphQLError.GraphQLError("Cannot extend non-enum type \"".concat(type.name, "\"."), [node]);
-      }
-
-      break;
-
-    case _kinds.Kind.UNION_TYPE_EXTENSION:
-      if (!(0, _definition.isUnionType)(type)) {
-        throw new _GraphQLError.GraphQLError("Cannot extend non-union type \"".concat(type.name, "\"."), [node]);
-      }
-
-      break;
-
-    case _kinds.Kind.INPUT_OBJECT_TYPE_EXTENSION:
-      if (!(0, _definition.isInputObjectType)(type)) {
-        throw new _GraphQLError.GraphQLError("Cannot extend non-input object type \"".concat(type.name, "\"."), [node]);
-      }
-
-      break;
+  function extendArg(arg) {
+    return _objectSpread({}, arg, {
+      type: replaceType(arg.type)
+    });
   }
 }