relay-compiler 8.0.0 → 10.0.1

package/core/Schema.js.flow

@@ -0,0 +1,1983 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ * @emails oncall+relay
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const {createCompilerError} = require('./CompilerError');
+const {isSchemaDefinitionAST} = require('./SchemaUtils');
+const {
+  GraphQLFloat,
+  GraphQLInt,
+  GraphQLBoolean,
+  GraphQLString,
+  GraphQLID,
+  parse,
+  parseType,
+  print,
+  valueFromASTUntyped,
+} = require('graphql');
+
+import type {Field as IRField} from './IR';
+import type {
+  DirectiveLocationEnum,
+  DocumentNode,
+  Source,
+  TypeNode,
+  ValueNode,
+  ObjectTypeDefinitionNode,
+  InterfaceTypeDefinitionNode,
+  InputObjectTypeDefinitionNode,
+  SchemaDefinitionNode,
+  ScalarTypeDefinitionNode,
+  EnumTypeDefinitionNode,
+  UnionTypeDefinitionNode,
+  DirectiveDefinitionNode,
+  TypeSystemDefinitionNode,
+  TypeSystemExtensionNode,
+  ObjectTypeExtensionNode,
+  InterfaceTypeExtensionNode,
+  FieldDefinitionNode,
+} from 'graphql';
+
+type ExtensionNode =
+  | TypeSystemDefinitionNode
+  | TypeSystemExtensionNode
+  | DirectiveDefinitionNode;
+
+export opaque type TypeID = BaseType | BaseList | BaseNonNull;
+
+type BaseType =
+  | ScalarType
+  | EnumType
+  | UnionType
+  | ObjectType
+  | InputObjectType
+  | InterfaceType;
+
+type BaseList = List<TypeID>;
+type BaseNonNull = NonNull<BaseType | BaseList>;
+
+export opaque type ScalarTypeID: ScalarFieldTypeID = ScalarType;
+export opaque type EnumTypeID: ScalarFieldTypeID = EnumType;
+export opaque type UnionTypeID: CompositeTypeID = UnionType;
+export opaque type InterfaceTypeID: CompositeTypeID = InterfaceType;
+export opaque type ObjectTypeID: CompositeTypeID = ObjectType;
+export opaque type InputObjectTypeID: TypeID = InputObjectType;
+export opaque type CompositeTypeID: LinkedFieldTypeID = CompositeType;
+export opaque type AbstractTypeID: CompositeTypeID = UnionType | InterfaceType;
+
+export opaque type ScalarFieldTypeID: TypeID =
+  | ScalarFieldBaseType
+  | ScalarFieldList
+  | ScalarFieldNonNull;
+
+export opaque type LinkedFieldTypeID: TypeID =
+  | LinkedFieldBaseType
+  | LinkedFieldList
+  | LinkedFieldNonNull;
+
+export opaque type InputTypeID: TypeID =
+  | InputBaseType
+  | InputTypeList
+  | InputTypeNonNull;
+
+type ScalarFieldBaseType = ScalarType | EnumType;
+type ScalarFieldList = List<ScalarFieldTypeID>;
+type ScalarFieldNonNull = NonNull<ScalarFieldBaseType | ScalarFieldList>;
+
+type CompositeType = ObjectType | InterfaceType | UnionType;
+type LinkedFieldBaseType = CompositeType;
+type LinkedFieldList = List<LinkedFieldTypeID>;
+type LinkedFieldNonNull = NonNull<LinkedFieldBaseType | LinkedFieldList>;
+
+type InputBaseType = InputObjectType | ScalarType | EnumType;
+type InputTypeList = List<InputTypeID>;
+type InputTypeNonNull = NonNull<InputBaseType | InputTypeList>;
+
+type Fetchable = $ReadOnly<{|
+  field_name: string,
+|}>;
+
+export opaque type FieldID = Field;
+
+export type Argument = $ReadOnly<{|
+  name: string,
+  type: InputTypeID,
+  defaultValue: mixed,
+|}>;
+
+export type Directive = $ReadOnly<{|
+  args: $ReadOnlyArray<Argument>,
+  isClient: boolean,
+  locations: $ReadOnlyArray<DirectiveLocationEnum>,
+  name: string,
+|}>;
+
+type DirectiveMap = Map<string, Directive>;
+
+type InternalArgumentStruct = $ReadOnly<{|
+  name: string,
+  typeNode: TypeNode,
+  defaultValue: ?ValueNode,
+|}>;
+
+type FieldDefinition = {|
+  +arguments: $ReadOnlyArray<InternalArgumentStruct>,
+  +type: TypeNode,
+  +isClient: boolean,
+|};
+
+type InternalDirectiveMap = Map<string, InternalDirectiveStruct>;
+
+type InternalDirectiveStruct = $ReadOnly<{|
+  name: string,
+  isClient: boolean,
+  locations: $ReadOnlyArray<DirectiveLocationEnum>,
+  args: $ReadOnlyArray<InternalArgumentStruct>,
+|}>;
+
+export type {Schema};
+
+type FieldsMap = Map<string, Field>;
+type TypeMapKey = string | symbol;
+
+/**
+ * @private
+ */
+class Type {
+  +name: string;
+  +isClient: boolean;
+  constructor(name: string, isClient: boolean) {
+    this.name = name;
+    this.isClient = isClient;
+  }
+  toString(): string {
+    return this.name;
+  }
+  toJSON(): string {
+    return String(this);
+  }
+}
+
+/**
+ * @private
+ */
+class ScalarType extends Type {}
+
+/**
+ * @private
+ */
+class EnumType extends Type {
+  +values: $ReadOnlyArray<string>;
+  constructor(name: string, values: $ReadOnlyArray<string>, isClient: boolean) {
+    super(name, isClient);
+    this.values = values;
+  }
+}
+
+/**
+ * @private
+ */
+class UnionType extends Type {}
+
+/**
+ * @private
+ */
+class ObjectType extends Type {}
+/**
+ * @private
+ */
+class InputObjectType extends Type {}
+
+/**
+ * @private
+ */
+class InterfaceType extends Type {}
+
+/**
+ * @private
+ */
+class List<+T> {
+  +ofType: T;
+  +_typeString: string;
+
+  constructor(type: T) {
+    this.ofType = type;
+    this._typeString = `[${String(this.ofType)}]`;
+  }
+
+  toString(): string {
+    return this._typeString;
+  }
+
+  toJSON(): string {
+    return this.toString();
+  }
+}
+
+/**
+ * @private
+ */
+class NonNull<+T> {
+  +ofType: T;
+  +_typeString: string;
+
+  constructor(type: T) {
+    this.ofType = type;
+    this._typeString = `${String(this.ofType)}!`;
+  }
+
+  toString(): string {
+    return this._typeString;
+  }
+
+  toJSON(): string {
+    return this.toString();
+  }
+}
+
+/**
+ * @private
+ */
+class Field {
+  +args: $ReadOnlyMap<string, Argument>;
+  +belongsTo: CompositeType | InputObjectType;
+  +name: string;
+  +type: TypeID;
+  +isClient: boolean;
+
+  constructor(
+    schema: Schema,
+    name: string,
+    type: TypeID,
+    belongsTo: CompositeType | InputObjectType,
+    args: $ReadOnlyArray<InternalArgumentStruct>,
+    isClient: boolean,
+  ) {
+    this.name = name;
+    this.type = type;
+    this.belongsTo = belongsTo;
+    this.isClient = isClient;
+    this.args = parseInputArgumentDefinitionsMap(schema, args);
+  }
+}
+
+/**
+ * @private
+ */
+function unwrap(type: TypeID): BaseType {
+  if (type instanceof NonNull || type instanceof List) {
+    return unwrap(type.ofType);
+  }
+  return type;
+}
+
+/**
+ * @private
+ */
+function hasConcreteTypeThatImplements(
+  schema: Schema,
+  type: TypeID,
+  interfaceType: InterfaceTypeID,
+): boolean {
+  return (
+    isAbstractType(type) &&
+    getConcreteTypes(schema, type).some(concreteType =>
+      schema.implementsInterface(
+        schema.assertCompositeType(concreteType),
+        interfaceType,
+      ),
+    )
+  );
+}
+
+/**
+ * @private
+ */
+function getConcreteTypes(
+  schema: Schema,
+  type: AbstractTypeID,
+): $ReadOnlyArray<ObjectTypeID> {
+  const concreteTypes = new Set();
+  schema.getPossibleTypes(type).forEach(possibleType => {
+    if (isObject(possibleType)) {
+      concreteTypes.add(possibleType);
+    }
+  });
+  return Array.from(concreteTypes);
+}
+
+const TYPENAME_FIELD = '__typename';
+const CLIENT_ID_FIELD = '__id';
+const QUERY_TYPE_KEY = Symbol('Query');
+const MUTATION_TYPE_KEY = Symbol('Mutation');
+const SUBSCRIPTION_TYPE_KEY = Symbol('Subscription');
+
+function isScalar(type: mixed): boolean %checks {
+  return type instanceof ScalarType;
+}
+
+function isObject(type: mixed): boolean %checks {
+  return type instanceof ObjectType;
+}
+
+function isEnum(type: mixed): boolean %checks {
+  return type instanceof EnumType;
+}
+
+function isUnion(type: mixed): boolean %checks {
+  return type instanceof UnionType;
+}
+
+function isInputObject(type: mixed): boolean %checks {
+  return type instanceof InputObjectType;
+}
+
+function isInterface(type: mixed): boolean %checks {
+  return type instanceof InterfaceType;
+}
+
+function isWrapper(type: mixed): boolean %checks {
+  return type instanceof List || type instanceof NonNull;
+}
+
+function isBaseType(type: mixed): boolean %checks {
+  return (
+    type instanceof ScalarType ||
+    type instanceof ObjectType ||
+    type instanceof EnumType ||
+    type instanceof UnionType ||
+    type instanceof InputObjectType ||
+    type instanceof InterfaceType
+  );
+}
+
+function isAbstractType(type: mixed): boolean %checks {
+  return type instanceof UnionType || type instanceof InterfaceType;
+}
+
+function isCompositeType(type: mixed): boolean %checks {
+  return (
+    type instanceof ObjectType ||
+    type instanceof UnionType ||
+    type instanceof InterfaceType
+  );
+}
+
+function isInputType(type: mixed): boolean %checks {
+  return (
+    type instanceof InputObjectType ||
+    type instanceof ScalarType ||
+    type instanceof EnumType
+  );
+}
+
+class Schema {
+  +_typeMap: TypeMap;
+  +_directiveMap: DirectiveMap;
+  +_fieldsMap: Map<Type, FieldsMap>;
+  +_typeWrappersMap: Map<TypeMapKey, TypeID>;
+  +_typeNameMap: Map<Type, Field>;
+  +_clientIdMap: Map<Type, Field>;
+
+  /**
+   * @private
+   */
+  constructor(typeMap: TypeMap) {
+    this._typeMap = typeMap;
+    this._typeWrappersMap = new Map();
+    this._fieldsMap = new Map();
+    this._typeNameMap = new Map();
+    this._clientIdMap = new Map();
+    this._directiveMap = new Map(
+      typeMap.getDirectives().map(directive => {
+        return [
+          directive.name,
+          {
+            locations: directive.locations,
+            args: parseInputArgumentDefinitions(this, directive.args),
+            name: directive.name,
+            isClient: directive.isClient,
+          },
+        ];
+      }),
+    );
+  }
+
+  getTypes(): $ReadOnlyArray<TypeID> {
+    return this._typeMap.getTypes();
+  }
+
+  getTypeFromAST(typeNode: TypeNode): ?TypeID {
+    if (typeNode.kind === 'NonNullType') {
+      const innerType = this.getTypeFromAST(typeNode.type);
+      if (!innerType) {
+        return;
+      }
+      if (innerType instanceof NonNull) {
+        throw createCompilerError(
+          'Unable to wrap non-nullable type with non-null wrapper.',
+        );
+      }
+      const cacheKey = `${this.getTypeString(innerType)}!`;
+      let type = this._typeWrappersMap.get(cacheKey);
+      if (type) {
+        return type;
+      }
+      type = new NonNull(innerType);
+      this._typeWrappersMap.set(cacheKey, type);
+      return type;
+    } else if (typeNode.kind === 'ListType') {
+      const innerType = this.getTypeFromAST(typeNode.type);
+      if (!innerType) {
+        return;
+      }
+      const cacheKey = `[${this.getTypeString(innerType)}]`;
+      let type = this._typeWrappersMap.get(cacheKey);
+      if (type) {
+        return type;
+      }
+      type = new List(innerType);
+      this._typeWrappersMap.set(cacheKey, type);
+      return type;
+    }
+    return this._typeMap.getTypeByName(typeNode.name.value);
+  }
+
+  _getRawType(typeName: TypeMapKey): ?TypeID {
+    const type = this._typeWrappersMap.get(typeName);
+    if (type) {
+      return type;
+    }
+    if (typeof typeName === 'string') {
+      return this.getTypeFromAST(parseType(typeName));
+    } else {
+      let 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 (operationType instanceof ObjectType) {
+        return operationType;
+      }
+    }
+  }
+
+  getTypeFromString(typeName: string): ?TypeID {
+    return this._getRawType(typeName);
+  }
+
+  expectTypeFromString(typeName: string): TypeID {
+    const type = this.getTypeFromString(typeName);
+    if (type == null) {
+      throw createCompilerError(`Unknown type: '${typeName}'.`);
+    }
+    return type;
+  }
+
+  expectTypeFromAST(ast: TypeNode): TypeID {
+    const type = this.getTypeFromAST(ast);
+    if (type == null) {
+      throw createCompilerError(`Unknown type: '${print(ast)}'.`, null, [ast]);
+    }
+    return type;
+  }
+
+  getNonNullType(type: TypeID): TypeID {
+    if (type instanceof NonNull) {
+      return type;
+    }
+    const cacheKey = `${String(type)}!`;
+    let nonNullType = this._typeWrappersMap.get(cacheKey);
+    if (nonNullType) {
+      return nonNullType;
+    }
+    nonNullType = new NonNull(type);
+    this._typeWrappersMap.set(cacheKey, nonNullType);
+    return nonNullType;
+  }
+
+  getRawType(type: TypeID): TypeID {
+    return unwrap(type);
+  }
+
+  getNullableType(type: TypeID): TypeID {
+    if (type instanceof NonNull) {
+      return type.ofType;
+    }
+    return type;
+  }
+
+  getListItemType(type: TypeID): TypeID {
+    if (type instanceof List) {
+      return type.ofType;
+    }
+    return type;
+  }
+
+  areEqualTypes(typeA: TypeID, typeB: TypeID): boolean {
+    if (typeA === typeB) {
+      return true;
+    }
+    if (typeA instanceof NonNull && typeB instanceof NonNull) {
+      return this.areEqualTypes(typeA.ofType, typeB.ofType);
+    }
+    if (typeA instanceof List && typeB instanceof List) {
+      return this.areEqualTypes(typeA.ofType, typeB.ofType);
+    }
+    if (isBaseType(typeA) && isBaseType(typeB)) {
+      return typeA.name === typeB.name;
+    }
+    return false;
+  }
+
+  /**
+   * Determine if the given type may implement the named type:
+   * - it is the named type
+   * - it implements the named interface
+   * - it is an abstract type and *some* of its concrete types may
+   *   implement the named type
+   */
+  mayImplement(type: CompositeTypeID, interfaceType: InterfaceTypeID): boolean {
+    return (
+      this.areEqualTypes(type, interfaceType) ||
+      this.implementsInterface(type, interfaceType) ||
+      (this.isAbstractType(type) &&
+        hasConcreteTypeThatImplements(this, type, interfaceType))
+    );
+  }
+
+  implementsInterface(
+    type: CompositeTypeID,
+    interfaceType: InterfaceTypeID,
+  ): boolean {
+    return this.getInterfaces(type).some(typeInterface =>
+      this.areEqualTypes(typeInterface, interfaceType),
+    );
+  }
+
+  canHaveSelections(type: TypeID): boolean {
+    return this.isObject(type) || this.isInterface(type);
+  }
+
+  getTypeString(type: TypeID): string {
+    return type.toString();
+  }
+
+  isTypeSubTypeOf(maybeSubType: TypeID, superType: TypeID): boolean {
+    // Equivalent type is a valid subtype
+    if (maybeSubType === superType) {
+      return true;
+    }
+
+    // If superType is non-null, maybeSubType must also be non-null.
+    if (superType instanceof NonNull) {
+      if (maybeSubType instanceof NonNull) {
+        return this.isTypeSubTypeOf(maybeSubType.ofType, superType.ofType);
+      }
+      return false;
+    }
+    if (maybeSubType instanceof NonNull) {
+      // If superType is nullable, maybeSubType may be non-null or nullable.
+      return this.isTypeSubTypeOf(maybeSubType.ofType, superType);
+    }
+
+    // If superType type is a list, maybeSubType type must also be a list.
+    if (superType instanceof List) {
+      if (maybeSubType instanceof List) {
+        return this.isTypeSubTypeOf(maybeSubType.ofType, superType.ofType);
+      }
+      return false;
+    }
+    if (maybeSubType instanceof List) {
+      // If superType is not a list, maybeSubType must also be not a list.
+      return false;
+    }
+
+    // If superType type is an abstract type, maybeSubType type may be a currently
+    // possible object type.
+    if (
+      this.isAbstractType(superType) &&
+      this.isObject(maybeSubType) &&
+      this.isPossibleType(
+        this.assertAbstractType(superType),
+        this.assertObjectType(maybeSubType),
+      )
+    ) {
+      return true;
+    }
+
+    // Otherwise, maybeSubType is not a valid subtype of the superType.
+    return false;
+  }
+
+  /**
+   * Provided two composite types, determine if they "overlap". Two composite
+   * types overlap when the Sets of possible concrete types for each intersect.
+   *
+   * This is often used to determine if a fragment of a given type could possibly
+   * be visited in a context of another type.
+   *
+   * This function is commutative.
+   */
+  doTypesOverlap(typeA: CompositeTypeID, typeB: CompositeTypeID): boolean {
+    // Equivalent types overlap
+    if (typeA === typeB) {
+      return true;
+    }
+
+    if (isAbstractType(typeA)) {
+      if (isAbstractType(typeB)) {
+        // If both types are abstract, then determine if there is any intersection
+        // between possible concrete types of each.
+        return Array.from(this.getPossibleTypes(typeA)).some(type => {
+          if (isObject(type)) {
+            return this.isPossibleType(typeB, type);
+          }
+        });
+      }
+      // Determine if the latter type is a possible concrete type of the former.
+      return this.isPossibleType(typeA, typeB);
+    }
+
+    if (isAbstractType(typeB)) {
+      // Determine if the former type is a possible concrete type of the latter.
+      return this.isPossibleType(typeB, typeA);
+    }
+
+    // Otherwise the types do not overlap.
+    return false;
+  }
+
+  isPossibleType(
+    superType: AbstractTypeID,
+    maybeSubType: ObjectTypeID,
+  ): boolean {
+    return this._typeMap.getPossibleTypeSet(superType).has(maybeSubType);
+  }
+
+  assertScalarFieldType(type: mixed): ScalarFieldTypeID {
+    // Scalar type fields can be wrappers / or can be scalars/enums
+    if (
+      (isWrapper(type) && !isScalar(unwrap(type)) && !isEnum(unwrap(type))) ||
+      (!isWrapper(type) && !isScalar(type) && !isEnum(type))
+    ) {
+      throw createCompilerError(
+        `Expected ${String(type)} to be a Scalar or Enum type.`,
+      );
+    }
+    return type;
+  }
+
+  assertLinkedFieldType(type: mixed): LinkedFieldTypeID {
+    // Linked Field types can be wrappers / or can be composite types
+    if (
+      (isWrapper(type) && !isCompositeType(unwrap(type))) ||
+      (!isWrapper(type) && !isCompositeType(type))
+    ) {
+      throw createCompilerError(
+        `Expected ${String(type)} to be a Object, Interface or a Union Type.`,
+      );
+    }
+    return type;
+  }
+
+  assertInputType(type: mixed): InputTypeID {
+    // Input type fields can be wrappers / or can be scalars/enums
+    if (
+      (isWrapper(type) && !isInputType(unwrap(type))) ||
+      (!isWrapper(type) && !isInputType(type))
+    ) {
+      throw createCompilerError(
+        `Expected ${String(type)} to be a Input, Scalar or Enum type.`,
+      );
+    }
+    return type;
+  }
+
+  asCompositeType(type: mixed): ?CompositeTypeID {
+    if (isCompositeType(type)) {
+      return type;
+    }
+  }
+
+  asInputType(type: mixed): ?InputTypeID {
+    if (
+      (isWrapper(type) && isInputType(unwrap(type))) ||
+      (!isWrapper(type) && isInputType(type))
+    ) {
+      return type;
+    }
+  }
+
+  asScalarFieldType(type: mixed): ?ScalarFieldTypeID {
+    if (isScalar(type) || isEnum(type)) {
+      return type;
+    }
+  }
+
+  assertScalarType(type: TypeID): ScalarTypeID {
+    if (!isScalar(type)) {
+      throw createCompilerError(
+        `Expected ${this.getTypeString(
+          type,
+        )} to be a scalar type, got ${this.getTypeString(type)}.`,
+      );
+    }
+    return type;
+  }
+
+  assertObjectType(type: TypeID): ObjectTypeID {
+    if (!isObject(type)) {
+      throw createCompilerError(
+        `Expected ${this.getTypeString(type)} to be an object type.`,
+      );
+    }
+    return type;
+  }
+
+  assertInputObjectType(type: TypeID): InputObjectTypeID {
+    if (!isInputObject(type)) {
+      throw createCompilerError(
+        `Expected ${this.getTypeString(type)} to be an input type.`,
+      );
+    }
+    return type;
+  }
+
+  assertInterfaceType(type: TypeID): InterfaceTypeID {
+    if (!isInterface(type)) {
+      throw createCompilerError(
+        `Expected ${this.getTypeString(type)} to be an interface type.`,
+      );
+    }
+    return type;
+  }
+
+  assertCompositeType(type: TypeID): CompositeTypeID {
+    if (!isCompositeType(type)) {
+      throw createCompilerError(
+        `Expected ${this.getTypeString(type)} to be a composite type.`,
+      );
+    }
+    return type;
+  }
+
+  assertAbstractType(type: TypeID): AbstractTypeID {
+    if (!isAbstractType(type)) {
+      throw createCompilerError(
+        `Expected ${this.getTypeString(type)} to be an abstract type.`,
+      );
+    }
+    return type;
+  }
+
+  assertLeafType(type: TypeID): TypeID {
+    if (!this.isLeafType(type)) {
+      throw createCompilerError(
+        `Expected ${this.getTypeString(type)} to be a leaf type.`,
+      );
+    }
+    return type;
+  }
+
+  assertUnionType(type: TypeID): UnionTypeID {
+    if (!isUnion(type)) {
+      throw createCompilerError(
+        `Expected ${this.getTypeString(type)} to be a union type.`,
+      );
+    }
+    return type;
+  }
+
+  assertEnumType(type: TypeID): EnumTypeID {
+    if (!isEnum(type)) {
+      throw createCompilerError(`Expected ${String(type)} to be an enum type.`);
+    }
+    return type;
+  }
+
+  assertIntType(type: TypeID): ScalarTypeID {
+    if (!isScalar(type) || !this.isInt(type)) {
+      throw createCompilerError(
+        `Expected ${String(type)} to be an 'Int' type.`,
+      );
+    }
+    return type;
+  }
+
+  assertFloatType(type: TypeID): ScalarTypeID {
+    if (!isScalar(type) || !this.isFloat(type)) {
+      throw createCompilerError(
+        `Expected ${this.getTypeString(type)} to be a 'Float' type.`,
+      );
+    }
+    return type;
+  }
+
+  assertBooleanType(type: TypeID): ScalarTypeID {
+    if (!isScalar(type) || !this.isBoolean(type)) {
+      throw createCompilerError(
+        `Expected ${this.getTypeString(type)} to be a 'Boolean' type.`,
+      );
+    }
+    return type;
+  }
+
+  assertStringType(type: TypeID): ScalarTypeID {
+    if (!isScalar(type) || !this.isString(type)) {
+      throw createCompilerError(
+        `Expected ${this.getTypeString(type)} to be a 'String' type.`,
+      );
+    }
+    return type;
+  }
+
+  assertIdType(type: TypeID): ScalarTypeID {
+    if (!isScalar(type) || !this.isId(type)) {
+      throw createCompilerError(
+        `Expected ${this.getTypeString(type)} to be an ID type.`,
+      );
+    }
+    return type;
+  }
+
+  expectBooleanType(): ScalarTypeID {
+    return this.assertScalarType(this.expectTypeFromString('Boolean'));
+  }
+
+  expectIntType(): ScalarTypeID {
+    return this.assertScalarType(this.expectTypeFromString('Int'));
+  }
+
+  expectFloatType(): ScalarTypeID {
+    return this.assertScalarType(this.expectTypeFromString('Float'));
+  }
+
+  expectStringType(): ScalarTypeID {
+    return this.assertScalarType(this.expectTypeFromString('String'));
+  }
+
+  expectIdType(): ScalarTypeID {
+    return this.assertScalarType(this.expectTypeFromString('ID'));
+  }
+
+  getQueryType(): ?ObjectTypeID {
+    const queryType = this._getRawType(QUERY_TYPE_KEY);
+    if (queryType && isObject(queryType)) {
+      return queryType;
+    }
+  }
+
+  getMutationType(): ?ObjectTypeID {
+    const mutationType = this._getRawType(MUTATION_TYPE_KEY);
+    if (mutationType && isObject(mutationType)) {
+      return mutationType;
+    }
+  }
+
+  getSubscriptionType(): ?ObjectTypeID {
+    const subscriptionType = this._getRawType(SUBSCRIPTION_TYPE_KEY);
+    if (subscriptionType && isObject(subscriptionType)) {
+      return subscriptionType;
+    }
+  }
+
+  expectQueryType(): ObjectTypeID {
+    const queryType = this.getQueryType();
+    if (queryType == null) {
+      throw createCompilerError('Query type is not defined on the Schema');
+    }
+    return queryType;
+  }
+
+  expectMutationType(): ObjectTypeID {
+    const mutationType = this.getMutationType();
+    if (mutationType == null) {
+      throw createCompilerError('Mutation type is not defined the Schema');
+    }
+    return mutationType;
+  }
+
+  expectSubscriptionType(): ObjectTypeID {
+    const subscriptionType = this.getSubscriptionType();
+    if (subscriptionType == null) {
+      throw createCompilerError('Subscription type is not defined the Schema');
+    }
+    return subscriptionType;
+  }
+
+  isNonNull(type: TypeID): boolean {
+    return type instanceof NonNull;
+  }
+
+  isList(type: TypeID): boolean {
+    return type instanceof List;
+  }
+
+  isWrapper(type: TypeID): boolean {
+    return isWrapper(type);
+  }
+
+  isScalar(type: TypeID): boolean {
+    return isScalar(type);
+  }
+
+  isObject(type: TypeID): boolean {
+    return isObject(type);
+  }
+
+  isEnum(type: TypeID): boolean {
+    return isEnum(type);
+  }
+
+  isUnion(type: TypeID): boolean {
+    return isUnion(type);
+  }
+
+  isInputObject(type: TypeID): boolean {
+    return isInputObject(type);
+  }
+
+  isInterface(type: TypeID): boolean {
+    return isInterface(type);
+  }
+
+  isInputType(type: TypeID): boolean {
+    // Wrappers can be input types (so it's save to check unwrapped type here)
+    return isInputType(type) || (isWrapper(type) && isInputType(unwrap(type)));
+  }
+
+  isCompositeType(type: TypeID): boolean {
+    return isCompositeType(type);
+  }
+
+  isAbstractType(type: TypeID): boolean {
+    return isAbstractType(type);
+  }
+
+  isLeafType(type: TypeID): boolean {
+    return this.isScalar(type) || this.isEnum(type);
+  }
+
+  isId(type: TypeID): boolean {
+    if (type instanceof ScalarType) {
+      return type.name === 'ID';
+    }
+    return false;
+  }
+
+  isInt(type: TypeID): boolean {
+    if (type instanceof ScalarType) {
+      return type.name === 'Int';
+    }
+    return false;
+  }
+
+  isFloat(type: TypeID): boolean {
+    if (type instanceof ScalarType) {
+      return type.name === 'Float';
+    }
+    return false;
+  }
+
+  isBoolean(type: TypeID): boolean {
+    if (type instanceof ScalarType) {
+      return type.name === 'Boolean';
+    }
+    return false;
+  }
+
+  isString(type: TypeID): boolean {
+    if (type instanceof ScalarType) {
+      return type.name === 'String';
+    }
+    return false;
+  }
+
+  hasField(
+    type: CompositeTypeID | InputObjectTypeID,
+    fieldName: string,
+  ): boolean {
+    const canHaveTypename = this.isObject(type) || this.isAbstractType(type);
+    // Special case for __typename field
+    if (
+      canHaveTypename &&
+      (fieldName === TYPENAME_FIELD || fieldName === CLIENT_ID_FIELD)
+    ) {
+      return true;
+    }
+    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;
+    }
+    return false;
+  }
+
+  hasId(type: CompositeTypeID): boolean {
+    if (!this.hasField(type, 'id')) {
+      return false;
+    }
+    const idField = this.expectField(type, 'id');
+    return this.areEqualTypes(
+      this.getNullableType(this.getFieldType(idField)),
+      this.expectIdType(),
+    );
+  }
+
+  getFields(
+    type: CompositeTypeID | InputObjectTypeID,
+  ): $ReadOnlyArray<FieldID> {
+    const fieldsMap = this._getFieldsMap(type);
+    return Array.from(fieldsMap.values());
+  }
+
+  _getFieldsMap(type: CompositeTypeID | InputObjectTypeID): FieldsMap {
+    const cachedMap = this._fieldsMap.get(type);
+    if (cachedMap != null) {
+      return cachedMap;
+    }
+
+    const fieldsMap = new Map();
+    if (type instanceof ObjectType || type instanceof InterfaceType) {
+      const fields = this._typeMap.getFieldMap(type);
+      if (fields) {
+        for (const [fieldName, fieldDefinition] of fields) {
+          const fieldType = this.expectTypeFromAST(fieldDefinition.type);
+          fieldsMap.set(
+            fieldName,
+            new Field(
+              this,
+              fieldName,
+              fieldType,
+              this.assertCompositeType(type),
+              fieldDefinition.arguments,
+              fieldDefinition.isClient,
+            ),
+          );
+        }
+      }
+    } else if (type instanceof InputObjectType) {
+      const fields = this._typeMap.getInputFieldMap(type);
+      if (fields) {
+        for (const [fieldName, typeNode] of fields) {
+          const fieldType = this.expectTypeFromAST(typeNode);
+          fieldsMap.set(
+            fieldName,
+            new Field(this, fieldName, fieldType, type, [], false),
+          );
+        }
+      }
+    }
+    if (fieldsMap.size === 0) {
+      throw createCompilerError(
+        `_getFieldsMap: Type '${type.name}' should have fields.`,
+      );
+    }
+    this._fieldsMap.set(type, fieldsMap);
+    return fieldsMap;
+  }
+
+  getFieldByName(
+    type: CompositeTypeID | InputObjectTypeID,
+    fieldName: string,
+  ): ?FieldID {
+    if (!this.hasField(type, fieldName)) {
+      return;
+    }
+
+    // A "special" case for __typename and __id fields - which should
+    // not be in the list of type fields, but should be fine to select
+    if (fieldName === TYPENAME_FIELD) {
+      let typename = this._typeNameMap.get(type);
+      if (!typename) {
+        typename = new Field(
+          this,
+          TYPENAME_FIELD,
+          this.getNonNullType(this.expectStringType()),
+          type,
+          [],
+          false, // isClient === false
+        );
+        this._typeNameMap.set(type, typename);
+      }
+      return typename;
+    }
+
+    if (fieldName === CLIENT_ID_FIELD) {
+      let clientId = this._clientIdMap.get(type);
+      if (!clientId) {
+        clientId = new Field(
+          this,
+          CLIENT_ID_FIELD,
+          this.getNonNullType(this.expectIdType()),
+          type,
+          [],
+          true, // isClient === true
+        );
+        this._clientIdMap.set(type, clientId);
+      }
+      return clientId;
+    }
+
+    if (isUnion(type)) {
+      throw createCompilerError(
+        `Unexpected union type '${this.getTypeString(
+          type,
+        )}' in the 'getFieldByName(...)'. Expected type with fields`,
+      );
+    }
+
+    const fieldsMap = this._getFieldsMap(type);
+    return fieldsMap.get(fieldName);
+  }
+
+  expectField(
+    type: CompositeTypeID | InputObjectTypeID,
+    fieldName: string,
+  ): FieldID {
+    const field = this.getFieldByName(type, fieldName);
+    if (!field) {
+      throw createCompilerError(
+        `Unknown field '${fieldName}' on type '${this.getTypeString(type)}'.`,
+      );
+    }
+    return field;
+  }
+
+  getFieldConfig(
+    field: FieldID,
+  ): {|
+    type: TypeID,
+    args: $ReadOnlyArray<Argument>,
+  |} {
+    return {
+      type: field.type,
+      args: Array.from(field.args.values()),
+    };
+  }
+
+  getFieldName(field: FieldID): string {
+    return field.name;
+  }
+
+  getFieldType(field: FieldID): TypeID {
+    return field.type;
+  }
+
+  getFieldParentType(field: FieldID): TypeID {
+    return field.belongsTo;
+  }
+
+  getFieldArgs(field: FieldID): $ReadOnlyArray<Argument> {
+    return Array.from(field.args.values());
+  }
+
+  getFieldArgByName(field: FieldID, argName: string): ?Argument {
+    return field.args.get(argName);
+  }
+
+  getEnumValues(type: EnumTypeID): $ReadOnlyArray<string> {
+    return type.values;
+  }
+
+  getUnionTypes(type: UnionTypeID): $ReadOnlyArray<TypeID> {
+    return Array.from(this._typeMap.getPossibleTypeSet(type));
+  }
+
+  getInterfaces(type: CompositeTypeID): $ReadOnlyArray<TypeID> {
+    if (type instanceof ObjectType) {
+      return this._typeMap.getInterfaces(type);
+    }
+    return [];
+  }
+
+  getPossibleTypes(type: AbstractTypeID): $ReadOnlySet<ObjectTypeID> {
+    return this._typeMap.getPossibleTypeSet(type);
+  }
+
+  getFetchableFieldName(type: ObjectTypeID): ?string {
+    return this._typeMap.getFetchableFieldName(type);
+  }
+
+  parseLiteral(type: ScalarTypeID | EnumTypeID, valueNode: ValueNode): mixed {
+    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);
+      }
+    }
+  }
+
+  parseValue(type: ScalarTypeID | EnumTypeID, value: mixed): mixed {
+    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;
+      }
+    }
+  }
+
+  serialize(type: ScalarTypeID | EnumTypeID, value: mixed): mixed {
+    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);
+        case 'Int':
+          return GraphQLInt.serialize(value);
+        case 'String':
+          return GraphQLString.serialize(value);
+        case 'ID':
+          return GraphQLID.serialize(value);
+        default:
+          return value;
+      }
+    }
+  }
+
+  getDirectives(): $ReadOnlyArray<Directive> {
+    return Array.from(this._directiveMap.values());
+  }
+
+  getDirective(directiveName: string): ?Directive {
+    return this._directiveMap.get(directiveName);
+  }
+
+  isServerType(type: TypeID): boolean {
+    const unwrapped = unwrap(type);
+    return unwrapped.isClient === false;
+  }
+
+  isServerField(field: FieldID): boolean {
+    return field.isClient === false;
+  }
+
+  isServerDirective(directiveName: string): boolean {
+    const directive = this._directiveMap.get(directiveName);
+    return directive?.isClient === false;
+  }
+
+  isServerDefinedField(type: CompositeTypeID, field: IRField): boolean {
+    return (
+      (this.isAbstractType(type) &&
+        field.directives.some(({name}) => name === 'fixme_fat_interface')) ||
+      (this.hasField(type, field.name) &&
+        this.isServerField(this.expectField(type, field.name)))
+    );
+  }
+
+  isClientDefinedField(type: CompositeTypeID, field: IRField): boolean {
+    return !this.isServerDefinedField(type, field);
+  }
+
+  extend(extensions: DocumentNode | $ReadOnlyArray<string>): Schema {
+    const doc = Array.isArray(extensions)
+      ? parse(extensions.join('\n'))
+      : extensions;
+
+    const schemaExtensions = [];
+    doc.definitions.forEach(definition => {
+      if (isSchemaDefinitionAST(definition)) {
+        schemaExtensions.push(definition);
+      }
+    });
+    if (schemaExtensions.length > 0) {
+      return new Schema(this._typeMap.extend(schemaExtensions));
+    }
+    return this;
+  }
+}
+
+class TypeMap {
+  _mutationTypeName: string;
+  _queryTypeName: string;
+  _subscriptionTypeName: string;
+  +_directives: InternalDirectiveMap;
+  +_extensions: $ReadOnlyArray<ExtensionNode>;
+  +_fetchable: Map<TypeID, Fetchable>;
+  +_fields: Map<InterfaceType | ObjectType, Map<string, FieldDefinition>>;
+  +_inputFields: Map<InputObjectType, Map<string, TypeNode>>;
+  +_interfaceImplementations: Map<InterfaceType, Set<ObjectType>>;
+  +_source: Source;
+  +_typeInterfaces: Map<TypeID, $ReadOnlyArray<InterfaceType>>;
+  +_types: Map<string, BaseType>;
+  +_unionTypes: Map<TypeID, Set<ObjectType>>;
+
+  constructor(source: Source, extensions: $ReadOnlyArray<ExtensionNode>) {
+    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);
+  }
+
+  _parse(source: Source) {
+    const document = parse(source, {
+      noLocation: true,
+    });
+    document.definitions.forEach(definition => {
+      switch (definition.kind) {
+        case 'SchemaDefinition': {
+          this._parseSchemaDefinition(definition);
+          break;
+        }
+        case 'ScalarTypeDefinition': {
+          this._parseScalarNode(definition, false);
+          break;
+        }
+        case 'EnumTypeDefinition': {
+          this._parseEnumNode(definition, false);
+          break;
+        }
+        case 'ObjectTypeDefinition': {
+          this._parseObjectTypeNode(definition, false);
+          break;
+        }
+        case 'InputObjectTypeDefinition': {
+          this._parseInputObjectTypeNode(definition, false);
+          break;
+        }
+        case 'UnionTypeDefinition': {
+          this._parseUnionNode(definition, false);
+          break;
+        }
+        case 'InterfaceTypeDefinition': {
+          this._parseInterfaceNode(definition, false);
+          break;
+        }
+        case 'DirectiveDefinition': {
+          this._parseDirective(definition, false);
+          break;
+        }
+      }
+    });
+  }
+
+  _parseSchemaDefinition(node: SchemaDefinitionNode) {
+    node.operationTypes.forEach(operationType => {
+      switch (operationType.operation) {
+        case 'query':
+          this._queryTypeName = operationType.type.name.value;
+          break;
+        case 'mutation':
+          this._mutationTypeName = operationType.type.name.value;
+          break;
+        case 'subscription':
+          this._subscriptionTypeName = operationType.type.name.value;
+          break;
+      }
+    });
+  }
+
+  _parseScalarNode(node: ScalarTypeDefinitionNode, isClient: boolean) {
+    const name = node.name.value;
+    if (!isDefaultScalar(name) && this._types.has(name)) {
+      throw createCompilerError(
+        `_parseScalarNode: Duplicate definition for type ${name}.`,
+        null,
+        [node],
+      );
+    }
+    this._types.set(name, new ScalarType(name, isClient));
+  }
+
+  _parseEnumNode(node: EnumTypeDefinitionNode, isClient: boolean) {
+    const name = node.name.value;
+    if (this._types.has(name)) {
+      throw createCompilerError(
+        `_parseEnumNode: Duplicate definition for type ${name}.`,
+        null,
+        [node],
+      );
+    }
+    // SDL doesn't have information about the actual ENUM values
+    const values = node.values
+      ? node.values.map(value => value.name.value)
+      : [];
+    this._types.set(name, new EnumType(name, values, isClient));
+  }
+
+  _parseObjectTypeNode(node: ObjectTypeDefinitionNode, isClient: boolean) {
+    const name = node.name.value;
+    // Objects may be created by _parseUnionNode
+    const type = this._types.get(name) ?? new ObjectType(name, isClient);
+    if (!(type instanceof ObjectType)) {
+      throw createCompilerError(
+        `_parseObjectTypeNode: Expected object type, got ${String(type)}`,
+        null,
+        [node],
+      );
+    }
+    if (type.isClient !== isClient) {
+      throw createCompilerError(
+        `_parseObjectTypeNode: Cannot create object type '${name}' defined as a client type.`,
+        null,
+        [node],
+      );
+    }
+    const typeInterfaces: Array<InterfaceType> = [];
+    node.interfaces &&
+      node.interfaces.forEach(interfaceTypeNode => {
+        const interfaceName = interfaceTypeNode.name.value;
+        let interfaceType = this._types.get(interfaceName);
+        if (!interfaceType) {
+          interfaceType = new InterfaceType(interfaceName, isClient);
+          this._types.set(interfaceName, interfaceType);
+        }
+        if (!(interfaceType instanceof InterfaceType)) {
+          throw createCompilerError(
+            '_parseObjectTypeNode: Expected interface type',
+            null,
+            [interfaceTypeNode],
+          );
+        }
+        const implementations =
+          this._interfaceImplementations.get(interfaceType) ?? new Set();
+
+        implementations.add(type);
+        this._interfaceImplementations.set(interfaceType, implementations);
+        typeInterfaces.push(interfaceType);
+      });
+    let fetchable = null;
+    node.directives &&
+      node.directives.forEach(directiveNode => {
+        if (directiveNode.name.value === 'fetchable') {
+          const field_name_arg =
+            directiveNode.arguments &&
+            directiveNode.arguments.find(
+              arg => 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);
+  }
+
+  _parseInputObjectTypeNode(
+    node: InputObjectTypeDefinitionNode,
+    isClient: boolean,
+  ) {
+    const name = node.name.value;
+    if (this._types.has(name)) {
+      throw createCompilerError(
+        '_parseInputObjectTypeNode: Unable to parse schema file. Duplicate definition for object type',
+        null,
+        [node],
+      );
+    }
+    const type = new InputObjectType(name, isClient);
+    this._types.set(name, type);
+    this._parseInputObjectFields(type, node);
+  }
+
+  _parseUnionNode(node: UnionTypeDefinitionNode, isClient: boolean) {
+    const name = node.name.value;
+    if (this._types.has(name)) {
+      throw createCompilerError(
+        '_parseUnionNode: Unable to parse schema file. Duplicate definition for object type',
+        null,
+        [node],
+      );
+    }
+    const union = new UnionType(name, isClient);
+    this._types.set(name, union);
+    this._unionTypes.set(
+      union,
+      new Set(
+        node.types
+          ? node.types.map(typeInUnion => {
+              const typeInUnionName = typeInUnion.name.value;
+              const object =
+                this._types.get(typeInUnionName) ??
+                new ObjectType(typeInUnionName, false);
+              if (!(object instanceof ObjectType)) {
+                throw createCompilerError(
+                  '_parseUnionNode: Expected object type',
+                  null,
+                  [typeInUnion],
+                );
+              }
+              this._types.set(typeInUnionName, object);
+              return object;
+            })
+          : [],
+      ),
+    );
+  }
+
+  _parseInterfaceNode(node: InterfaceTypeDefinitionNode, isClient: boolean) {
+    const name = node.name.value;
+    let 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 ${String(type)}`,
+        null,
+        [node],
+      );
+    }
+    if (type.isClient !== isClient) {
+      throw createCompilerError(
+        `_parseInterfaceNode: Cannot create interface '${name}' defined as a client interface`,
+        null,
+        [node],
+      );
+    }
+    node.fields && this._handleTypeFieldsStrict(type, node.fields, isClient);
+  }
+
+  _handleTypeFieldsStrict(
+    type: ObjectType | InterfaceType,
+    fields: $ReadOnlyArray<FieldDefinitionNode>,
+    isClient: boolean,
+  ) {
+    if (this._fields.has(type)) {
+      throw createCompilerError(
+        '_handleTypeFieldsStrict: Unable to parse schema file. Duplicate definition for object type',
+      );
+    }
+    this._handleTypeFields(type, fields, isClient);
+  }
+
+  _handleTypeFields(
+    type: ObjectType | InterfaceType,
+    fields: $ReadOnlyArray<FieldDefinitionNode>,
+    isClient: boolean,
+  ) {
+    const fieldsMap = this._fields.get(type) ?? new Map();
+    fields.forEach(fieldNode => {
+      const fieldName = fieldNode.name.value;
+      if (fieldsMap.has(fieldName)) {
+        throw createCompilerError(
+          `_handleTypeFields: Duplicate definition for field '${fieldName}'.`,
+        );
+      }
+      fieldsMap.set(fieldName, {
+        arguments: fieldNode.arguments
+          ? fieldNode.arguments.map(arg => {
+              return {
+                name: arg.name.value,
+                typeNode: arg.type,
+                defaultValue: arg.defaultValue,
+              };
+            })
+          : [],
+        type: fieldNode.type,
+        isClient: isClient,
+      });
+    });
+    this._fields.set(type, fieldsMap);
+  }
+
+  _parseInputObjectFields(
+    type: InputObjectType,
+    node: InputObjectTypeDefinitionNode,
+  ) {
+    if (this._inputFields.has(type)) {
+      throw createCompilerError(
+        '_parseInputObjectFields: Unable to parse schema file. Duplicate definition for type',
+        null,
+        [node],
+      );
+    }
+    const fields = new Map();
+    if (node.fields) {
+      node.fields.forEach(fieldNode => {
+        fields.set(fieldNode.name.value, fieldNode.type);
+      });
+    }
+    this._inputFields.set(type, fields);
+  }
+
+  _parseDirective(node: DirectiveDefinitionNode, isClient: boolean) {
+    const name = node.name.value;
+    this._directives.set(name, {
+      name,
+      args: node.arguments
+        ? node.arguments.map(arg => {
+            return {
+              name: arg.name.value,
+              typeNode: arg.type,
+              defaultValue: arg.defaultValue,
+            };
+          })
+        : [],
+
+      locations: node.locations.map(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,
+    });
+  }
+
+  _parseObjectTypeExtension(node: ObjectTypeExtensionNode) {
+    const type = this._types.get(node.name.value);
+    if (!(type instanceof ObjectType)) {
+      throw createCompilerError(
+        `_parseObjectTypeExtension: Expected to find type with the name '${node.name.value}'`,
+        null,
+        [node],
+      );
+    }
+    node.fields &&
+      this._handleTypeFields(type, node.fields, true /** client fields */);
+  }
+
+  _parseInterfaceTypeExtension(node: InterfaceTypeExtensionNode) {
+    const 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);
+  }
+
+  _extend(extensions: $ReadOnlyArray<ExtensionNode>) {
+    extensions.forEach(definition => {
+      if (definition.kind === 'ObjectTypeDefinition') {
+        this._parseObjectTypeNode(definition, true);
+      } else if (definition.kind === 'InterfaceTypeDefinition') {
+        this._parseInterfaceNode(definition, true);
+      } else if (definition.kind === 'ScalarTypeDefinition') {
+        this._parseScalarNode(definition, true);
+      } else if (definition.kind === 'EnumTypeDefinition') {
+        this._parseEnumNode(definition, true);
+      } else if (definition.kind === 'InterfaceTypeExtension') {
+        this._parseInterfaceTypeExtension(definition);
+      } else if (definition.kind === 'ObjectTypeExtension') {
+        this._parseObjectTypeExtension(definition);
+      } else if (definition.kind === 'DirectiveDefinition') {
+        this._parseDirective(definition, true /* client directive */);
+      } else {
+        throw createCompilerError(
+          `Unexpected extension kind: '${definition.kind}'`,
+          null,
+          [definition],
+        );
+      }
+    });
+  }
+
+  getTypes(): $ReadOnlyArray<BaseType> {
+    return Array.from(this._types.values());
+  }
+
+  getTypeByName(typename: string): ?BaseType {
+    return this._types.get(typename);
+  }
+
+  getInterfaces(type: ObjectType): $ReadOnlyArray<InterfaceType> {
+    return this._typeInterfaces.get(type) ?? [];
+  }
+
+  getPossibleTypeSet(
+    type: UnionType | InterfaceType,
+  ): $ReadOnlySet<ObjectType> {
+    let set;
+    if (type instanceof InterfaceType) {
+      set = this._interfaceImplementations.get(type) ?? new Set();
+    } else if (type instanceof UnionType) {
+      set = this._unionTypes.get(type) ?? new Set();
+    } else {
+      throw createCompilerError(
+        'Invalid type supplied to "getPossibleTypeSet"',
+      );
+    }
+    if (!set) {
+      throw createCompilerError(
+        `Unable to find possible types for ${type.name}`,
+      );
+    }
+    return set;
+  }
+
+  getFetchableFieldName(type: ObjectTypeID): ?string {
+    return this._fetchable.get(type)?.field_name ?? null;
+  }
+
+  getQueryType(): ?BaseType {
+    return this._types.get(this._queryTypeName);
+  }
+
+  getMutationType(): ?BaseType {
+    return this._types.get(this._mutationTypeName);
+  }
+
+  getSubscriptionType(): ?BaseType {
+    return this._types.get(this._subscriptionTypeName);
+  }
+
+  getField(
+    type: InterfaceType | ObjectType,
+    fieldName: string,
+  ): ?FieldDefinition {
+    const fields = this._fields.get(type);
+    if (fields) {
+      return fields.get(fieldName);
+    }
+  }
+
+  getFieldMap(type: InterfaceType | ObjectType): ?Map<string, FieldDefinition> {
+    return this._fields.get(type);
+  }
+
+  getInputField(type: InputObjectType, fieldName: string): ?TypeNode {
+    const inputFields = this._inputFields.get(type);
+    if (inputFields) {
+      return inputFields.get(fieldName);
+    }
+  }
+
+  getInputFieldMap(type: InputObjectType): ?Map<string, TypeNode> {
+    return this._inputFields.get(type);
+  }
+
+  getDirectives(): $ReadOnlyArray<InternalDirectiveStruct> {
+    return Array.from(this._directives.values());
+  }
+
+  extend(extensions: $ReadOnlyArray<ExtensionNode>): TypeMap {
+    return new TypeMap(this._source, this._extensions.concat(extensions));
+  }
+}
+
+function create(
+  baseSchema: Source,
+  schemaExtensionDocuments?: $ReadOnlyArray<DocumentNode>,
+  schemaExtensions?: $ReadOnlyArray<string>,
+): Schema {
+  const extensions: Array<ExtensionNode> = [];
+  schemaExtensions &&
+    schemaExtensions.forEach(source => {
+      const doc = parse(source, {
+        noLocation: true,
+      });
+      doc.definitions.forEach(definition => {
+        if (isSchemaDefinitionAST(definition)) {
+          extensions.push(definition);
+        }
+      });
+    });
+  schemaExtensionDocuments &&
+    schemaExtensionDocuments.forEach(doc => {
+      doc.definitions.forEach(definition => {
+        if (isSchemaDefinitionAST(definition)) {
+          extensions.push(definition);
+        }
+      });
+    });
+
+  return new Schema(new TypeMap(baseSchema, extensions));
+}
+
+function parseInputArgumentDefinitions(
+  schema: Schema,
+  args: $ReadOnlyArray<InternalArgumentStruct>,
+): $ReadOnlyArray<Argument> {
+  return args.map(arg => {
+    const argType = schema.assertInputType(
+      schema.expectTypeFromAST(arg.typeNode),
+    );
+    let defaultValue;
+    const defaultValueNode = arg.defaultValue;
+    if (defaultValueNode != null) {
+      const nullableType = schema.getNullableType(argType);
+      const 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);
+        }
+      }
+      if (defaultValue === undefined) {
+        throw createCompilerError(
+          `parseInputArgumentDefinitions: Unexpected default value: ${String(
+            defaultValueNode,
+          )}. Expected to have a value of type ${String(nullableType)}.`,
+        );
+      }
+    }
+    return {
+      name: arg.name,
+      type: argType,
+      defaultValue,
+    };
+  });
+}
+
+function parseInputArgumentDefinitionsMap(
+  schema: Schema,
+  args: $ReadOnlyArray<InternalArgumentStruct>,
+): $ReadOnlyMap<string, Argument> {
+  return new Map(
+    parseInputArgumentDefinitions(schema, args).map(arg => {
+      return [arg.name, arg];
+    }),
+  );
+}
+
+function isDefaultScalar(name: string): boolean {
+  return new Set(['ID', 'String', 'Boolean', 'Int', 'Float']).has(name);
+}
+
+module.exports = {
+  create,
+};