relay-compiler 7.0.0 → 9.1.0

package/lib/core/Schema.js

@@ -8,41 +8,51 @@
  * @format
  * @emails oncall+relay
  */
+// flowlint ambiguous-object-type:error
 'use strict';
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
 var _inheritsLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/inheritsLoose"));
 
-var ASTConvert = require('./ASTConvert');
+function _createForOfIteratorHelper(o) { if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (o = _unsupportedIterableToArray(o))) { var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var it, normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
-var nullthrows = require('../util/nullthrowsOSS');
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-var _require = require('./RelayCompilerError'),
+function _createSuper(Derived) { return function () { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (_isNativeReflectConstruct()) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+var _require = require('./CompilerError'),
     createCompilerError = _require.createCompilerError;
 
-var _require2 = require('graphql'),
-    GraphQLEnumType = _require2.GraphQLEnumType,
-    GraphQLInputObjectType = _require2.GraphQLInputObjectType,
-    GraphQLInterfaceType = _require2.GraphQLInterfaceType,
-    GraphQLObjectType = _require2.GraphQLObjectType,
-    GraphQLScalarType = _require2.GraphQLScalarType,
-    GraphQLSchema = _require2.GraphQLSchema,
-    GraphQLUnionType = _require2.GraphQLUnionType,
-    buildASTSchema = _require2.buildASTSchema,
-    extendSchema = _require2.extendSchema,
-    parse = _require2.parse,
-    parseType = _require2.parseType,
-    print = _require2.print;
+var _require2 = require('./SchemaUtils'),
+    isSchemaDefinitionAST = _require2.isSchemaDefinitionAST;
+
+var _require3 = require('graphql'),
+    GraphQLFloat = _require3.GraphQLFloat,
+    GraphQLInt = _require3.GraphQLInt,
+    GraphQLBoolean = _require3.GraphQLBoolean,
+    GraphQLString = _require3.GraphQLString,
+    GraphQLID = _require3.GraphQLID,
+    parse = _require3.parse,
+    parseType = _require3.parseType,
+    print = _require3.print,
+    valueFromASTUntyped = _require3.valueFromASTUntyped;
 
 /**
  * @private
  */
-var Type =
-/*#__PURE__*/
-function () {
-  function Type(name) {
+var Type = /*#__PURE__*/function () {
+  function Type(name, isClient) {
     this.name = name;
+    this.isClient = isClient;
   }
 
   var _proto = Type.prototype;
@@ -62,11 +72,11 @@ function () {
  */
 
 
-var ScalarType =
-/*#__PURE__*/
-function (_Type) {
+var ScalarType = /*#__PURE__*/function (_Type) {
   (0, _inheritsLoose2["default"])(ScalarType, _Type);
 
+  var _super = _createSuper(ScalarType);
+
   function ScalarType() {
     return _Type.apply(this, arguments) || this;
   }
@@ -78,13 +88,17 @@ function (_Type) {
  */
 
 
-var EnumType =
-/*#__PURE__*/
-function (_Type2) {
+var EnumType = /*#__PURE__*/function (_Type2) {
   (0, _inheritsLoose2["default"])(EnumType, _Type2);
 
-  function EnumType() {
-    return _Type2.apply(this, arguments) || this;
+  var _super2 = _createSuper(EnumType);
+
+  function EnumType(name, values, isClient) {
+    var _this;
+
+    _this = _Type2.call(this, name, isClient) || this;
+    _this.values = values;
+    return _this;
   }
 
   return EnumType;
@@ -94,11 +108,11 @@ function (_Type2) {
  */
 
 
-var UnionType =
-/*#__PURE__*/
-function (_Type3) {
+var UnionType = /*#__PURE__*/function (_Type3) {
   (0, _inheritsLoose2["default"])(UnionType, _Type3);
 
+  var _super3 = _createSuper(UnionType);
+
   function UnionType() {
     return _Type3.apply(this, arguments) || this;
   }
@@ -110,11 +124,11 @@ function (_Type3) {
  */
 
 
-var ObjectType =
-/*#__PURE__*/
-function (_Type4) {
+var ObjectType = /*#__PURE__*/function (_Type4) {
   (0, _inheritsLoose2["default"])(ObjectType, _Type4);
 
+  var _super4 = _createSuper(ObjectType);
+
   function ObjectType() {
     return _Type4.apply(this, arguments) || this;
   }
@@ -126,11 +140,11 @@ function (_Type4) {
  */
 
 
-var InputObjectType =
-/*#__PURE__*/
-function (_Type5) {
+var InputObjectType = /*#__PURE__*/function (_Type5) {
   (0, _inheritsLoose2["default"])(InputObjectType, _Type5);
 
+  var _super5 = _createSuper(InputObjectType);
+
   function InputObjectType() {
     return _Type5.apply(this, arguments) || this;
   }
@@ -142,11 +156,11 @@ function (_Type5) {
  */
 
 
-var InterfaceType =
-/*#__PURE__*/
-function (_Type6) {
+var InterfaceType = /*#__PURE__*/function (_Type6) {
   (0, _inheritsLoose2["default"])(InterfaceType, _Type6);
 
+  var _super6 = _createSuper(InterfaceType);
+
   function InterfaceType() {
     return _Type6.apply(this, arguments) || this;
   }
@@ -158,9 +172,7 @@ function (_Type6) {
  */
 
 
-var List =
-/*#__PURE__*/
-function () {
+var List = /*#__PURE__*/function () {
   function List(type) {
     this.ofType = type;
     this._typeString = "[".concat(String(this.ofType), "]");
@@ -183,9 +195,7 @@ function () {
  */
 
 
-var NonNull =
-/*#__PURE__*/
-function () {
+var NonNull = /*#__PURE__*/function () {
   function NonNull(type) {
     this.ofType = type;
     this._typeString = "".concat(String(this.ofType), "!");
@@ -208,19 +218,12 @@ function () {
  */
 
 
-var Field = function Field(schema, name, type, belongsTo, argDefs) {
+var Field = function Field(schema, name, type, belongsTo, args, isClient) {
   this.name = name;
   this.type = type;
   this.belongsTo = belongsTo;
-  this.args = new Map(argDefs.map(function (arg) {
-    var _arg$astNode;
-
-    return [arg.name, {
-      name: arg.name,
-      type: schema.assertInputType(schema.expectTypeFromAST(nullthrows((_arg$astNode = arg.astNode) === null || _arg$astNode === void 0 ? void 0 : _arg$astNode.type))),
-      defaultValue: arg.defaultValue
-    }];
-  }));
+  this.isClient = isClient;
+  this.args = parseInputArgumentDefinitionsMap(schema, args);
 };
 /**
  * @private
@@ -261,6 +264,9 @@ function getConcreteTypes(schema, type) {
 
 var TYPENAME_FIELD = '__typename';
 var CLIENT_ID_FIELD = '__id';
+var QUERY_TYPE_KEY = Symbol('Query');
+var MUTATION_TYPE_KEY = Symbol('Mutation');
+var SUBSCRIPTION_TYPE_KEY = Symbol('Subscription');
 
 function _isScalar(type) {
   return type instanceof ScalarType;
@@ -306,45 +312,34 @@ function _isInputType(type) {
   return type instanceof InputObjectType || type instanceof ScalarType || type instanceof EnumType;
 }
 
-var Schema =
-/*#__PURE__*/
-function () {
+var Schema = /*#__PURE__*/function () {
   /**
    * @private
    */
-  function Schema(baseSchema, extendedSchema, typeMap, fieldsMap, typeNameMap, clientIdMap, possibleTypesMap, directivesMap, QUERY_TYPE_KEY, MUTATION_TYPE_KEY, SUBSCRIPTION_TYPE_KEY) {
-    var _this = this;
-
-    var _directivesMap;
+  function Schema(typeMap) {
+    var _this2 = this;
 
-    this.QUERY_TYPE_KEY = QUERY_TYPE_KEY;
-    this.MUTATION_TYPE_KEY = MUTATION_TYPE_KEY;
-    this.SUBSCRIPTION_TYPE_KEY = SUBSCRIPTION_TYPE_KEY;
-    this._baseSchema = baseSchema;
-    this._extendedSchema = extendedSchema;
     this._typeMap = typeMap;
-    this._fieldsMap = fieldsMap;
-    this._typeNameMap = typeNameMap;
-    this._clientIdMap = clientIdMap;
-    this._possibleTypesMap = possibleTypesMap;
-    this._directivesMap = (_directivesMap = directivesMap) !== null && _directivesMap !== void 0 ? _directivesMap : new Map(this._extendedSchema.getDirectives().map(function (directive) {
+    this._typeWrappersMap = new Map();
+    this._fieldsMap = new Map();
+    this._typeNameMap = new Map();
+    this._clientIdMap = new Map();
+    this._directiveMap = new Map(typeMap.getDirectives().map(function (directive) {
       return [directive.name, {
-        clientOnlyDirective: _this._baseSchema.getDirective(directive.name) == null,
-        name: directive.name,
         locations: directive.locations,
-        args: directive.args.map(function (arg) {
-          return {
-            name: arg.name,
-            type: _this.assertInputType(arg.astNode ? _this.expectTypeFromAST(arg.astNode.type) : _this.expectTypeFromString(String(arg.type))),
-            defaultValue: arg.defaultValue
-          };
-        })
+        args: parseInputArgumentDefinitions(_this2, directive.args),
+        name: directive.name,
+        isClient: directive.isClient
       }];
     }));
   }
 
   var _proto4 = Schema.prototype;
 
+  _proto4.getTypes = function getTypes() {
+    return this._typeMap.getTypes();
+  };
+
   _proto4.getTypeFromAST = function getTypeFromAST(typeNode) {
     if (typeNode.kind === 'NonNullType') {
       var innerType = this.getTypeFromAST(typeNode.type);
@@ -359,7 +354,7 @@ function () {
 
       var cacheKey = "".concat(this.getTypeString(innerType), "!");
 
-      var type = this._typeMap.get(cacheKey);
+      var type = this._typeWrappersMap.get(cacheKey);
 
       if (type) {
         return type;
@@ -367,7 +362,7 @@ function () {
 
       type = new NonNull(innerType);
 
-      this._typeMap.set(cacheKey, type);
+      this._typeWrappersMap.set(cacheKey, type);
 
       return type;
     } else if (typeNode.kind === 'ListType') {
@@ -379,7 +374,7 @@ function () {
 
       var _cacheKey = "[".concat(this.getTypeString(_innerType), "]");
 
-      var _type = this._typeMap.get(_cacheKey);
+      var _type = this._typeWrappersMap.get(_cacheKey);
 
       if (_type) {
         return _type;
@@ -387,52 +382,16 @@ function () {
 
       _type = new List(_innerType);
 
-      this._typeMap.set(_cacheKey, _type);
+      this._typeWrappersMap.set(_cacheKey, _type);
 
       return _type;
-    } else {
-      var name = typeNode.name.value;
-
-      var _type2 = this._typeMap.get(name);
-
-      if (_type2) {
-        return _type2;
-      }
-
-      var graphQLType = this._extendedSchema.getType(name);
-
-      if (!graphQLType) {
-        return;
-      }
-
-      var TypeClass = Type;
-
-      if (graphQLType instanceof GraphQLScalarType) {
-        TypeClass = ScalarType;
-      } else if (graphQLType instanceof GraphQLInputObjectType) {
-        TypeClass = InputObjectType;
-      } else if (graphQLType instanceof GraphQLEnumType) {
-        TypeClass = EnumType;
-      } else if (graphQLType instanceof GraphQLUnionType) {
-        TypeClass = UnionType;
-      } else if (graphQLType instanceof GraphQLInterfaceType) {
-        TypeClass = InterfaceType;
-      } else if (graphQLType instanceof GraphQLObjectType) {
-        TypeClass = ObjectType;
-      } else {
-        throw createCompilerError("Unknown GraphQL type: ".concat(graphQLType));
-      }
-
-      _type2 = new TypeClass(name);
-
-      this._typeMap.set(name, _type2);
-
-      return _type2;
     }
+
+    return this._typeMap.getTypeByName(typeNode.name.value);
   };
 
   _proto4._getRawType = function _getRawType(typeName) {
-    var type = this._typeMap.get(typeName);
+    var type = this._typeWrappersMap.get(typeName);
 
     if (type) {
       return type;
@@ -441,23 +400,17 @@ function () {
     if (typeof typeName === 'string') {
       return this.getTypeFromAST(parseType(typeName));
     } else {
-      var graphQLType;
-
-      if (typeName === this.QUERY_TYPE_KEY) {
-        graphQLType = this._baseSchema.getQueryType();
-      } else if (typeName === this.MUTATION_TYPE_KEY) {
-        graphQLType = this._baseSchema.getMutationType();
-      } else if (typeName === this.SUBSCRIPTION_TYPE_KEY) {
-        graphQLType = this._baseSchema.getSubscriptionType();
+      var operationType;
+
+      if (typeName === QUERY_TYPE_KEY) {
+        operationType = this._typeMap.getQueryType();
+      } else if (typeName === MUTATION_TYPE_KEY) {
+        operationType = this._typeMap.getMutationType();
+      } else if (typeName === SUBSCRIPTION_TYPE_KEY) {
+        operationType = this._typeMap.getSubscriptionType();
       }
 
-      if (graphQLType) {
-        var operationType = new ObjectType(graphQLType.name);
-
-        this._typeMap.set(typeName, operationType);
-
-        this._typeMap.set(graphQLType.name, operationType);
-
+      if (operationType instanceof ObjectType) {
         return operationType;
       }
     }
@@ -494,7 +447,7 @@ function () {
 
     var cacheKey = "".concat(String(type), "!");
 
-    var nonNullType = this._typeMap.get(cacheKey);
+    var nonNullType = this._typeWrappersMap.get(cacheKey);
 
     if (nonNullType) {
       return nonNullType;
@@ -502,7 +455,7 @@ function () {
 
     nonNullType = new NonNull(type);
 
-    this._typeMap.set(cacheKey, nonNullType);
+    this._typeWrappersMap.set(cacheKey, nonNullType);
 
     return nonNullType;
   };
@@ -560,10 +513,10 @@ function () {
   };
 
   _proto4.implementsInterface = function implementsInterface(type, interfaceType) {
-    var _this2 = this;
+    var _this3 = this;
 
     return this.getInterfaces(type).some(function (typeInterface) {
-      return _this2.areEqualTypes(typeInterface, interfaceType);
+      return _this3.areEqualTypes(typeInterface, interfaceType);
     });
   };
 
@@ -630,7 +583,7 @@ function () {
   ;
 
   _proto4.doTypesOverlap = function doTypesOverlap(typeA, typeB) {
-    var _this3 = this;
+    var _this4 = this;
 
     // Equivalent types overlap
     if (typeA === typeB) {
@@ -643,7 +596,7 @@ function () {
         // between possible concrete types of each.
         return Array.from(this.getPossibleTypes(typeA)).some(function (type) {
           if (_isObject(type)) {
-            return _this3.isPossibleType(typeB, type);
+            return _this4.isPossibleType(typeB, type);
           }
         });
       } // Determine if the latter type is a possible concrete type of the former.
@@ -662,7 +615,7 @@ function () {
   };
 
   _proto4.isPossibleType = function isPossibleType(superType, maybeSubType) {
-    return this._getPossibleTypeSet(superType).has(maybeSubType);
+    return this._typeMap.getPossibleTypeSet(superType).has(maybeSubType);
   };
 
   _proto4.assertScalarFieldType = function assertScalarFieldType(type) {
@@ -843,7 +796,7 @@ function () {
   };
 
   _proto4.getQueryType = function getQueryType() {
-    var queryType = this._getRawType(this.QUERY_TYPE_KEY);
+    var queryType = this._getRawType(QUERY_TYPE_KEY);
 
     if (queryType && _isObject(queryType)) {
       return queryType;
@@ -851,7 +804,7 @@ function () {
   };
 
   _proto4.getMutationType = function getMutationType() {
-    var mutationType = this._getRawType(this.MUTATION_TYPE_KEY);
+    var mutationType = this._getRawType(MUTATION_TYPE_KEY);
 
     if (mutationType && _isObject(mutationType)) {
       return mutationType;
@@ -859,7 +812,7 @@ function () {
   };
 
   _proto4.getSubscriptionType = function getSubscriptionType() {
-    var subscriptionType = this._getRawType(this.SUBSCRIPTION_TYPE_KEY);
+    var subscriptionType = this._getRawType(SUBSCRIPTION_TYPE_KEY);
 
     if (subscriptionType && _isObject(subscriptionType)) {
       return subscriptionType;
@@ -996,15 +949,13 @@ function () {
       return true;
     }
 
-    var name = type.name;
-
-    var gqlType = this._extendedSchema.getType(name);
-
-    if (gqlType instanceof GraphQLObjectType || gqlType instanceof GraphQLInterfaceType || gqlType instanceof GraphQLInputObjectType) {
-      return gqlType.getFields()[fieldName] != null;
+    if (type instanceof ObjectType || type instanceof InterfaceType) {
+      return this._typeMap.getField(type, fieldName) != null;
+    } else if (type instanceof InputObjectType) {
+      return this._typeMap.getInputField(type, fieldName) != null;
     }
 
-    throw createCompilerError('hasField(): Expected a concrete type or interface, ' + "got type ".concat(type.name));
+    return false;
   };
 
   _proto4.hasId = function hasId(type) {
@@ -1023,8 +974,6 @@ function () {
   };
 
   _proto4._getFieldsMap = function _getFieldsMap(type) {
-    var _this4 = this;
-
     var cachedMap = this._fieldsMap.get(type);
 
     if (cachedMap != null) {
@@ -1032,38 +981,55 @@ function () {
     }
 
     var fieldsMap = new Map();
-    var name = type.name;
 
-    var gqlType = this._extendedSchema.getType(name);
+    if (type instanceof ObjectType || type instanceof InterfaceType) {
+      var fields = this._typeMap.getFieldMap(type);
 
-    if (gqlType instanceof GraphQLObjectType || gqlType instanceof GraphQLInterfaceType) {
-      var typeFields = gqlType.getFields();
-      var fieldNames = Object.keys(typeFields);
-      fieldNames.forEach(function (fieldName) {
-        var field = typeFields[fieldName];
+      if (fields) {
+        var _iterator = _createForOfIteratorHelper(fields),
+            _step;
 
-        if (field == null) {
-          return;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var _step$value = _step.value,
+                fieldName = _step$value[0],
+                fieldDefinition = _step$value[1];
+            var fieldType = this.expectTypeFromAST(fieldDefinition.type);
+            fieldsMap.set(fieldName, new Field(this, fieldName, fieldType, this.assertCompositeType(type), fieldDefinition.arguments, fieldDefinition.isClient));
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
         }
+      }
+    } else if (type instanceof InputObjectType) {
+      var _fields = this._typeMap.getInputFieldMap(type);
 
-        var fieldType = field.astNode ? _this4.expectTypeFromAST(field.astNode.type) : _this4.expectTypeFromString(String(field.type));
-        fieldsMap.set(fieldName, new Field(_this4, fieldName, fieldType, _this4.assertCompositeType(type), field.args));
-      });
-    } else if (gqlType instanceof GraphQLInputObjectType) {
-      var _typeFields = gqlType.getFields();
+      if (_fields) {
+        var _iterator2 = _createForOfIteratorHelper(_fields),
+            _step2;
 
-      var _fieldNames = Object.keys(_typeFields);
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var _step2$value = _step2.value,
+                _fieldName = _step2$value[0],
+                typeNode = _step2$value[1];
 
-      _fieldNames.forEach(function (fieldName) {
-        var field = _typeFields[fieldName];
+            var _fieldType = this.expectTypeFromAST(typeNode);
 
-        if (field == null) {
-          return;
+            fieldsMap.set(_fieldName, new Field(this, _fieldName, _fieldType, type, [], false));
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
         }
+      }
+    }
 
-        var fieldType = field.astNode ? _this4.expectTypeFromAST(field.astNode.type) : _this4.expectTypeFromString(String(field.type));
-        fieldsMap.set(fieldName, new Field(_this4, fieldName, fieldType, type, []));
-      });
+    if (fieldsMap.size === 0) {
+      throw createCompilerError("_getFieldsMap: Type '".concat(type.name, "' should have fields."));
     }
 
     this._fieldsMap.set(type, fieldsMap);
@@ -1082,7 +1048,7 @@ function () {
       var typename = this._typeNameMap.get(type);
 
       if (!typename) {
-        typename = new Field(this, TYPENAME_FIELD, this.getNonNullType(this.expectStringType()), type, []);
+        typename = new Field(this, TYPENAME_FIELD, this.getNonNullType(this.expectStringType()), type, [], false);
 
         this._typeNameMap.set(type, typename);
       }
@@ -1094,7 +1060,7 @@ function () {
       var clientId = this._clientIdMap.get(type);
 
       if (!clientId) {
-        clientId = new Field(this, CLIENT_ID_FIELD, this.getNonNullType(this.expectIdType()), type, []);
+        clientId = new Field(this, CLIENT_ID_FIELD, this.getNonNullType(this.expectIdType()), type, [], true);
 
         this._clientIdMap.set(type, clientId);
       }
@@ -1149,226 +1115,751 @@ function () {
   };
 
   _proto4.getEnumValues = function getEnumValues(type) {
-    var gqlType = this._extendedSchema.getType(type.name);
+    return type.values;
+  };
 
-    if (gqlType instanceof GraphQLEnumType) {
-      return gqlType.getValues().map(function (_ref) {
-        var value = _ref.value;
-        return String(value);
-      });
+  _proto4.getUnionTypes = function getUnionTypes(type) {
+    return Array.from(this._typeMap.getPossibleTypeSet(type));
+  };
+
+  _proto4.getInterfaces = function getInterfaces(type) {
+    if (type instanceof ObjectType) {
+      return this._typeMap.getInterfaces(type);
     }
 
-    throw createCompilerError("Expected '".concat(type.name, "' to be an enum."));
+    return [];
   };
 
-  _proto4.getUnionTypes = function getUnionTypes(type) {
-    var _this5 = this;
+  _proto4.getPossibleTypes = function getPossibleTypes(type) {
+    return this._typeMap.getPossibleTypeSet(type);
+  };
 
-    var gqlType = this._extendedSchema.getType(type.name);
+  _proto4.getFetchableFieldName = function getFetchableFieldName(type) {
+    return this._typeMap.getFetchableFieldName(type);
+  };
 
-    if (gqlType instanceof GraphQLUnionType) {
-      return gqlType.getTypes().map(function (typeFromUnion) {
-        return _this5.expectTypeFromString(typeFromUnion.name);
-      });
+  _proto4.parseLiteral = function parseLiteral(type, valueNode) {
+    if (type instanceof EnumType && valueNode.kind === 'EnumValue') {
+      return this.parseValue(type, valueNode.value);
+    } else if (type instanceof ScalarType) {
+      if (valueNode.kind === 'BooleanValue' && type.name === 'Boolean') {
+        return GraphQLBoolean.parseLiteral(valueNode);
+      } else if (valueNode.kind === 'FloatValue' && type.name === 'Float') {
+        return GraphQLFloat.parseLiteral(valueNode);
+      } else if (valueNode.kind === 'IntValue' && (type.name === 'Int' || type.name === 'ID' || type.name === 'Float')) {
+        return GraphQLInt.parseLiteral(valueNode);
+      } else if (valueNode.kind === 'StringValue' && (type.name === 'String' || type.name === 'ID')) {
+        return GraphQLString.parseLiteral(valueNode);
+      } else if (!isDefaultScalar(type.name)) {
+        return valueFromASTUntyped(valueNode);
+      }
+    }
+  };
+
+  _proto4.parseValue = function parseValue(type, value) {
+    if (type instanceof EnumType) {
+      return type.values.includes(value) ? value : undefined;
+    } else if (type instanceof ScalarType) {
+      switch (type.name) {
+        case 'Boolean':
+          return GraphQLBoolean.parseValue(value);
+
+        case 'Float':
+          return GraphQLFloat.parseValue(value);
+
+        case 'Int':
+          return GraphQLInt.parseValue(value);
+
+        case 'String':
+          return GraphQLString.parseValue(value);
+
+        case 'ID':
+          return GraphQLID.parseValue(value);
+
+        default:
+          return value;
+      }
     }
+  };
+
+  _proto4.serialize = function serialize(type, value) {
+    if (type instanceof EnumType) {
+      return type.values.includes(value) ? value : undefined;
+    } else if (type instanceof ScalarType) {
+      switch (type.name) {
+        case 'Boolean':
+          return GraphQLBoolean.serialize(value);
+
+        case 'Float':
+          return GraphQLFloat.serialize(value);
 
-    throw createCompilerError("Unable to get union types for type '".concat(this.getTypeString(type), "'."));
+        case 'Int':
+          return GraphQLInt.serialize(value);
+
+        case 'String':
+          return GraphQLString.serialize(value);
+
+        case 'ID':
+          return GraphQLID.serialize(value);
+
+        default:
+          return value;
+      }
+    }
   };
 
-  _proto4.getInterfaces = function getInterfaces(type) {
-    var _this6 = this;
+  _proto4.getDirectives = function getDirectives() {
+    return Array.from(this._directiveMap.values());
+  };
 
-    var gqlType = this._extendedSchema.getType(type.name);
+  _proto4.getDirective = function getDirective(directiveName) {
+    return this._directiveMap.get(directiveName);
+  };
 
-    if (gqlType instanceof GraphQLObjectType) {
-      return gqlType.getInterfaces().map(function (typeInterface) {
-        return _this6.expectTypeFromString(typeInterface.name);
-      });
+  _proto4.isServerType = function isServerType(type) {
+    if (_isObject(type)) {
+      return type.isClient === false;
+    } else if (_isEnum(type)) {
+      return type.isClient === false;
     }
 
-    return [];
+    return true;
   };
 
-  _proto4._getPossibleTypeSet = function _getPossibleTypeSet(type) {
-    var _this7 = this;
+  _proto4.isServerField = function isServerField(field) {
+    return field.isClient === false;
+  };
 
-    var possibleTypes = this._possibleTypesMap.get(type);
+  _proto4.isServerDirective = function isServerDirective(directiveName) {
+    var directive = this._directiveMap.get(directiveName);
 
-    if (!possibleTypes) {
-      var gqlType = this._extendedSchema.getType(type.name);
+    return (directive === null || directive === void 0 ? void 0 : directive.isClient) === false;
+  };
 
-      if (gqlType instanceof GraphQLUnionType || gqlType instanceof GraphQLInterfaceType) {
-        possibleTypes = new Set(this._extendedSchema.getPossibleTypes(gqlType).map(function (possibleType) {
-          return _this7.assertObjectType(_this7.expectTypeFromString(possibleType.name));
-        }));
+  _proto4.isServerDefinedField = function isServerDefinedField(type, field) {
+    return this.isAbstractType(type) && field.directives.some(function (_ref) {
+      var name = _ref.name;
+      return name === 'fixme_fat_interface';
+    }) || this.hasField(type, field.name) && this.isServerField(this.expectField(type, field.name));
+  };
 
-        this._possibleTypesMap.set(type, possibleTypes);
-      } else {
-        throw createCompilerError("Expected \"".concat(this.getTypeString(type), "\" to be an Abstract type."));
+  _proto4.isClientDefinedField = function isClientDefinedField(type, field) {
+    return !this.isServerDefinedField(type, field);
+  };
+
+  _proto4.extend = function extend(extensions) {
+    var doc = Array.isArray(extensions) ? parse(extensions.join('\n')) : extensions;
+    var schemaExtensions = [];
+    doc.definitions.forEach(function (definition) {
+      if (isSchemaDefinitionAST(definition)) {
+        schemaExtensions.push(definition);
       }
+    });
+
+    if (schemaExtensions.length > 0) {
+      return new Schema(this._typeMap.extend(schemaExtensions));
     }
 
-    return possibleTypes;
+    return this;
   };
 
-  _proto4.getPossibleTypes = function getPossibleTypes(type) {
-    return this._getPossibleTypeSet(type);
+  return Schema;
+}();
+
+var TypeMap = /*#__PURE__*/function () {
+  function TypeMap(source, extensions) {
+    this._types = new Map([['ID', new ScalarType('ID', false)], ['String', new ScalarType('String', false)], ['Boolean', new ScalarType('Boolean', false)], ['Float', new ScalarType('Float', false)], ['Int', new ScalarType('Int', false)]]);
+    this._typeInterfaces = new Map();
+    this._unionTypes = new Map();
+    this._interfaceImplementations = new Map();
+    this._fields = new Map();
+    this._inputFields = new Map();
+    this._directives = new Map([['include', {
+      name: 'include',
+      isClient: false,
+      locations: ['FIELD', 'FRAGMENT_SPREAD', 'INLINE_FRAGMENT'],
+      args: [{
+        name: 'if',
+        typeNode: parseType('Boolean!'),
+        defaultValue: undefined
+      }]
+    }], ['skip', {
+      name: 'skip',
+      isClient: false,
+      locations: ['FIELD', 'FRAGMENT_SPREAD', 'INLINE_FRAGMENT'],
+      args: [{
+        name: 'if',
+        typeNode: parseType('Boolean!'),
+        defaultValue: undefined
+      }]
+    }], ['deprecated', {
+      name: 'deprecated',
+      isClient: false,
+      locations: ['FIELD_DEFINITION', 'ENUM_VALUE'],
+      args: [{
+        name: 'reason',
+        typeNode: parseType('String'),
+        defaultValue: {
+          kind: 'StringValue',
+          value: 'No longer supported'
+        }
+      }]
+    }]]);
+    this._queryTypeName = 'Query';
+    this._mutationTypeName = 'Mutation';
+    this._subscriptionTypeName = 'Subscription';
+    this._source = source;
+    this._extensions = extensions;
+    this._fetchable = new Map();
+
+    this._parse(source);
+
+    this._extend(extensions);
+  }
+
+  var _proto5 = TypeMap.prototype;
+
+  _proto5._parse = function _parse(source) {
+    var _this5 = this;
+
+    var document = parse(source, {
+      noLocation: true
+    });
+    document.definitions.forEach(function (definition) {
+      switch (definition.kind) {
+        case 'SchemaDefinition':
+          {
+            _this5._parseSchemaDefinition(definition);
+
+            break;
+          }
+
+        case 'ScalarTypeDefinition':
+          {
+            _this5._parseScalarNode(definition, false);
+
+            break;
+          }
+
+        case 'EnumTypeDefinition':
+          {
+            _this5._parseEnumNode(definition, false);
+
+            break;
+          }
+
+        case 'ObjectTypeDefinition':
+          {
+            _this5._parseObjectTypeNode(definition, false);
+
+            break;
+          }
+
+        case 'InputObjectTypeDefinition':
+          {
+            _this5._parseInputObjectTypeNode(definition, false);
+
+            break;
+          }
+
+        case 'UnionTypeDefinition':
+          {
+            _this5._parseUnionNode(definition, false);
+
+            break;
+          }
+
+        case 'InterfaceTypeDefinition':
+          {
+            _this5._parseInterfaceNode(definition, false);
+
+            break;
+          }
+
+        case 'DirectiveDefinition':
+          {
+            _this5._parseDirective(definition, false);
+
+            break;
+          }
+      }
+    });
   };
 
-  _proto4.parseLiteral = function parseLiteral(type, valueNode) {
-    var gqlType = this._extendedSchema.getType(type.name);
+  _proto5._parseSchemaDefinition = function _parseSchemaDefinition(node) {
+    var _this6 = this;
+
+    node.operationTypes.forEach(function (operationType) {
+      switch (operationType.operation) {
+        case 'query':
+          _this6._queryTypeName = operationType.type.name.value;
+          break;
+
+        case 'mutation':
+          _this6._mutationTypeName = operationType.type.name.value;
+          break;
+
+        case 'subscription':
+          _this6._subscriptionTypeName = operationType.type.name.value;
+          break;
+      }
+    });
+  };
+
+  _proto5._parseScalarNode = function _parseScalarNode(node, isClient) {
+    var name = node.name.value;
 
-    if (gqlType instanceof GraphQLEnumType || gqlType instanceof GraphQLScalarType) {
-      return gqlType.parseLiteral(valueNode);
+    if (!isDefaultScalar(name) && this._types.has(name)) {
+      throw createCompilerError("_parseScalarNode: Duplicate definition for type ".concat(name, "."), null, [node]);
     }
 
-    throw createCompilerError("parseLiteral(...) is used with invalid type: ".concat(this.getTypeString(type), "."));
+    this._types.set(name, new ScalarType(name, isClient));
   };
 
-  _proto4.parseValue = function parseValue(type, value) {
-    var gqlType = this._extendedSchema.getType(type.name);
+  _proto5._parseEnumNode = function _parseEnumNode(node, isClient) {
+    var name = node.name.value;
+
+    if (this._types.has(name)) {
+      throw createCompilerError("_parseEnumNode: Duplicate definition for type ".concat(name, "."), null, [node]);
+    } // SDL doesn't have information about the actual ENUM values
+
+
+    var values = node.values ? node.values.map(function (value) {
+      return value.name.value;
+    }) : [];
+
+    this._types.set(name, new EnumType(name, values, isClient));
+  };
+
+  _proto5._parseObjectTypeNode = function _parseObjectTypeNode(node, isClient) {
+    var _this7 = this;
+
+    var _this$_types$get;
+
+    var name = node.name.value; // Objects may be created by _parseUnionNode
+
+    var type = (_this$_types$get = this._types.get(name)) !== null && _this$_types$get !== void 0 ? _this$_types$get : new ObjectType(name, isClient);
 
-    if (gqlType instanceof GraphQLEnumType || gqlType instanceof GraphQLScalarType) {
-      return gqlType.parseValue(value);
+    if (!(type instanceof ObjectType)) {
+      throw createCompilerError("_parseObjectTypeNode: Expected object type, got ".concat(String(type)), null, [node]);
     }
 
-    throw createCompilerError("parseValue(...) is used with invalid type: ".concat(this.getTypeString(type), "."));
+    if (type.isClient !== isClient) {
+      throw createCompilerError("_parseObjectTypeNode: Cannot create object type '".concat(name, "' defined as a client type."), null, [node]);
+    }
+
+    var typeInterfaces = [];
+    node.interfaces && node.interfaces.forEach(function (interfaceTypeNode) {
+      var _this$_interfaceImple;
+
+      var interfaceName = interfaceTypeNode.name.value;
+
+      var interfaceType = _this7._types.get(interfaceName);
+
+      if (!interfaceType) {
+        interfaceType = new InterfaceType(interfaceName, isClient);
+
+        _this7._types.set(interfaceName, interfaceType);
+      }
+
+      if (!(interfaceType instanceof InterfaceType)) {
+        throw createCompilerError('_parseObjectTypeNode: Expected interface type', null, [interfaceTypeNode]);
+      }
+
+      var implementations = (_this$_interfaceImple = _this7._interfaceImplementations.get(interfaceType)) !== null && _this$_interfaceImple !== void 0 ? _this$_interfaceImple : new Set();
+      implementations.add(type);
+
+      _this7._interfaceImplementations.set(interfaceType, implementations);
+
+      typeInterfaces.push(interfaceType);
+    });
+    var fetchable = null;
+    node.directives && node.directives.forEach(function (directiveNode) {
+      if (directiveNode.name.value === 'fetchable') {
+        var field_name_arg = directiveNode.arguments && directiveNode.arguments.find(function (arg) {
+          return arg.name.value === 'field_name';
+        });
+
+        if (field_name_arg != null && field_name_arg.value.kind === 'StringValue') {
+          fetchable = {
+            field_name: field_name_arg.value.value
+          };
+        }
+      }
+    });
+
+    this._typeInterfaces.set(type, typeInterfaces);
+
+    this._types.set(name, type);
+
+    if (fetchable != null) {
+      this._fetchable.set(type, fetchable);
+    }
+
+    node.fields && this._handleTypeFieldsStrict(type, node.fields, isClient);
   };
 
-  _proto4.serialize = function serialize(type, value) {
-    var gqlType = this._extendedSchema.getType(type.name);
+  _proto5._parseInputObjectTypeNode = function _parseInputObjectTypeNode(node, isClient) {
+    var name = node.name.value;
 
-    if (gqlType instanceof GraphQLEnumType || gqlType instanceof GraphQLScalarType) {
-      return gqlType.serialize(value);
+    if (this._types.has(name)) {
+      throw createCompilerError('_parseInputObjectTypeNode: Unable to parse schema file. Duplicate definition for object type', null, [node]);
     }
 
-    throw createCompilerError("parseValue(...) is used with invalid type: ".concat(this.getTypeString(type), "."));
+    var type = new InputObjectType(name, isClient);
+
+    this._types.set(name, type);
+
+    this._parseInputObjectFields(type, node);
   };
 
-  _proto4.getDirectives = function getDirectives() {
-    return Array.from(this._directivesMap.values());
+  _proto5._parseUnionNode = function _parseUnionNode(node, isClient) {
+    var _this8 = this;
+
+    var name = node.name.value;
+
+    if (this._types.has(name)) {
+      throw createCompilerError('_parseUnionNode: Unable to parse schema file. Duplicate definition for object type', null, [node]);
+    }
+
+    var union = new UnionType(name, isClient);
+
+    this._types.set(name, union);
+
+    this._unionTypes.set(union, new Set(node.types ? node.types.map(function (typeInUnion) {
+      var _this$_types$get2;
+
+      var typeInUnionName = typeInUnion.name.value;
+      var object = (_this$_types$get2 = _this8._types.get(typeInUnionName)) !== null && _this$_types$get2 !== void 0 ? _this$_types$get2 : new ObjectType(typeInUnionName, false);
+
+      if (!(object instanceof ObjectType)) {
+        throw createCompilerError('_parseUnionNode: Expected object type', null, [typeInUnion]);
+      }
+
+      _this8._types.set(typeInUnionName, object);
+
+      return object;
+    }) : []));
   };
 
-  _proto4.getDirective = function getDirective(directiveName) {
-    return this._directivesMap.get(directiveName);
+  _proto5._parseInterfaceNode = function _parseInterfaceNode(node, isClient) {
+    var name = node.name.value;
+
+    var type = this._types.get(name);
+
+    if (!type) {
+      type = new InterfaceType(name, isClient);
+
+      this._types.set(name, type);
+    }
+
+    if (!(type instanceof InterfaceType)) {
+      throw createCompilerError("_parseInterfaceNode: Expected interface type. Got ".concat(String(type)), null, [node]);
+    }
+
+    if (type.isClient !== isClient) {
+      throw createCompilerError("_parseInterfaceNode: Cannot create interface '".concat(name, "' defined as a client interface"), null, [node]);
+    }
+
+    node.fields && this._handleTypeFieldsStrict(type, node.fields, isClient);
   };
 
-  _proto4.isServerType = function isServerType(type) {
-    var name = this.getTypeString(type);
-    return this._baseSchema.getType(name) != null;
+  _proto5._handleTypeFieldsStrict = function _handleTypeFieldsStrict(type, fields, isClient) {
+    if (this._fields.has(type)) {
+      throw createCompilerError('_handleTypeFieldsStrict: Unable to parse schema file. Duplicate definition for object type');
+    }
+
+    this._handleTypeFields(type, fields, isClient);
   };
 
-  _proto4.isServerField = function isServerField(field) {
-    var fieldName = field.name; // Allow metadata fields and fields defined on classic "fat" interfaces
+  _proto5._handleTypeFields = function _handleTypeFields(type, fields, isClient) {
+    var _this$_fields$get;
 
-    if (['__typename'].includes(fieldName)) {
-      return true;
-    }
+    var fieldsMap = (_this$_fields$get = this._fields.get(type)) !== null && _this$_fields$get !== void 0 ? _this$_fields$get : new Map();
+    fields.forEach(function (fieldNode) {
+      var fieldName = fieldNode.name.value;
 
-    var fieldRawTypeName = this.getTypeString(unwrap(field.type));
-    var fieldParentTypeName = this.getTypeString(unwrap(field.belongsTo)); // Field type is client-only
+      if (fieldsMap.has(fieldName)) {
+        throw createCompilerError("_handleTypeFields: Duplicate definition for field '".concat(fieldName, "'."));
+      }
 
-    if (!this._baseSchema.getType(fieldRawTypeName)) {
-      return false;
+      fieldsMap.set(fieldName, {
+        arguments: fieldNode.arguments ? fieldNode.arguments.map(function (arg) {
+          return {
+            name: arg.name.value,
+            typeNode: arg.type,
+            defaultValue: arg.defaultValue
+          };
+        }) : [],
+        type: fieldNode.type,
+        isClient: isClient
+      });
+    });
+
+    this._fields.set(type, fieldsMap);
+  };
+
+  _proto5._parseInputObjectFields = function _parseInputObjectFields(type, node) {
+    if (this._inputFields.has(type)) {
+      throw createCompilerError('_parseInputObjectFields: Unable to parse schema file. Duplicate definition for type', null, [node]);
     }
 
-    var serverType = this._baseSchema.getType(fieldParentTypeName); // Parent type is client-only
+    var fields = new Map();
 
+    if (node.fields) {
+      node.fields.forEach(function (fieldNode) {
+        fields.set(fieldNode.name.value, fieldNode.type);
+      });
+    }
 
-    if (serverType == null) {
-      return false;
-    } else {
-      if (serverType instanceof GraphQLObjectType || serverType instanceof GraphQLInterfaceType || serverType instanceof GraphQLInputObjectType) {
-        // Field is not available in the server schema
-        if (!serverType.getFields()[fieldName]) {
-          return false;
+    this._inputFields.set(type, fields);
+  };
+
+  _proto5._parseDirective = function _parseDirective(node, isClient) {
+    var name = node.name.value;
+
+    this._directives.set(name, {
+      name: name,
+      args: node.arguments ? node.arguments.map(function (arg) {
+        return {
+          name: arg.name.value,
+          typeNode: arg.type,
+          defaultValue: arg.defaultValue
+        };
+      }) : [],
+      locations: node.locations.map(function (location) {
+        switch (location.value) {
+          case 'QUERY':
+          case 'MUTATION':
+          case 'SUBSCRIPTION':
+          case 'FIELD':
+          case 'FRAGMENT_DEFINITION':
+          case 'FRAGMENT_SPREAD':
+          case 'INLINE_FRAGMENT':
+          case 'VARIABLE_DEFINITION':
+          case 'SCHEMA':
+          case 'SCALAR':
+          case 'OBJECT':
+          case 'FIELD_DEFINITION':
+          case 'ARGUMENT_DEFINITION':
+          case 'INTERFACE':
+          case 'UNION':
+          case 'ENUM':
+          case 'ENUM_VALUE':
+          case 'INPUT_OBJECT':
+          case 'INPUT_FIELD_DEFINITION':
+            return location.value;
+
+          default:
+            throw createCompilerError('Invalid directive location');
         }
+      }),
+      isClient: isClient
+    });
+  };
+
+  _proto5._parseObjectTypeExtension = function _parseObjectTypeExtension(node) {
+    var type = this._types.get(node.name.value);
+
+    if (!(type instanceof ObjectType)) {
+      throw createCompilerError("_parseObjectTypeExtension: Expected to find type with the name '".concat(node.name.value, "'"), null, [node]);
+    }
+
+    node.fields && this._handleTypeFields(type, node.fields, true
+    /** client fields */
+    );
+  };
+
+  _proto5._parseInterfaceTypeExtension = function _parseInterfaceTypeExtension(node) {
+    var type = this._types.get(node.name.value);
+
+    if (!(type instanceof InterfaceType)) {
+      throw createCompilerError('_parseInterfaceTypeExtension: Expected to have an interface type');
+    }
+
+    node.fields && this._handleTypeFields(type, node.fields, true);
+  };
+
+  _proto5._extend = function _extend(extensions) {
+    var _this9 = this;
+
+    extensions.forEach(function (definition) {
+      if (definition.kind === 'ObjectTypeDefinition') {
+        _this9._parseObjectTypeNode(definition, true);
+      } else if (definition.kind === 'InterfaceTypeDefinition') {
+        _this9._parseInterfaceNode(definition, true);
+      } else if (definition.kind === 'ScalarTypeDefinition') {
+        _this9._parseScalarNode(definition, true);
+      } else if (definition.kind === 'EnumTypeDefinition') {
+        _this9._parseEnumNode(definition, true);
+      } else if (definition.kind === 'InterfaceTypeExtension') {
+        _this9._parseInterfaceTypeExtension(definition);
+      } else if (definition.kind === 'ObjectTypeExtension') {
+        _this9._parseObjectTypeExtension(definition);
+      } else if (definition.kind === 'DirectiveDefinition') {
+        _this9._parseDirective(definition, true
+        /* client directive */
+        );
       } else {
-        return false;
+        throw createCompilerError("Unexpected extension kind: '".concat(definition.kind, "'"), null, [definition]);
       }
+    });
+  };
+
+  _proto5.getTypes = function getTypes() {
+    return Array.from(this._types.values());
+  };
+
+  _proto5.getTypeByName = function getTypeByName(typename) {
+    return this._types.get(typename);
+  };
+
+  _proto5.getInterfaces = function getInterfaces(type) {
+    var _this$_typeInterfaces;
+
+    return (_this$_typeInterfaces = this._typeInterfaces.get(type)) !== null && _this$_typeInterfaces !== void 0 ? _this$_typeInterfaces : [];
+  };
+
+  _proto5.getPossibleTypeSet = function getPossibleTypeSet(type) {
+    var set;
+
+    if (type instanceof InterfaceType) {
+      var _this$_interfaceImple2;
+
+      set = (_this$_interfaceImple2 = this._interfaceImplementations.get(type)) !== null && _this$_interfaceImple2 !== void 0 ? _this$_interfaceImple2 : new Set();
+    } else if (type instanceof UnionType) {
+      var _this$_unionTypes$get;
+
+      set = (_this$_unionTypes$get = this._unionTypes.get(type)) !== null && _this$_unionTypes$get !== void 0 ? _this$_unionTypes$get : new Set();
+    } else {
+      throw createCompilerError('Invalid type supplied to "getPossibleTypeSet"');
     }
 
-    return true;
+    if (!set) {
+      throw createCompilerError("Unable to find possible types for ".concat(type.name));
+    }
+
+    return set;
   };
 
-  _proto4.isServerDirective = function isServerDirective(directiveName) {
-    var directive = this._directivesMap.get(directiveName);
+  _proto5.getFetchableFieldName = function getFetchableFieldName(type) {
+    var _this$_fetchable$get$, _this$_fetchable$get;
 
-    return (directive === null || directive === void 0 ? void 0 : directive.clientOnlyDirective) === false;
+    return (_this$_fetchable$get$ = (_this$_fetchable$get = this._fetchable.get(type)) === null || _this$_fetchable$get === void 0 ? void 0 : _this$_fetchable$get.field_name) !== null && _this$_fetchable$get$ !== void 0 ? _this$_fetchable$get$ : null;
   };
 
-  _proto4.isServerDefinedField = function isServerDefinedField(type, field) {
-    return this.isAbstractType(type) && field.directives.some(function (_ref2) {
-      var name = _ref2.name;
-      return name === 'fixme_fat_interface';
-    }) || this.hasField(type, field.name) && this.isServerField(this.expectField(type, field.name));
+  _proto5.getQueryType = function getQueryType() {
+    return this._types.get(this._queryTypeName);
   };
 
-  _proto4.isClientDefinedField = function isClientDefinedField(type, field) {
-    return !this.isServerDefinedField(type, field);
-  }
-  /**
-   * The only consumer of this is RelayParser.parse(...)
-   * We should either refactor RelayParser.parse(...) to not-rely on the `
-   * extendSchema` method. Or actually implement it here.
-   */
-  ;
+  _proto5.getMutationType = function getMutationType() {
+    return this._types.get(this._mutationTypeName);
+  };
 
-  _proto4.DEPRECATED__extend = function DEPRECATED__extend(document) {
-    var extendedSchema = extendSchema(this._extendedSchema, document, {
-      assumeValid: true
-    });
-    return new Schema(this._baseSchema, extendedSchema, this._typeMap, this._fieldsMap, this._typeNameMap, this._clientIdMap, this._possibleTypesMap, this._directivesMap, this.QUERY_TYPE_KEY, this.MUTATION_TYPE_KEY, this.SUBSCRIPTION_TYPE_KEY);
+  _proto5.getSubscriptionType = function getSubscriptionType() {
+    return this._types.get(this._subscriptionTypeName);
   };
 
-  return Schema;
-}();
+  _proto5.getField = function getField(type, fieldName) {
+    var fields = this._fields.get(type);
+
+    if (fields) {
+      return fields.get(fieldName);
+    }
+  };
 
-var localGraphQLSchemaCache = new Map();
+  _proto5.getFieldMap = function getFieldMap(type) {
+    return this._fields.get(type);
+  };
 
-function DEPRECATED__buildGraphQLSchema(source) {
-  var schema = localGraphQLSchemaCache.get(source);
+  _proto5.getInputField = function getInputField(type, fieldName) {
+    var inputFields = this._inputFields.get(type);
 
-  if (schema != null) {
-    return schema;
-  }
+    if (inputFields) {
+      return inputFields.get(fieldName);
+    }
+  };
+
+  _proto5.getInputFieldMap = function getInputFieldMap(type) {
+    return this._inputFields.get(type);
+  };
+
+  _proto5.getDirectives = function getDirectives() {
+    return Array.from(this._directives.values());
+  };
+
+  _proto5.extend = function extend(extensions) {
+    return new TypeMap(this._source, this._extensions.concat(extensions));
+  };
 
-  try {
-    schema = buildASTSchema(parse(source), {
-      assumeValid: true
+  return TypeMap;
+}();
+
+function create(baseSchema, schemaExtensionDocuments, schemaExtensions) {
+  var extensions = [];
+  schemaExtensions && schemaExtensions.forEach(function (source) {
+    var doc = parse(source, {
+      noLocation: true
     });
-    localGraphQLSchemaCache.set(source, schema);
-    return schema;
-  } catch (error) {
-    throw Object.assign(error, {
-      message: "Caught an error \"".concat(error.message, "\" while loading and parsing schema file: ").concat(source.name, ". Please make sure that schema is valid.")
+    doc.definitions.forEach(function (definition) {
+      if (isSchemaDefinitionAST(definition)) {
+        extensions.push(definition);
+      }
     });
-  }
+  });
+  schemaExtensionDocuments && schemaExtensionDocuments.forEach(function (doc) {
+    doc.definitions.forEach(function (definition) {
+      if (isSchemaDefinitionAST(definition)) {
+        extensions.push(definition);
+      }
+    });
+  });
+  return new Schema(new TypeMap(baseSchema, extensions));
 }
-/**
- * We need this in order to make unit-test works
- * In most of the unit-tests the schema is created from the instance of the
- * GraphQLSchema.
- */
 
+function parseInputArgumentDefinitions(schema, args) {
+  return args.map(function (arg) {
+    var argType = schema.assertInputType(schema.expectTypeFromAST(arg.typeNode));
+    var defaultValue;
+    var defaultValueNode = arg.defaultValue;
+
+    if (defaultValueNode != null) {
+      var nullableType = schema.getNullableType(argType);
+      var isNullable = schema.isNonNull(argType) === false;
+
+      if (isNullable && defaultValueNode.kind === 'NullValue') {
+        defaultValue = null;
+      } else {
+        if (nullableType instanceof ScalarType || nullableType instanceof EnumType) {
+          defaultValue = schema.parseLiteral(nullableType, defaultValueNode);
+        } else if (nullableType instanceof List && defaultValueNode.kind === 'ListValue' || nullableType instanceof InputObjectType && defaultValueNode.kind === 'ObjectValue') {
+          defaultValue = valueFromASTUntyped(defaultValueNode);
+        }
+      }
 
-function DEPRECATED__create(baseSchema, extendedSchema) {
-  var _extendedSchema;
+      if (defaultValue === undefined) {
+        throw createCompilerError("parseInputArgumentDefinitions: Unexpected default value: ".concat(String(defaultValueNode), ". Expected to have a value of type ").concat(String(nullableType), "."));
+      }
+    }
 
-  return new Schema(baseSchema, (_extendedSchema = extendedSchema) !== null && _extendedSchema !== void 0 ? _extendedSchema : baseSchema, new Map(), new Map(), new Map(), new Map(), new Map(), null, Symbol('Query'), Symbol('Mutation'), Symbol('Subsription'));
+    return {
+      name: arg.name,
+      type: argType,
+      defaultValue: defaultValue
+    };
+  });
 }
 
-function create(baseSchema, schemaExtensionDocuments, schemaExtensions) {
-  var _schemaExtensions, _schemaExtensionDocum;
+function parseInputArgumentDefinitionsMap(schema, args) {
+  return new Map(parseInputArgumentDefinitions(schema, args).map(function (arg) {
+    return [arg.name, arg];
+  }));
+}
 
-  var schema = DEPRECATED__buildGraphQLSchema(baseSchema);
-  var transformedSchema = ASTConvert.transformASTSchema(schema, (_schemaExtensions = schemaExtensions) !== null && _schemaExtensions !== void 0 ? _schemaExtensions : []);
-  var extendedSchema = ASTConvert.extendASTSchema(transformedSchema, (_schemaExtensionDocum = schemaExtensionDocuments) !== null && _schemaExtensionDocum !== void 0 ? _schemaExtensionDocum : []);
-  return new Schema(schema, extendedSchema, new Map(), new Map(), new Map(), new Map(), new Map(), null, Symbol('Query'), Symbol('Mutation'), Symbol('Subsription'));
+function isDefaultScalar(name) {
+  return new Set(['ID', 'String', 'Boolean', 'Int', 'Float']).has(name);
 }
 
 module.exports = {
-  DEPRECATED__buildGraphQLSchema: DEPRECATED__buildGraphQLSchema,
-  DEPRECATED__create: DEPRECATED__create,
   create: create
 };