graphql 14.1.1 → 14.3.1

package/utilities/extendSchema.mjs

@@ -3,14 +3,16 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 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.
+ * Copyright (c) Facebook, Inc. and its affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
  * 
  */
+import flatMap from '../polyfills/flatMap';
 import objectValues from '../polyfills/objectValues';
+import inspect from '../jsutils/inspect';
 import invariant from '../jsutils/invariant';
 import mapValue from '../jsutils/mapValue';
 import keyValMap from '../jsutils/keyValMap';
@@ -51,14 +53,14 @@ export 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 = [];
+  var schemaExts = [];
   var _iteratorNormalCompletion = true;
   var _didIteratorError = false;
   var _iteratorError = undefined;
@@ -70,16 +72,15 @@ export function extendSchema(schema, documentAST, options) {
       if (def.kind === Kind.SCHEMA_DEFINITION) {
         schemaDef = def;
       } else if (def.kind === Kind.SCHEMA_EXTENSION) {
-        schemaExtensions.push(def);
+        schemaExts.push(def);
       } else if (isTypeDefinitionNode(def)) {
-        var typeName = def.name.value;
-        typeDefinitionMap[typeName] = def;
+        typeDefs.push(def);
       } else if (isTypeExtensionNode(def)) {
         var extendedTypeName = def.name.value;
-        var existingTypeExtensions = typeExtensionsMap[extendedTypeName];
-        typeExtensionsMap[extendedTypeName] = existingTypeExtensions ? existingTypeExtensions.concat([def]) : [def];
+        var existingTypeExts = typeExtsMap[extendedTypeName];
+        typeExtsMap[extendedTypeName] = existingTypeExts ? existingTypeExts.concat([def]) : [def];
       } else if (def.kind === Kind.DIRECTIVE_DEFINITION) {
-        directiveDefinitions.push(def);
+        directiveDefs.push(def);
       }
     } // If this document contains no new types, extensions, or directives then
     // return the same unmodified GraphQLSchema instance.
@@ -99,599 +100,304 @@ export function extendSchema(schema, documentAST, options) {
     }
   }
 
-  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 ASTDefinitionBuilder(typeDefinitionMap, options, function (typeName) {
-    var existingType = schema.getType(typeName);
-    !existingType ? invariant(0, "Unknown type: \"".concat(typeName, "\".")) : void 0;
-    return extendNamedType(existingType);
+  var schemaConfig = schema.toConfig();
+  var astBuilder = new ASTDefinitionBuilder(options, function (typeName) {
+    var type = typeMap[typeName];
+    !type ? invariant(0, "Unknown type: \"".concat(typeName, "\".")) : void 0;
+    return type;
   });
-  var extendTypeCache = Object.create(null); // Get the extended root operation types.
+  var typeMap = keyValMap(typeDefs, function (node) {
+    return node.name.value;
+  }, function (node) {
+    return astBuilder.buildType(node);
+  });
+  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 _iteratorNormalCompletion2 = true;
-    var _didIteratorError2 = false;
-    var _iteratorError2 = undefined;
+    var _iteratorNormalCompletion3 = true;
+    var _didIteratorError3 = false;
+    var _iteratorError3 = undefined;
 
     try {
-      for (var _iterator2 = schemaDef.operationTypes[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-        var _ref2 = _step2.value;
+      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;
-        // 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);
+        operationTypes[operation] = type.name.value;
       }
     } catch (err) {
-      _didIteratorError2 = true;
-      _iteratorError2 = err;
+      _didIteratorError3 = true;
+      _iteratorError3 = err;
     } finally {
       try {
-        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-          _iterator2.return();
+        if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+          _iterator3.return();
         }
       } finally {
-        if (_didIteratorError2) {
-          throw _iteratorError2;
+        if (_didIteratorError3) {
+          throw _iteratorError3;
         }
       }
     }
   } // Then, incorporate schema definition and all schema extensions.
 
 
-  for (var _i = 0; _i < schemaExtensions.length; _i++) {
-    var schemaExtension = schemaExtensions[_i];
+  for (var _i = 0, _schemaExts = schemaExts; _i < _schemaExts.length; _i++) {
+    var schemaExt = _schemaExts[_i];
 
-    if (schemaExtension.operationTypes) {
-      var _iteratorNormalCompletion14 = true;
-      var _didIteratorError14 = false;
-      var _iteratorError14 = undefined;
+    if (schemaExt.operationTypes) {
+      var _iteratorNormalCompletion4 = true;
+      var _didIteratorError4 = false;
+      var _iteratorError4 = undefined;
 
       try {
-        for (var _iterator14 = schemaExtension.operationTypes[Symbol.iterator](), _step14; !(_iteratorNormalCompletion14 = (_step14 = _iterator14.next()).done); _iteratorNormalCompletion14 = true) {
-          var _ref4 = _step14.value;
+        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;
-          // 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);
+          operationTypes[_operation] = _type.name.value;
         }
       } catch (err) {
-        _didIteratorError14 = true;
-        _iteratorError14 = err;
+        _didIteratorError4 = true;
+        _iteratorError4 = err;
       } finally {
         try {
-          if (!_iteratorNormalCompletion14 && _iterator14.return != null) {
-            _iterator14.return();
+          if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+            _iterator4.return();
           }
         } finally {
-          if (_didIteratorError14) {
-            throw _iteratorError14;
+          if (_didIteratorError4) {
+            throw _iteratorError4;
           }
         }
       }
     }
-  }
+  } // Support both original legacy names and extended legacy names.
 
-  var schemaExtensionASTNodes = schemaExtensions ? schema.extensionASTNodes ? schema.extensionASTNodes.concat(schemaExtensions) : schemaExtensions : schema.extensionASTNodes;
-  var types = [].concat(objectValues(schema.getTypeMap()).map(function (type) {
-    return extendNamedType(type);
-  }), objectValues(typeDefinitionMap).map(function (type) {
-    return astBuilder.buildType(type);
-  })); // 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 GraphQLSchema(_objectSpread({}, operationTypes, {
-    types: types,
+  return new 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: objectValues(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 (isListType(type)) {
+      return new GraphQLList(replaceType(type.ofType));
+    } else if (isNonNullType(type)) {
+      return new 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 ? invariant(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 (isIntrospectionType(type) || isSpecifiedScalarType(type)) {
       // Builtin types are not extended.
       return type;
-    }
-
-    var name = type.name;
-
-    if (!extendTypeCache[name]) {
-      if (isScalarType(type)) {
-        extendTypeCache[name] = extendScalarType(type);
-      } else if (isObjectType(type)) {
-        extendTypeCache[name] = extendObjectType(type);
-      } else if (isInterfaceType(type)) {
-        extendTypeCache[name] = extendInterfaceType(type);
-      } else if (isUnionType(type)) {
-        extendTypeCache[name] = extendUnionType(type);
-      } else if (isEnumType(type)) {
-        extendTypeCache[name] = extendEnumType(type);
-      } else if (isInputObjectType(type)) {
-        extendTypeCache[name] = extendInputObjectType(type);
-      }
-    }
-
-    return extendTypeCache[name];
+    } else if (isScalarType(type)) {
+      return extendScalarType(type);
+    } else if (isObjectType(type)) {
+      return extendObjectType(type);
+    } else if (isInterfaceType(type)) {
+      return extendInterfaceType(type);
+    } else if (isUnionType(type)) {
+      return extendUnionType(type);
+    } else if (isEnumType(type)) {
+      return extendEnumType(type);
+    } else if (isInputObjectType(type)) {
+      return extendInputObjectType(type);
+    } // Not reachable. All possible types have been considered.
+
+    /* istanbul ignore next */
+
+
+    throw new Error("Unexpected type: \"".concat(inspect(type), "\"."));
   }
 
   function extendDirective(directive) {
-    return new GraphQLDirective({
-      name: directive.name,
-      description: directive.description,
-      locations: directive.locations,
-      args: extendArgs(directive.args),
-      astNode: directive.astNode
-    });
+    var config = directive.toConfig();
+    return new GraphQLDirective(_objectSpread({}, config, {
+      args: mapValue(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 GraphQLInputObjectType({
-      name: name,
-      description: type.description,
+    var config = type.toConfig();
+    var extensions = typeExtsMap[config.name] || [];
+    var fieldNodes = flatMap(extensions, function (node) {
+      return node.fields || [];
+    });
+    return new GraphQLInputObjectType(_objectSpread({}, config, {
       fields: function fields() {
-        return extendInputFieldMap(type);
+        return _objectSpread({}, mapValue(config.fields, function (field) {
+          return _objectSpread({}, field, {
+            type: replaceType(field.type)
+          });
+        }), keyValMap(fieldNodes, function (field) {
+          return field.name.value;
+        }, function (field) {
+          return astBuilder.buildInputField(field);
+        }));
       },
-      astNode: type.astNode,
-      extensionASTNodes: extensionASTNodes
-    });
-  }
-
-  function extendInputFieldMap(type) {
-    var newFieldMap = mapValue(type.getFields(), function (field) {
-      return {
-        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 _iteratorNormalCompletion3 = true;
-      var _didIteratorError3 = false;
-      var _iteratorError3 = undefined;
-
-      try {
-        for (var _iterator3 = extensions[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
-          var extension = _step3.value;
-          var _iteratorNormalCompletion4 = true;
-          var _didIteratorError4 = false;
-          var _iteratorError4 = undefined;
-
-          try {
-            for (var _iterator4 = extension.fields[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
-              var field = _step4.value;
-              newFieldMap[field.name.value] = astBuilder.buildInputField(field);
-            }
-          } catch (err) {
-            _didIteratorError4 = true;
-            _iteratorError4 = err;
-          } finally {
-            try {
-              if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
-                _iterator4.return();
-              }
-            } finally {
-              if (_didIteratorError4) {
-                throw _iteratorError4;
-              }
-            }
-          }
-        }
-      } catch (err) {
-        _didIteratorError3 = true;
-        _iteratorError3 = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
-            _iterator3.return();
-          }
-        } finally {
-          if (_didIteratorError3) {
-            throw _iteratorError3;
-          }
-        }
-      }
-    }
-
-    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 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 = flatMap(extensions, function (node) {
+      return node.values || [];
     });
-  }
-
-  function extendValueMap(type) {
-    var newValueMap = Object.create(null);
-    var _iteratorNormalCompletion5 = true;
-    var _didIteratorError5 = false;
-    var _iteratorError5 = undefined;
-
-    try {
-      for (var _iterator5 = type.getValues()[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
-        var _value = _step5.value;
-        newValueMap[_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.
-
-    } catch (err) {
-      _didIteratorError5 = true;
-      _iteratorError5 = err;
-    } finally {
-      try {
-        if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
-          _iterator5.return();
-        }
-      } finally {
-        if (_didIteratorError5) {
-          throw _iteratorError5;
-        }
-      }
-    }
-
-    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.values[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
-              var value = _step7.value;
-              newValueMap[value.name.value] = astBuilder.buildEnumValue(value);
-            }
-          } 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 newValueMap;
+    return new GraphQLEnumType(_objectSpread({}, config, {
+      values: _objectSpread({}, config.values, keyValMap(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 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 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 GraphQLObjectType({
-      name: name,
-      description: type.description,
+    var config = type.toConfig();
+    var extensions = typeExtsMap[config.name] || [];
+    var interfaceNodes = flatMap(extensions, function (node) {
+      return node.interfaces || [];
+    });
+    var fieldNodes = flatMap(extensions, function (node) {
+      return node.fields || [];
+    });
+    return new 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({}, mapValue(config.fields, extendField), keyValMap(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 keyValMap(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 GraphQLInterfaceType({
-      name: type.name,
-      description: type.description,
+    var config = type.toConfig();
+    var extensions = typeExtsMap[config.name] || [];
+    var fieldNodes = flatMap(extensions, function (node) {
+      return node.fields || [];
+    });
+    return new GraphQLInterfaceType(_objectSpread({}, config, {
       fields: function fields() {
-        return extendFieldMap(type);
+        return _objectSpread({}, mapValue(config.fields, extendField), keyValMap(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 GraphQLUnionType({
-      name: name,
-      description: type.description,
+    var config = type.toConfig();
+    var extensions = typeExtsMap[config.name] || [];
+    var typeNodes = flatMap(extensions, function (node) {
+      return node.types || [];
+    });
+    return new 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 _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.types[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.
-              possibleTypes.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 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 _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.interfaces[Symbol.iterator](), _step11; !(_iteratorNormalCompletion11 = (_step11 = _iterator11.next()).done); _iteratorNormalCompletion11 = true) {
-              var namedType = _step11.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) {
-            _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 interfaces;
+      extensionASTNodes: config.extensionASTNodes.concat(extensions)
+    }));
   }
 
-  function extendFieldMap(type) {
-    var newFieldMap = mapValue(type.getFields(), function (field) {
-      return {
-        description: field.description,
-        deprecationReason: field.deprecationReason,
-        type: extendType(field.type),
-        args: extendArgs(field.args),
-        astNode: field.astNode,
-        resolve: field.resolve
-      };
-    }); // If there are any extensions to the fields, apply those here.
-
-    var extensions = typeExtensionsMap[type.name];
-
-    if (extensions) {
-      var _iteratorNormalCompletion12 = true;
-      var _didIteratorError12 = false;
-      var _iteratorError12 = undefined;
-
-      try {
-        for (var _iterator12 = extensions[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
-          var extension = _step12.value;
-          var _iteratorNormalCompletion13 = true;
-          var _didIteratorError13 = false;
-          var _iteratorError13 = undefined;
-
-          try {
-            for (var _iterator13 = extension.fields[Symbol.iterator](), _step13; !(_iteratorNormalCompletion13 = (_step13 = _iterator13.next()).done); _iteratorNormalCompletion13 = true) {
-              var field = _step13.value;
-              newFieldMap[field.name.value] = astBuilder.buildField(field);
-            }
-          } catch (err) {
-            _didIteratorError13 = true;
-            _iteratorError13 = err;
-          } finally {
-            try {
-              if (!_iteratorNormalCompletion13 && _iterator13.return != null) {
-                _iterator13.return();
-              }
-            } finally {
-              if (_didIteratorError13) {
-                throw _iteratorError13;
-              }
-            }
-          }
-        }
-      } catch (err) {
-        _didIteratorError12 = true;
-        _iteratorError12 = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
-            _iterator12.return();
-          }
-        } finally {
-          if (_didIteratorError12) {
-            throw _iteratorError12;
-          }
-        }
-      }
-    }
-
-    return newFieldMap;
+  function extendField(field) {
+    return _objectSpread({}, field, {
+      type: replaceType(field.type),
+      args: mapValue(field.args, extendArg)
+    });
   }
 
-  function extendType(typeDef) {
-    if (isListType(typeDef)) {
-      return GraphQLList(extendType(typeDef.ofType));
-    }
-
-    if (isNonNullType(typeDef)) {
-      return GraphQLNonNull(extendType(typeDef.ofType));
-    }
-
-    return extendNamedType(typeDef);
+  function extendArg(arg) {
+    return _objectSpread({}, arg, {
+      type: replaceType(arg.type)
+    });
   }
-}
+}