@ardatan/relay-compiler 12.0.0

package/lib/core/RelayParser.js

@@ -0,0 +1,1382 @@
+/**
+ * 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.
+ *
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var Profiler = require('./GraphQLCompilerProfiler');
+
+var orList = require('../util/orList');
+
+var partitionArray = require('../util/partitionArray');
+
+var _require = require('../util/DefaultHandleKey'),
+    DEFAULT_HANDLE_KEY = _require.DEFAULT_HANDLE_KEY;
+
+var _require2 = require('./CompilerError'),
+    createCompilerError = _require2.createCompilerError,
+    createUserError = _require2.createUserError,
+    eachWithCombinedError = _require2.eachWithCombinedError;
+
+var _require3 = require('./SchemaUtils'),
+    isExecutableDefinitionAST = _require3.isExecutableDefinitionAST;
+
+var _require4 = require('./getFieldDefinition'),
+    getFieldDefinitionLegacy = _require4.getFieldDefinitionLegacy;
+
+var _require5 = require('graphql'),
+    parseGraphQL = _require5.parse,
+    parseType = _require5.parseType,
+    print = _require5.print,
+    Source = _require5.Source;
+
+var ARGUMENT_DEFINITIONS = 'argumentDefinitions';
+var ARGUMENTS = 'arguments';
+var DEPRECATED_UNCHECKED_ARGUMENTS = 'uncheckedArguments_DEPRECATED';
+var DIRECTIVE_WHITELIST = new Set([ARGUMENT_DEFINITIONS, DEPRECATED_UNCHECKED_ARGUMENTS, ARGUMENTS]);
+/**
+ * @internal
+ *
+ * This directive is not intended for use by developers directly. To set a field
+ * handle in product code use a compiler plugin.
+ */
+
+var CLIENT_FIELD = '__clientField';
+var CLIENT_FIELD_HANDLE = 'handle';
+var CLIENT_FIELD_KEY = 'key';
+var CLIENT_FIELD_FILTERS = 'filters';
+var INCLUDE = 'include';
+var SKIP = 'skip';
+var IF = 'if';
+/**
+ * Transforms GraphQL text into Relay Compiler's internal, strongly-typed
+ * intermediate representation (IR).
+ */
+
+function parse(schema, text, filename) {
+  var ast = parseGraphQL(new Source(text, filename));
+  var parser = new RelayParser(schema.extend(ast), ast.definitions);
+  return parser.transform();
+}
+/**
+ * Transforms untyped GraphQL parse trees (ASTs) into Relay Compiler's
+ * internal, strongly-typed intermediate representation (IR).
+ */
+
+
+function transform(schema, definitions) {
+  return Profiler.run('RelayParser.transform', function () {
+    var parser = new RelayParser(schema, definitions);
+    return parser.transform();
+  });
+}
+/**
+ * @private
+ */
+
+
+var RelayParser = /*#__PURE__*/function () {
+  function RelayParser(schema, definitions) {
+    var _this = this;
+
+    this._definitions = new Map(); // leaving this configurable to make it easy to experiment w changing later
+
+    this._getFieldDefinition = getFieldDefinitionLegacy;
+    this._schema = schema;
+    var duplicated = new Set();
+    definitions.forEach(function (def) {
+      if (isExecutableDefinitionAST(def)) {
+        var name = getName(def);
+
+        if (_this._definitions.has(name)) {
+          duplicated.add(name);
+          return;
+        }
+
+        _this._definitions.set(name, def);
+      }
+    });
+
+    if (duplicated.size) {
+      throw createUserError('RelayParser: Encountered duplicate definitions for one or more ' + 'documents: each document must have a unique name. Duplicated documents:\n' + Array.from(duplicated, function (name) {
+        return "- ".concat(name);
+      }).join('\n'));
+    }
+  }
+
+  var _proto = RelayParser.prototype;
+
+  _proto.transform = function transform() {
+    var _this2 = this;
+
+    var nodes = [];
+    var entries = new Map(); // Construct a mapping of name to definition ast + variable definitions.
+    // This allows the subsequent AST -> IR tranformation to reference the
+    // defined arguments of referenced fragments.
+
+    eachWithCombinedError(this._definitions, function (_ref) {
+      var name = _ref[0],
+          definition = _ref[1];
+
+      var variableDefinitions = _this2._buildArgumentDefinitions(definition);
+
+      entries.set(name, {
+        definition: definition,
+        variableDefinitions: variableDefinitions
+      });
+    }); // Convert the ASTs to IR.
+
+    eachWithCombinedError(entries.values(), function (_ref2) {
+      var definition = _ref2.definition,
+          variableDefinitions = _ref2.variableDefinitions;
+      var node = parseDefinition(_this2._schema, _this2._getFieldDefinition, entries, definition, variableDefinitions);
+      nodes.push(node);
+    });
+    return nodes;
+  }
+  /**
+   * Constructs a mapping of variable names to definitions for the given
+   * operation/fragment definition.
+   */
+  ;
+
+  _proto._buildArgumentDefinitions = function _buildArgumentDefinitions(definition) {
+    switch (definition.kind) {
+      case 'OperationDefinition':
+        return this._buildOperationArgumentDefinitions(definition);
+
+      case 'FragmentDefinition':
+        return this._buildFragmentArgumentDefinitions(definition);
+
+      default:
+        definition;
+        throw createCompilerError("Unexpected ast kind '".concat(definition.kind, "'."), [definition]);
+    }
+  }
+  /**
+   * Constructs a mapping of variable names to definitions using the
+   * variables defined in `@argumentDefinitions`.
+   */
+  ;
+
+  _proto._buildFragmentArgumentDefinitions = function _buildFragmentArgumentDefinitions(fragment) {
+    var _this3 = this;
+
+    var variableDirectives = (fragment.directives || []).filter(function (directive) {
+      return getName(directive) === ARGUMENT_DEFINITIONS;
+    });
+
+    if (!variableDirectives.length) {
+      return new Map();
+    }
+
+    if (variableDirectives.length !== 1) {
+      throw createUserError("Directive @".concat(ARGUMENT_DEFINITIONS, " may be defined at most once per ") + 'fragment.', null, variableDirectives);
+    }
+
+    var variableDirective = variableDirectives[0]; // work, below accesses all report arguments could still be null/undefined.
+
+    var args = variableDirective.arguments;
+
+    if (variableDirective == null || !Array.isArray(args)) {
+      return new Map();
+    }
+
+    if (!args.length) {
+      throw createUserError("Directive @".concat(ARGUMENT_DEFINITIONS, " requires arguments: remove the ") + 'directive to skip defining local variables for this fragment.', null, [variableDirective]);
+    }
+
+    var variables = new Map();
+    args.forEach(function (arg) {
+      var _defaultValue$value;
+
+      var argName = getName(arg);
+      var previousVariable = variables.get(argName);
+
+      if (previousVariable != null) {
+        throw createUserError("Duplicate definition for variable '$".concat(argName, "'."), null, [previousVariable.ast, arg]);
+      }
+
+      if (arg.value.kind !== 'ObjectValue') {
+        throw createUserError("Expected definition for variable '$".concat(argName, "' to be an object ") + "with the shape: '{type: string, defaultValue?: mixed}.", null, [arg.value]);
+      }
+
+      var defaultValueNode;
+      var typeString;
+      arg.value.fields.forEach(function (field) {
+        var name = getName(field);
+
+        if (name === 'type') {
+          typeString = transformLiteralValue(field.value, field);
+        } else if (name === 'defaultValue') {
+          defaultValueNode = field.value;
+        } else {
+          throw createUserError("Expected definition for variable '$".concat(argName, "' to be an object ") + "with the shape: '{type: string, defaultValue?: mixed}.", null, [arg.value]);
+        }
+      });
+
+      if (typeof typeString !== 'string') {
+        throw createUserError("Expected definition for variable '$".concat(argName, "' to be an object ") + "with the shape: '{type: string, defaultValue?: mixed}.", null, [arg.value]);
+      }
+
+      var typeFromAST = _this3._schema.getTypeFromAST(parseType(typeString));
+
+      if (typeFromAST == null) {
+        throw createUserError( // $FlowFixMe[incompatible-type]
+        "Unknown type \"".concat(typeString, "\" referenced in the argument definitions."), null, [arg]);
+      }
+
+      var type = _this3._schema.asInputType(typeFromAST);
+
+      if (type == null) {
+        throw createUserError( // $FlowFixMe[incompatible-type]
+        "Expected type \"".concat(typeString, "\" to be an input type in the \"").concat(arg.name.value, "\" argument definitions."), null, [arg.value]);
+      }
+
+      var defaultValue = defaultValueNode != null ? transformValue(_this3._schema, defaultValueNode, type, function (variableAst) {
+        throw createUserError("Expected 'defaultValue' to be a literal, got a variable.", null, [variableAst]);
+      }) : null;
+
+      if (defaultValue != null && defaultValue.kind !== 'Literal') {
+        throw createUserError("Expected 'defaultValue' to be a literal, got a variable.", [defaultValue.loc]);
+      }
+
+      variables.set(argName, {
+        ast: arg,
+        defaultValue: (_defaultValue$value = defaultValue === null || defaultValue === void 0 ? void 0 : defaultValue.value) !== null && _defaultValue$value !== void 0 ? _defaultValue$value : null,
+        defined: true,
+        name: argName,
+        type: type
+      });
+    });
+    return variables;
+  }
+  /**
+   * Constructs a mapping of variable names to definitions using the
+   * standard GraphQL syntax for variable definitions.
+   */
+  ;
+
+  _proto._buildOperationArgumentDefinitions = function _buildOperationArgumentDefinitions(operation) {
+    var schema = this._schema;
+    var variableDefinitions = new Map();
+    (operation.variableDefinitions || []).forEach(function (def) {
+      var name = getName(def.variable);
+      var typeFromAST = schema.getTypeFromAST(def.type);
+
+      if (typeFromAST == null) {
+        throw createUserError("Unknown type: '".concat(getTypeName(def.type), "'."), null, [def.type]);
+      }
+
+      var type = schema.asInputType(typeFromAST);
+
+      if (type == null) {
+        throw createUserError("Expected type \"".concat(getTypeName(def.type), "\" to be an input type."), null, [def.type]);
+      }
+
+      var defaultValue = def.defaultValue ? transformLiteralValue(def.defaultValue, def) : null;
+      var previousDefinition = variableDefinitions.get(name);
+
+      if (previousDefinition != null) {
+        throw createUserError("Duplicate definition for variable '$".concat(name, "'."), null, [previousDefinition.ast, def]);
+      }
+
+      variableDefinitions.set(name, {
+        ast: def,
+        defaultValue: defaultValue,
+        defined: true,
+        name: name,
+        type: type
+      });
+    });
+    return variableDefinitions;
+  };
+
+  return RelayParser;
+}();
+/**
+ * @private
+ */
+
+
+function parseDefinition(schema, getFieldDefinition, entries, definition, variableDefinitions) {
+  var parser = new GraphQLDefinitionParser(schema, getFieldDefinition, entries, definition, variableDefinitions);
+  return parser.transform();
+}
+/**
+ * @private
+ */
+
+
+var GraphQLDefinitionParser = /*#__PURE__*/function () {
+  function GraphQLDefinitionParser(schema, getFieldDefinition, entries, definition, variableDefinitions) {
+    this._definition = definition;
+    this._entries = entries;
+    this._getFieldDefinition = getFieldDefinition;
+    this._schema = schema;
+    this._variableDefinitions = variableDefinitions;
+    this._unknownVariables = new Map();
+  }
+
+  var _proto2 = GraphQLDefinitionParser.prototype;
+
+  _proto2.transform = function transform() {
+    var definition = this._definition;
+
+    switch (definition.kind) {
+      case 'OperationDefinition':
+        return this._transformOperation(definition);
+
+      case 'FragmentDefinition':
+        return this._transformFragment(definition);
+
+      default:
+        definition;
+        throw createCompilerError("Unsupported definition type ".concat(definition.kind), [definition]);
+    }
+  };
+
+  _proto2._recordAndVerifyVariableReference = function _recordAndVerifyVariableReference(variable, name, usedAsType) {
+    // Special case for variables used in @arguments where we currently
+    // aren't guaranteed to be able to resolve the type.
+    if (usedAsType == null) {
+      if (!this._variableDefinitions.has(name) && !this._unknownVariables.has(name)) {
+        this._unknownVariables.set(name, {
+          ast: variable,
+          type: null
+        });
+      }
+
+      return;
+    }
+
+    var variableDefinition = this._variableDefinitions.get(name);
+
+    if (variableDefinition != null) {
+      // If the variable is defined, all usages must be compatible
+      var effectiveType = variableDefinition.type;
+
+      if (variableDefinition.defaultValue != null) {
+        // If a default value is defined then it is guaranteed to be used
+        // at runtime such that the effective type of the variable is non-null
+        effectiveType = this._schema.getNonNullType(this._schema.getNullableType(effectiveType));
+      }
+
+      if (!this._schema.isTypeSubTypeOf(effectiveType, usedAsType)) {
+        throw createUserError("Variable '$".concat(name, "' was defined as type '").concat(String(variableDefinition.type), "' but used in a location expecting the type '").concat(String(usedAsType), "'"), null, [variableDefinition.ast, variable]);
+      }
+    } else {
+      var previous = this._unknownVariables.get(name);
+
+      if (!previous || !previous.type) {
+        // No previous usage, current type is strongest
+        this._unknownVariables.set(name, {
+          ast: variable,
+          type: usedAsType
+        });
+      } else {
+        var previousVariable = previous.ast,
+            previousType = previous.type;
+
+        if (!(this._schema.isTypeSubTypeOf(usedAsType, previousType) || this._schema.isTypeSubTypeOf(previousType, usedAsType))) {
+          throw createUserError("Variable '$".concat(name, "' was used in locations expecting the conflicting types '").concat(String(previousType), "' and '").concat(String(usedAsType), "'."), null, [previousVariable, variable]);
+        } // If the new used type has stronger requirements, use that type as reference,
+        // otherwise keep referencing the previous type
+
+
+        if (this._schema.isTypeSubTypeOf(usedAsType, previousType)) {
+          this._unknownVariables.set(name, {
+            ast: variable,
+            type: usedAsType
+          });
+        }
+      }
+    }
+  };
+
+  _proto2._getDirectiveLocations = function _getDirectiveLocations() {
+    if (!this._directiveLocations) {
+      var directiveDefs = this._schema.getDirectives();
+
+      this._directiveLocations = new Map();
+
+      var _iterator = (0, _createForOfIteratorHelper2["default"])(directiveDefs),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var def = _step.value;
+
+          this._directiveLocations.set(def.name, def.locations);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+
+    return this._directiveLocations;
+  };
+
+  _proto2._validateDirectivesLocation = function _validateDirectivesLocation(directives, allowedLocaction) {
+    if (!directives || !directives.length) {
+      return;
+    }
+
+    var directiveLocs = this._getDirectiveLocations();
+
+    var mismatches = directives.filter(function (directive) {
+      var name = getName(directive);
+
+      if (DIRECTIVE_WHITELIST.has(name)) {
+        return false;
+      }
+
+      var locs = directiveLocs.get(name);
+
+      if (locs == null) {
+        throw createUserError("Unknown directive '".concat(name, "'."), null, [directive]);
+      }
+
+      return !locs.some(function (loc) {
+        return loc === allowedLocaction;
+      });
+    });
+
+    if (mismatches.length) {
+      var invalidDirectives = mismatches.map(function (directive) {
+        return '@' + getName(directive);
+      }).join(', ');
+      throw createUserError("Invalid directives ".concat(invalidDirectives, " found on ").concat(allowedLocaction, "."), null, mismatches);
+    }
+  };
+
+  _proto2._transformFragment = function _transformFragment(fragment) {
+    var directives = this._transformDirectives((fragment.directives || []).filter(function (directive) {
+      return getName(directive) !== ARGUMENT_DEFINITIONS;
+    }), 'FRAGMENT_DEFINITION');
+
+    var typeFromAST = this._schema.getTypeFromAST(fragment.typeCondition);
+
+    if (typeFromAST == null) {
+      throw createUserError("Fragment \"".concat(fragment.name.value, "\" cannot condition on unknown ") + "type \"".concat(String(fragment.typeCondition.name.value), "\"."), null, [fragment.typeCondition]);
+    }
+
+    var type = this._schema.asCompositeType(typeFromAST);
+
+    if (type == null) {
+      throw createUserError("Fragment \"".concat(fragment.name.value, "\" cannot condition on non composite ") + "type \"".concat(String(type), "\"."), null, [fragment.typeCondition]);
+    }
+
+    var selections = this._transformSelections(fragment.selectionSet, type, fragment.typeCondition);
+
+    var argumentDefinitions = (0, _toConsumableArray2["default"])(buildArgumentDefinitions(this._variableDefinitions));
+
+    var _iterator2 = (0, _createForOfIteratorHelper2["default"])(this._unknownVariables),
+        _step2;
+
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _step2$value = _step2.value,
+            name = _step2$value[0],
+            variableReference = _step2$value[1];
+        argumentDefinitions.push({
+          kind: 'RootArgumentDefinition',
+          loc: buildLocation(variableReference.ast.loc),
+          name: name,
+          type: variableReference.type
+        });
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+
+    return {
+      kind: 'Fragment',
+      directives: directives,
+      loc: buildLocation(fragment.loc),
+      metadata: null,
+      name: getName(fragment),
+      selections: selections,
+      type: type,
+      // $FlowFixMe[incompatible-return] - could be null
+      argumentDefinitions: argumentDefinitions
+    };
+  };
+
+  _proto2._getLocationFromOperation = function _getLocationFromOperation(definition) {
+    switch (definition.operation) {
+      case 'query':
+        return 'QUERY';
+
+      case 'mutation':
+        return 'MUTATION';
+
+      case 'subscription':
+        return 'SUBSCRIPTION';
+
+      default:
+        definition.operation;
+        throw createCompilerError("Unknown operation type '".concat(definition.operation, "'."), null, [definition]);
+    }
+  };
+
+  _proto2._transformOperation = function _transformOperation(definition) {
+    var name = getName(definition);
+
+    var directives = this._transformDirectives(definition.directives || [], this._getLocationFromOperation(definition));
+
+    var type;
+    var operation;
+    var schema = this._schema;
+
+    switch (definition.operation) {
+      case 'query':
+        operation = 'query';
+        type = schema.expectQueryType();
+        break;
+
+      case 'mutation':
+        operation = 'mutation';
+        type = schema.expectMutationType();
+        break;
+
+      case 'subscription':
+        operation = 'subscription';
+        type = schema.expectSubscriptionType();
+        break;
+
+      default:
+        definition.operation;
+        throw createCompilerError("Unknown operation type '".concat(definition.operation, "'."), null, [definition]);
+    }
+
+    if (!definition.selectionSet) {
+      throw createUserError('Expected operation to have selections.', null, [definition]);
+    }
+
+    var selections = this._transformSelections(definition.selectionSet, type);
+
+    var argumentDefinitions = buildArgumentDefinitions(this._variableDefinitions);
+
+    if (this._unknownVariables.size !== 0) {
+      throw createUserError("Query '".concat(name, "' references undefined variables."), null, Array.from(this._unknownVariables.values(), function (variableReference) {
+        return variableReference.ast;
+      }));
+    }
+
+    return {
+      kind: 'Root',
+      operation: operation,
+      loc: buildLocation(definition.loc),
+      metadata: null,
+      name: name,
+      argumentDefinitions: argumentDefinitions,
+      directives: directives,
+      selections: selections,
+      // $FlowFixMe[incompatible-return]
+      type: type
+    };
+  };
+
+  _proto2._transformSelections = function _transformSelections(selectionSet, parentType, parentTypeAST) {
+    var _this4 = this;
+
+    return selectionSet.selections.map(function (selection) {
+      var node;
+
+      if (selection.kind === 'Field') {
+        node = _this4._transformField(selection, parentType);
+      } else if (selection.kind === 'FragmentSpread') {
+        node = _this4._transformFragmentSpread(selection, parentType, parentTypeAST);
+      } else if (selection.kind === 'InlineFragment') {
+        node = _this4._transformInlineFragment(selection, parentType, parentTypeAST);
+      } else {
+        selection.kind;
+        throw createCompilerError("Unknown ast kind '".concat(selection.kind, "'."), [selection]);
+      }
+
+      var _this4$_splitConditio = _this4._splitConditions(node.directives),
+          conditions = _this4$_splitConditio[0],
+          directives = _this4$_splitConditio[1];
+
+      var conditionalNodes = applyConditions(conditions, // $FlowFixMe[incompatible-call]
+      [(0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, node), {}, {
+        directives: directives
+      })]);
+
+      if (conditionalNodes.length !== 1) {
+        throw createCompilerError('Expected exactly one condition node.', null, selection.directives);
+      }
+
+      return conditionalNodes[0];
+    });
+  };
+
+  _proto2._transformInlineFragment = function _transformInlineFragment(fragment, parentType, parentTypeAST) {
+    var schema = this._schema;
+    var typeCondition = fragment.typeCondition != null ? schema.getTypeFromAST(fragment.typeCondition) : parentType;
+
+    if (typeCondition == null) {
+      var _fragment$typeConditi;
+
+      throw createUserError('Inline fragments can only be on object, interface or union types' + ", got unknown type '".concat(getTypeName(fragment.typeCondition), "'."), null, [(_fragment$typeConditi = fragment.typeCondition) !== null && _fragment$typeConditi !== void 0 ? _fragment$typeConditi : fragment]);
+    }
+
+    var typeConditionName = schema.getTypeString(typeCondition);
+    typeCondition = schema.asCompositeType(typeCondition);
+
+    if (typeCondition == null) {
+      var _fragment$typeConditi2;
+
+      throw createUserError('Inline fragments can only be on object, interface or union types' + ", got '".concat(typeConditionName, "'."), null, [(_fragment$typeConditi2 = fragment.typeCondition) !== null && _fragment$typeConditi2 !== void 0 ? _fragment$typeConditi2 : fragment]);
+    }
+
+    var rawParentType = this._schema.assertCompositeType(this._schema.getRawType(parentType));
+
+    checkFragmentSpreadTypeCompatibility(this._schema, typeCondition, rawParentType, null, fragment.typeCondition, parentTypeAST);
+
+    var directives = this._transformDirectives(fragment.directives || [], 'INLINE_FRAGMENT');
+
+    var selections = this._transformSelections(fragment.selectionSet, typeCondition, fragment.typeCondition);
+
+    return {
+      kind: 'InlineFragment',
+      directives: directives,
+      loc: buildLocation(fragment.loc),
+      metadata: null,
+      selections: selections,
+      typeCondition: typeCondition
+    };
+  };
+
+  _proto2._transformFragmentSpread = function _transformFragmentSpread(fragmentSpread, parentType, parentTypeAST) {
+    var _this5 = this;
+
+    var fragmentName = getName(fragmentSpread);
+
+    var _partitionArray = partitionArray(fragmentSpread.directives || [], function (directive) {
+      var name = getName(directive);
+      return name === ARGUMENTS || name === DEPRECATED_UNCHECKED_ARGUMENTS;
+    }),
+        argumentDirectives = _partitionArray[0],
+        otherDirectives = _partitionArray[1];
+
+    if (argumentDirectives.length > 1) {
+      throw createUserError("Directive @".concat(ARGUMENTS, " may be used at most once per a fragment spread."), null, argumentDirectives);
+    }
+
+    var fragmentDefinition = this._entries.get(fragmentName);
+
+    if (fragmentDefinition == null) {
+      throw createUserError("Unknown fragment '".concat(fragmentName, "'."), null, [fragmentSpread.name]);
+    }
+
+    var fragmentTypeNode = getFragmentType(fragmentDefinition.definition);
+
+    var fragmentType = this._schema.assertCompositeType(this._schema.expectTypeFromAST(fragmentTypeNode));
+
+    var rawParentType = this._schema.assertCompositeType(this._schema.getRawType(parentType));
+
+    checkFragmentSpreadTypeCompatibility(this._schema, fragmentType, rawParentType, fragmentSpread.name.value, fragmentSpread, parentTypeAST);
+    var fragmentArgumentDefinitions = fragmentDefinition.variableDefinitions;
+    var argumentsDirective = argumentDirectives[0];
+    var args;
+
+    if (argumentsDirective != null) {
+      var isDeprecatedUncheckedArguments = getName(argumentsDirective) === DEPRECATED_UNCHECKED_ARGUMENTS;
+      var hasInvalidArgument = false;
+      args = (argumentsDirective.arguments || []).map(function (arg) {
+        var _argumentDefinition$t;
+
+        var argName = getName(arg);
+        var argValue = arg.value;
+        var argumentDefinition = fragmentArgumentDefinitions.get(argName);
+        var argumentType = (_argumentDefinition$t = argumentDefinition === null || argumentDefinition === void 0 ? void 0 : argumentDefinition.type) !== null && _argumentDefinition$t !== void 0 ? _argumentDefinition$t : null;
+
+        if (argValue.kind === 'Variable') {
+          if (argumentDefinition == null && !isDeprecatedUncheckedArguments) {
+            throw createUserError("Variable @".concat(ARGUMENTS, " values are only supported when the ") + "argument is defined with @".concat(ARGUMENT_DEFINITIONS, ". Check ") + "the definition of fragment '".concat(fragmentName, "'."), null, [arg.value, fragmentDefinition.definition]);
+          }
+
+          hasInvalidArgument = hasInvalidArgument || argumentDefinition == null; // TODO: check the type of the variable and use the type
+
+          return {
+            kind: 'Argument',
+            loc: buildLocation(arg.loc),
+            name: argName,
+            value: _this5._transformVariable(argValue, null),
+            type: null
+          };
+        } else {
+          if (argumentType == null) {
+            throw createUserError("Literal @".concat(ARGUMENTS, " values are only supported when the ") + "argument is defined with @".concat(ARGUMENT_DEFINITIONS, ". Check ") + "the definition of fragment '".concat(fragmentName, "'."), null, [arg.value, fragmentDefinition.definition]);
+          }
+
+          var value = _this5._transformValue(argValue, argumentType);
+
+          return {
+            kind: 'Argument',
+            loc: buildLocation(arg.loc),
+            name: argName,
+            value: value,
+            type: argumentType
+          };
+        }
+      });
+
+      if (isDeprecatedUncheckedArguments && !hasInvalidArgument) {
+        throw createUserError("Invalid use of @".concat(DEPRECATED_UNCHECKED_ARGUMENTS, ": all arguments ") + "are defined, use @".concat(ARGUMENTS, " instead."), null, [argumentsDirective]);
+      }
+    }
+
+    var directives = this._transformDirectives(otherDirectives, 'FRAGMENT_SPREAD');
+
+    return {
+      kind: 'FragmentSpread',
+      args: args || [],
+      metadata: null,
+      loc: buildLocation(fragmentSpread.loc),
+      name: fragmentName,
+      directives: directives
+    };
+  };
+
+  _proto2._transformField = function _transformField(field, parentType) {
+    var _field$alias$value, _field$alias;
+
+    var schema = this._schema;
+    var name = getName(field);
+
+    var fieldDef = this._getFieldDefinition(schema, parentType, name, field);
+
+    if (fieldDef == null) {
+      throw createUserError("Unknown field '".concat(name, "' on type '").concat(schema.getTypeString(parentType), "'."), null, [field]);
+    }
+
+    var alias = (_field$alias$value = (_field$alias = field.alias) === null || _field$alias === void 0 ? void 0 : _field$alias.value) !== null && _field$alias$value !== void 0 ? _field$alias$value : name;
+
+    var args = this._transformArguments(field.arguments || [], schema.getFieldArgs(fieldDef), fieldDef);
+
+    var _partitionArray2 = partitionArray(field.directives || [], function (directive) {
+      return getName(directive) !== CLIENT_FIELD;
+    }),
+        otherDirectives = _partitionArray2[0],
+        clientFieldDirectives = _partitionArray2[1];
+
+    var directives = this._transformDirectives(otherDirectives, 'FIELD');
+
+    var type = schema.getFieldType(fieldDef);
+
+    var handles = this._transformHandle(name, args, clientFieldDirectives);
+
+    if (schema.isLeafType(schema.getRawType(type))) {
+      if (field.selectionSet && field.selectionSet.selections && field.selectionSet.selections.length) {
+        throw createUserError("Expected no selections for scalar field '".concat(name, "'."), null, [field]);
+      }
+
+      return {
+        kind: 'ScalarField',
+        alias: alias,
+        args: args,
+        directives: directives,
+        handles: handles,
+        loc: buildLocation(field.loc),
+        metadata: null,
+        name: name,
+        type: schema.assertScalarFieldType(type)
+      };
+    } else {
+      var selections = field.selectionSet ? this._transformSelections(field.selectionSet, type) : null;
+
+      if (selections == null || selections.length === 0) {
+        throw createUserError("Expected at least one selection for non-scalar field '".concat(name, "' on type '").concat(schema.getTypeString(type), "'."), null, [field]);
+      }
+
+      return {
+        kind: 'LinkedField',
+        alias: alias,
+        args: args,
+        connection: false,
+        directives: directives,
+        handles: handles,
+        loc: buildLocation(field.loc),
+        metadata: null,
+        name: name,
+        selections: selections,
+        type: schema.assertLinkedFieldType(type)
+      };
+    }
+  };
+
+  _proto2._transformHandle = function _transformHandle(fieldName, fieldArgs, clientFieldDirectives) {
+    var handles = null;
+    clientFieldDirectives.forEach(function (clientFieldDirective) {
+      var handleArgument = (clientFieldDirective.arguments || []).find(function (arg) {
+        return getName(arg) === CLIENT_FIELD_HANDLE;
+      });
+
+      if (handleArgument) {
+        var name = null;
+        var key = DEFAULT_HANDLE_KEY;
+        var filters = null;
+        var maybeHandle = transformLiteralValue(handleArgument.value, handleArgument);
+
+        if (typeof maybeHandle !== 'string') {
+          throw createUserError("Expected a string literal argument for the @".concat(CLIENT_FIELD, " directive."), null, [handleArgument.value]);
+        }
+
+        name = maybeHandle;
+        var keyArgument = (clientFieldDirective.arguments || []).find(function (arg) {
+          return getName(arg) === CLIENT_FIELD_KEY;
+        });
+
+        if (keyArgument) {
+          var maybeKey = transformLiteralValue(keyArgument.value, keyArgument);
+
+          if (typeof maybeKey !== 'string') {
+            throw createUserError("Expected a string literal argument for the @".concat(CLIENT_FIELD, " directive."), null, [keyArgument.value]);
+          }
+
+          key = maybeKey;
+        }
+
+        var filtersArgument = (clientFieldDirective.arguments || []).find(function (arg) {
+          return getName(arg) === CLIENT_FIELD_FILTERS;
+        });
+
+        if (filtersArgument) {
+          var maybeFilters = transformLiteralValue(filtersArgument.value, filtersArgument);
+
+          if (!(Array.isArray(maybeFilters) && maybeFilters.every(function (filter) {
+            return typeof filter === 'string' && fieldArgs.some(function (fieldArg) {
+              return fieldArg.name === filter;
+            });
+          }))) {
+            throw createUserError("Expected an array of argument names on field '".concat(fieldName, "'."), null, [filtersArgument.value]);
+          } // $FlowFixMe[incompatible-cast]
+
+
+          filters = maybeFilters;
+        }
+
+        var dynamicKeyArgument = (clientFieldDirective.arguments || []).find(function (arg) {
+          return getName(arg) === 'dynamicKey_UNSTABLE';
+        });
+
+        if (dynamicKeyArgument != null) {
+          throw createUserError('Dynamic keys are only supported with @connection.', null, [dynamicKeyArgument.value]);
+        }
+
+        handles = handles || [];
+        handles.push({
+          name: name,
+          key: key,
+          filters: filters,
+          dynamicKey: null
+        });
+      }
+    });
+    return handles;
+  };
+
+  _proto2._transformDirectives = function _transformDirectives(directives, location) {
+    var _this6 = this;
+
+    this._validateDirectivesLocation(directives, location);
+
+    return directives.map(function (directive) {
+      var name = getName(directive);
+
+      var directiveDef = _this6._schema.getDirective(name);
+
+      if (directiveDef == null) {
+        throw createUserError("Unknown directive '".concat(name, "'."), null, [directive]);
+      }
+
+      var args = _this6._transformArguments(directive.arguments || [], directiveDef.args.map(function (item) {
+        return {
+          name: item.name,
+          type: item.type,
+          defaultValue: item.defaultValue
+        };
+      }), null, name);
+
+      return {
+        kind: 'Directive',
+        loc: buildLocation(directive.loc),
+        name: name,
+        args: args
+      };
+    });
+  };
+
+  _proto2._transformArguments = function _transformArguments(args, argumentDefinitions, field, directiveName) {
+    var _this7 = this;
+
+    return args.map(function (arg) {
+      var argName = getName(arg);
+      var argDef = argumentDefinitions.find(function (def) {
+        return def.name === argName;
+      });
+
+      if (argDef == null) {
+        var message = "Unknown argument '".concat(argName, "'") + (field ? " on field '".concat(_this7._schema.getFieldName(field), "'") + " of type '".concat(_this7._schema.getTypeString(_this7._schema.getFieldParentType(field)), "'.") : directiveName != null ? " on directive '@".concat(directiveName, "'.") : '.');
+        throw createUserError(message, null, [arg]);
+      }
+
+      var value = _this7._transformValue(arg.value, argDef.type);
+
+      return {
+        kind: 'Argument',
+        loc: buildLocation(arg.loc),
+        name: argName,
+        value: value,
+        type: argDef.type
+      };
+    });
+  };
+
+  _proto2._splitConditions = function _splitConditions(mixedDirectives) {
+    var _partitionArray3 = partitionArray(mixedDirectives, function (directive) {
+      return directive.name === INCLUDE || directive.name === SKIP;
+    }),
+        conditionDirectives = _partitionArray3[0],
+        otherDirectives = _partitionArray3[1];
+
+    var conditions = conditionDirectives.map(function (directive) {
+      var passingValue = directive.name === INCLUDE;
+      var arg = directive.args[0];
+
+      if (arg == null || arg.name !== IF) {
+        throw createUserError("Expected an 'if' argument to @".concat(directive.name, "."), [directive.loc]);
+      }
+
+      if (!(arg.value.kind === 'Variable' || arg.value.kind === 'Literal')) {
+        throw createUserError("Expected the 'if' argument to @".concat(directive.name, " to be a variable or literal."), [directive.loc]);
+      }
+
+      return {
+        kind: 'Condition',
+        condition: arg.value,
+        loc: directive.loc,
+        passingValue: passingValue,
+        selections: []
+      };
+    });
+    var sortedConditions = conditions.sort(function (a, b) {
+      if (a.condition.kind === 'Variable' && b.condition.kind === 'Variable') {
+        return a.condition.variableName < b.condition.variableName ? -1 : a.condition.variableName > b.condition.variableName ? 1 : 0;
+      } else {
+        // sort literals earlier, variables later
+        return a.condition.kind === 'Variable' ? 1 : b.condition.kind === 'Variable' ? -1 : 0;
+      }
+    });
+    return [sortedConditions, otherDirectives];
+  };
+
+  _proto2._transformVariable = function _transformVariable(ast, usedAsType) {
+    var variableName = getName(ast);
+
+    this._recordAndVerifyVariableReference(ast, variableName, usedAsType);
+
+    return {
+      kind: 'Variable',
+      loc: buildLocation(ast.loc),
+      variableName: variableName,
+      type: usedAsType
+    };
+  };
+
+  _proto2._transformValue = function _transformValue(ast, type) {
+    var _this8 = this;
+
+    return transformValue(this._schema, ast, type, function (variableAst, variableType) {
+      return _this8._transformVariable(variableAst, variableType);
+    });
+  };
+
+  return GraphQLDefinitionParser;
+}();
+/**
+ * Transforms and validates argument values according to the expected
+ * type.
+ */
+
+
+function transformValue(schema, ast, type, transformVariable) {
+  if (ast.kind === 'Variable') {
+    // Special case variables since there is no value to parse
+    return transformVariable(ast, type);
+  } else if (ast.kind === 'NullValue') {
+    // Special case null literals since there is no value to parse
+    if (schema.isNonNull(type)) {
+      throw createUserError("Expected a value matching type '".concat(String(type), "'."), null, [ast]);
+    }
+
+    return {
+      kind: 'Literal',
+      loc: buildLocation(ast.loc),
+      value: null
+    };
+  } else {
+    return transformNonNullLiteral(schema, ast, type, transformVariable);
+  }
+}
+/**
+ * Transforms and validates non-null literal (non-variable) values
+ * according to the expected type.
+ */
+
+
+function transformNonNullLiteral(schema, ast, type, transformVariable) {
+  // Transform the value based on the type without a non-null wrapper.
+  // Note that error messages should still use the original `type`
+  // since that accurately describes to the user what the expected
+  // type is (using nullableType would suggest that `null` is legal
+  // even when it may not be, for example).
+  var nullableType = schema.getNullableType(type);
+
+  if (schema.isList(nullableType)) {
+    if (ast.kind !== 'ListValue') {
+      // Parse singular (non-list) values flowing into a list type
+      // as scalars, ie without wrapping them in an array.
+      if (!schema.isInputType(schema.getListItemType(nullableType))) {
+        throw createUserError("Expected type ".concat(schema.getTypeString(nullableType), " to be an input type."), null, [ast]);
+      }
+
+      return transformValue(schema, ast, schema.assertInputType(schema.getListItemType(nullableType)), transformVariable);
+    }
+
+    var itemType = schema.assertInputType(schema.getListItemType(nullableType));
+    var literalList = [];
+    var items = [];
+    var areAllItemsScalar = true;
+    ast.values.forEach(function (item) {
+      var itemValue = transformValue(schema, item, itemType, transformVariable);
+
+      if (itemValue.kind === 'Literal') {
+        literalList.push(itemValue.value);
+      }
+
+      items.push(itemValue);
+      areAllItemsScalar = areAllItemsScalar && itemValue.kind === 'Literal';
+    });
+
+    if (areAllItemsScalar) {
+      return {
+        kind: 'Literal',
+        loc: buildLocation(ast.loc),
+        value: literalList
+      };
+    } else {
+      return {
+        kind: 'ListValue',
+        loc: buildLocation(ast.loc),
+        items: items
+      };
+    }
+  } else if (schema.isInputObject(nullableType)) {
+    if (ast.kind !== 'ObjectValue') {
+      throw createUserError("Expected a value matching type '".concat(schema.getTypeString(type), "'."), null, [ast]);
+    }
+
+    var literalObject = {};
+    var fields = [];
+    var areAllFieldsScalar = true;
+    var inputType = schema.assertInputObjectType(nullableType);
+    var requiredFieldNames = new Set(schema.getFields(inputType).filter(function (field) {
+      return schema.isNonNull(schema.getFieldType(field));
+    }).map(function (field) {
+      return schema.getFieldName(field);
+    }));
+    var seenFields = new Map();
+    ast.fields.forEach(function (field) {
+      var fieldName = getName(field);
+      var seenField = seenFields.get(fieldName);
+
+      if (seenField) {
+        throw createUserError("Duplicated field name '".concat(fieldName, "' in the input object."), null, [field, seenField]);
+      }
+
+      var fieldID = schema.getFieldByName(inputType, fieldName);
+
+      if (!fieldID) {
+        throw createUserError("Unknown field '".concat(fieldName, "' on type '").concat(schema.getTypeString(inputType), "'."), null, [field]);
+      }
+
+      var fieldConfig = schema.getFieldConfig(fieldID);
+      var fieldType = schema.assertInputType(fieldConfig.type);
+      var fieldValue = transformValue(schema, field.value, fieldType, transformVariable);
+
+      if (fieldValue.kind === 'Literal') {
+        literalObject[field.name.value] = fieldValue.value;
+      }
+
+      fields.push({
+        kind: 'ObjectFieldValue',
+        loc: buildLocation(field.loc),
+        name: fieldName,
+        value: fieldValue
+      });
+      seenFields.set(fieldName, field);
+      requiredFieldNames["delete"](fieldName);
+      areAllFieldsScalar = areAllFieldsScalar && fieldValue.kind === 'Literal';
+    });
+
+    if (requiredFieldNames.size > 0) {
+      var requiredFieldStr = Array.from(requiredFieldNames).map(function (item) {
+        return "'".concat(item, "'");
+      }).join(', ');
+      throw createUserError("Missing non-optional field".concat(requiredFieldNames.size > 1 ? 's:' : '', " ").concat(requiredFieldStr, " for input type '").concat(schema.getTypeString(inputType), "'."), null, [ast]);
+    }
+
+    if (areAllFieldsScalar) {
+      return {
+        kind: 'Literal',
+        loc: buildLocation(ast.loc),
+        value: literalObject
+      };
+    } else {
+      return {
+        kind: 'ObjectValue',
+        loc: buildLocation(ast.loc),
+        fields: fields
+      };
+    }
+  } else if (schema.isId(nullableType)) {
+    // GraphQLID's parseLiteral() always returns the string value. However
+    // the int/string distinction may be important at runtime, so this
+    // transform parses int/string literals into the corresponding JS types.
+    if (ast.kind === 'IntValue') {
+      return {
+        kind: 'Literal',
+        loc: buildLocation(ast.loc),
+        value: parseInt(ast.value, 10)
+      };
+    } else if (ast.kind === 'StringValue') {
+      return {
+        kind: 'Literal',
+        loc: buildLocation(ast.loc),
+        value: ast.value
+      };
+    } else {
+      throw createUserError("Invalid value, expected a value matching type '".concat(schema.getTypeString(type), "'."), null, [ast]);
+    }
+  } else if (schema.isEnum(nullableType)) {
+    var enumType = schema.assertEnumType(nullableType);
+    var value = schema.parseLiteral(enumType, ast);
+
+    if (value == null) {
+      var suggestions = schema.getEnumValues(enumType); // parseLiteral() should return a non-null JavaScript value
+      // if the ast value is valid for the type.
+
+      throw createUserError("Expected a value matching type '".concat(schema.getTypeString(type), "'. Possible values: ").concat(orList(suggestions), "?'"), null, [ast]);
+    }
+
+    return {
+      kind: 'Literal',
+      loc: buildLocation(ast.loc),
+      value: value
+    };
+  } else if (schema.isScalar(nullableType)) {
+    var _value = schema.parseLiteral(schema.assertScalarType(nullableType), ast);
+
+    if (_value == null) {
+      // parseLiteral() should return a non-null JavaScript value
+      // if the ast value is valid for the type.
+      throw createUserError("Expected a value matching type '".concat(schema.getTypeString(type), "'."), null, [ast]);
+    }
+
+    return {
+      kind: 'Literal',
+      loc: buildLocation(ast.loc),
+      value: _value
+    };
+  } else {
+    throw createCompilerError("Unsupported type '".concat(schema.getTypeString(type), "' for input value, expected a GraphQLList, ") + 'GraphQLInputObjectType, GraphQLEnumType, or GraphQLScalarType.', null, [ast]);
+  }
+}
+/**
+ * @private
+ */
+
+
+function transformLiteralValue(ast, context) {
+  switch (ast.kind) {
+    case 'IntValue':
+      return parseInt(ast.value, 10);
+
+    case 'FloatValue':
+      return parseFloat(ast.value);
+
+    case 'StringValue':
+      return ast.value;
+
+    case 'BooleanValue':
+      // Note: duplicated because Flow does not understand fall-through cases
+      return ast.value;
+
+    case 'EnumValue':
+      // Note: duplicated because Flow does not understand fall-through cases
+      return ast.value;
+
+    case 'ListValue':
+      return ast.values.map(function (item) {
+        return transformLiteralValue(item, context);
+      });
+
+    case 'NullValue':
+      return null;
+
+    case 'ObjectValue':
+      {
+        var objectValue = {};
+        ast.fields.forEach(function (field) {
+          var fieldName = getName(field);
+          var value = transformLiteralValue(field.value, context);
+          objectValue[fieldName] = value;
+        });
+        return objectValue;
+      }
+
+    case 'Variable':
+      throw createUserError('Unexpected variable where a literal (static) value is required.', null, [ast, context]);
+
+    default:
+      ast.kind;
+      throw createCompilerError("Unknown ast kind '".concat(ast.kind, "'."), [ast]);
+  }
+}
+/**
+ * @private
+ */
+
+
+function buildArgumentDefinitions(variables) {
+  return Array.from(variables.values(), function (_ref3) {
+    var ast = _ref3.ast,
+        name = _ref3.name,
+        defaultValue = _ref3.defaultValue,
+        type = _ref3.type;
+    return {
+      kind: 'LocalArgumentDefinition',
+      loc: buildLocation(ast.loc),
+      name: name,
+      type: type,
+      defaultValue: defaultValue
+    };
+  });
+}
+/**
+ * @private
+ */
+
+
+function buildLocation(loc) {
+  if (loc == null) {
+    return {
+      kind: 'Unknown'
+    };
+  }
+
+  return {
+    kind: 'Source',
+    start: loc.start,
+    end: loc.end,
+    source: loc.source
+  };
+}
+/**
+ * @private
+ */
+
+
+function applyConditions(conditions, selections) {
+  var nextSelections = selections;
+  conditions.forEach(function (condition) {
+    nextSelections = [(0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, condition), {}, {
+      selections: nextSelections
+    })];
+  });
+  return nextSelections;
+}
+/**
+ * @private
+ */
+
+
+function getName(ast) {
+  var _ast$name;
+
+  var name = (_ast$name = ast.name) === null || _ast$name === void 0 ? void 0 : _ast$name.value;
+
+  if (typeof name !== 'string') {
+    throw createCompilerError("Expected ast node to have a 'name'.", null, [ast]);
+  }
+
+  return name;
+}
+
+function getTypeName(ast) {
+  return ast ? print(ast) : 'Undefined Type Name';
+}
+/**
+ * @private
+ */
+
+
+function getFragmentType(ast) {
+  if (ast.kind === 'FragmentDefinition') {
+    return ast.typeCondition;
+  }
+
+  throw createCompilerError('Expected ast node to be a FragmentDefinition node.', null, [ast]);
+}
+
+function checkFragmentSpreadTypeCompatibility(schema, fragmentType, parentType, fragmentName, fragmentTypeAST, parentTypeAST) {
+  if (!schema.doTypesOverlap(fragmentType, schema.assertCompositeType(parentType))) {
+    var nodes = [];
+
+    if (parentTypeAST) {
+      nodes.push(parentTypeAST);
+    }
+
+    if (fragmentTypeAST) {
+      nodes.push(fragmentTypeAST);
+    }
+
+    var possibleConcreteTypes = schema.isAbstractType(parentType) ? Array.from(schema.getPossibleTypes(schema.assertAbstractType(parentType))) : [];
+    var suggestedTypesMessage = '';
+
+    if (possibleConcreteTypes.length !== 0) {
+      suggestedTypesMessage = " Possible concrete types include ".concat(possibleConcreteTypes.sort().slice(0, 3).map(function (type) {
+        return "'".concat(schema.getTypeString(type), "'");
+      }).join(', '), ", etc.");
+    }
+
+    throw createUserError((fragmentName != null ? "Fragment '".concat(fragmentName, "' cannot be spread here as objects of ") : 'Fragment cannot be spread here as objects of ') + "type '".concat(schema.getTypeString(parentType), "' ") + "can never be of type '".concat(schema.getTypeString(fragmentType), "'.") + suggestedTypesMessage, null, nodes);
+  }
+}
+
+module.exports = {
+  parse: parse,
+  transform: transform
+};