relay-compiler 1.3.0 → 1.5.0

package/lib/RelayParser.js

@@ -1,10 +1,8 @@
 /**
  * Copyright (c) 2013-present, Facebook, Inc.
- * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
  *
  * @providesModule RelayParser
  * 
@@ -13,639 +11,53 @@
 
 'use strict';
 
-var _extends3 = _interopRequireDefault(require('babel-runtime/helpers/extends'));
-
 var _classCallCheck3 = _interopRequireDefault(require('babel-runtime/helpers/classCallCheck'));
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
-
-var _require = require('./DefaultHandleKey'),
-    DEFAULT_HANDLE_KEY = _require.DEFAULT_HANDLE_KEY;
-
-var _require2 = require('./GraphQLSchemaUtils'),
-    getNullableType = _require2.getNullableType,
-    getRawType = _require2.getRawType,
-    getTypeFromAST = _require2.getTypeFromAST,
-    isOperationDefinitionAST = _require2.isOperationDefinitionAST;
+var _possibleConstructorReturn3 = _interopRequireDefault(require('babel-runtime/helpers/possibleConstructorReturn'));
 
-var _require3 = require('graphql'),
-    assertAbstractType = _require3.assertAbstractType,
-    assertCompositeType = _require3.assertCompositeType,
-    assertInputType = _require3.assertInputType,
-    assertOutputType = _require3.assertOutputType,
-    extendSchema = _require3.extendSchema,
-    getNamedType = _require3.getNamedType,
-    GraphQLEnumType = _require3.GraphQLEnumType,
-    GraphQLInputObjectType = _require3.GraphQLInputObjectType,
-    GraphQLInterfaceType = _require3.GraphQLInterfaceType,
-    GraphQLList = _require3.GraphQLList,
-    GraphQLObjectType = _require3.GraphQLObjectType,
-    GraphQLScalarType = _require3.GraphQLScalarType,
-    GraphQLUnionType = _require3.GraphQLUnionType,
-    isAbstractType = _require3.isAbstractType,
-    isLeafType = _require3.isLeafType,
-    isTypeSubTypeOf = _require3.isTypeSubTypeOf,
-    parse = _require3.parse,
-    parseType = _require3.parseType,
-    SchemaMetaFieldDef = _require3.SchemaMetaFieldDef,
-    Source = _require3.Source,
-    TypeMetaFieldDef = _require3.TypeMetaFieldDef,
-    TypeNameMetaFieldDef = _require3.TypeNameMetaFieldDef;
+var _inherits3 = _interopRequireDefault(require('babel-runtime/helpers/inherits'));
 
-var ARGUMENT_DEFINITIONS = 'argumentDefinitions';
-var ARGUMENTS = 'arguments';
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
 
-/**
- * @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 _require = require('graphql'),
+    assertAbstractType = _require.assertAbstractType,
+    isAbstractType = _require.isAbstractType;
 
-var INCLUDE = 'include';
-var SKIP = 'skip';
-var IF = 'if';
+var _require2 = require('./GraphQLCompilerPublic'),
+    Parser = _require2.Parser,
+    SchemaUtils = _require2.SchemaUtils;
 
-function parseRelay(schema, text, filename) {
-  var ast = parse(new Source(text, filename));
-  var nodes = [];
-  schema = extendSchema(schema, ast);
-  ast.definitions.forEach(function (definition) {
-    if (isOperationDefinitionAST(definition)) {
-      nodes.push(transform(schema, definition));
-    }
-  });
-  return nodes;
-}
+var getRawType = SchemaUtils.getRawType;
 
-/**
- * Transforms a raw GraphQL AST into a simpler representation with type
- * information.
- */
-function transform(schema, definition) {
-  var parser = new RelayParser(schema, definition);
-  return parser.transform();
-}
+var RelayParser = function (_Parser) {
+  (0, _inherits3['default'])(RelayParser, _Parser);
 
-var RelayParser = function () {
   function RelayParser(schema, definition) {
     (0, _classCallCheck3['default'])(this, RelayParser);
 
-    this._definition = definition;
-    this._referencedVariables = {};
-    this._schema = schema;
-  }
-
-  RelayParser.prototype._getErrorContext = function _getErrorContext() {
-    var message = 'document `' + getName(this._definition) + '`';
-    if (this._definition.loc && this._definition.loc.source) {
-      message += ' file: `' + this._definition.loc.source.name + '`';
-    }
-    return message;
-  };
-
-  RelayParser.prototype._recordVariableReference = function _recordVariableReference(name, type) {
-    var prevType = this._referencedVariables[name];
-    if (type && prevType) {
-      require('fbjs/lib/invariant')(this._referencedVariables[name] == null || isTypeSubTypeOf(this._schema, this._referencedVariables[name], type), 'RelayParser: Variable `$%s` was used in locations expecting ' + 'the conflicting types `%s` and `%s`. Source: %s.', name, prevType, type, this._getErrorContext());
-    }
-    this._referencedVariables[name] = prevType || type;
-  };
-
-  RelayParser.prototype.transform = function transform() {
-    switch (this._definition.kind) {
-      case 'OperationDefinition':
-        return this._transformOperation(this._definition);
-      case 'FragmentDefinition':
-        return this._transformFragment(this._definition);
-      default:
-        require('fbjs/lib/invariant')(false, 'RelayParser: Unknown AST kind `%s`. Source: %s.', this._definition.kind, this._getErrorContext());
-    }
-  };
-
-  RelayParser.prototype._transformFragment = function _transformFragment(fragment) {
-    var _this = this;
-
-    var argumentDefinitions = this._buildArgumentDefinitions(fragment);
-    var directives = this._transformDirectives((fragment.directives || []).filter(function (directive) {
-      return getName(directive) !== ARGUMENT_DEFINITIONS;
-    }));
-    var type = assertCompositeType(getTypeFromAST(this._schema, fragment.typeCondition));
-    var selections = this._transformSelections(fragment.selectionSet, type);
-    require('fbjs/lib/forEachObject')(this._referencedVariables, function (variableType, name) {
-      var localArgument = argumentDefinitions.find(function (argDef) {
-        return argDef.name === name;
-      });
-      if (localArgument) {
-        require('fbjs/lib/invariant')(variableType == null || isTypeSubTypeOf(_this._schema, localArgument.type, variableType), 'RelayParser: Variable `$%s` was defined as type `%s`, but used in a ' + 'location that expects type `%s`. Source: %s.', name, localArgument.type, variableType, _this._getErrorContext());
-      } else {
-        argumentDefinitions.push({
-          kind: 'RootArgumentDefinition',
-          metadata: null,
-          name: name,
-          type: variableType
-        });
-      }
-    });
-    return {
-      kind: 'Fragment',
-      directives: directives,
-      metadata: null,
-      name: getName(fragment),
-      selections: selections,
-      type: type,
-      argumentDefinitions: argumentDefinitions
-    };
-  };
-
-  /**
-   * Polyfills suport for fragment variable definitions via the
-   * @argumentDefinitions directive. Returns the equivalent AST
-   * to the `argumentDefinitions` property on queries/mutations/etc.
-   */
-
-
-  RelayParser.prototype._buildArgumentDefinitions = function _buildArgumentDefinitions(fragment) {
-    var _this2 = this;
-
-    var variableDirectives = (fragment.directives || []).filter(function (directive) {
-      return getName(directive) === ARGUMENT_DEFINITIONS;
-    });
-    if (!variableDirectives.length) {
-      return [];
-    }
-    require('fbjs/lib/invariant')(variableDirectives.length === 1, 'RelayParser: Directive %s may be defined at most once on fragment ' + '`%s`. Source: %s.', ARGUMENT_DEFINITIONS, getName(fragment), this._getErrorContext());
-    var variableDirective = variableDirectives[0];
-    // $FlowIssue: refining directly on `variableDirective.arguments` doesn't
-    // work, below accesses all report arguments could still be null/undefined.
-    var args = variableDirective.arguments;
-    if (variableDirective == null || !Array.isArray(args)) {
-      return [];
-    }
-    require('fbjs/lib/invariant')(args.length, 'RelayParser: Directive %s requires arguments: remove the directive to ' + 'skip defining local variables for this fragment `%s`. Source: %s.', ARGUMENT_DEFINITIONS, getName(fragment), this._getErrorContext());
-    return args.map(function (arg) {
-      var argName = getName(arg);
-      var argValue = _this2._transformValue(arg.value);
-      require('fbjs/lib/invariant')(argValue.kind === 'Literal', 'RelayParser: Expected definition for variable `%s` to be an object ' + 'with the following shape: `{type: string, defaultValue?: mixed}`, got ' + '`%s`. Source: %s.', argValue, _this2._getErrorContext());
-      var value = argValue.value;
-      require('fbjs/lib/invariant')(!Array.isArray(value) && typeof value === 'object' && value !== null && typeof value.type === 'string', 'RelayParser: Expected definition for variable `%s` to be an object ' + 'with the following shape: `{type: string, defaultValue?: mixed}`, got ' + '`%s`. Source: %s.', argName, argValue, _this2._getErrorContext());
-      var typeAST = parseType(value.type);
-      var type = assertInputType(getTypeFromAST(_this2._schema, typeAST));
-      return {
-        kind: 'LocalArgumentDefinition',
-        defaultValue: value.defaultValue != null ? value.defaultValue : null,
-        metadata: null,
-        name: argName,
-        type: type
-      };
-    });
-  };
-
-  RelayParser.prototype._transformOperation = function _transformOperation(definition) {
-    var name = getName(definition);
-    var argumentDefinitions = this._transformArgumentDefinitions(definition.variableDefinitions || []);
-    var directives = this._transformDirectives(definition.directives || []);
-    var type = void 0;
-    var operation = void 0;
-    switch (definition.operation) {
-      case 'query':
-        operation = 'query';
-        type = assertCompositeType(this._schema.getQueryType());
-        break;
-      case 'mutation':
-        operation = 'mutation';
-        type = assertCompositeType(this._schema.getMutationType());
-        break;
-      case 'subscription':
-        operation = 'subscription';
-        type = assertCompositeType(this._schema.getSubscriptionType());
-        break;
-      default:
-        require('fbjs/lib/invariant')(false, 'RelayParser: Unknown AST kind `%s`. Source: %s.', definition.operation, this._getErrorContext());
-    }
-    require('fbjs/lib/invariant')(definition.selectionSet, 'RelayParser: Expected %s `%s` to have selections. Source: %s.', operation, name, this._getErrorContext());
-    var selections = this._transformSelections(definition.selectionSet, type);
-    return {
-      kind: 'Root',
-      operation: operation,
-      metadata: null,
-      name: name,
-      argumentDefinitions: argumentDefinitions,
-      directives: directives,
-      selections: selections,
-      type: type
-    };
-  };
-
-  RelayParser.prototype._transformArgumentDefinitions = function _transformArgumentDefinitions(argumentDefinitions) {
-    var _this3 = this;
-
-    return argumentDefinitions.map(function (def) {
-      var name = getName(def.variable);
-      var type = assertInputType(getTypeFromAST(_this3._schema, def.type));
-      var defaultLiteral = def.defaultValue ? _this3._transformValue(def.defaultValue) : null;
-      require('fbjs/lib/invariant')(defaultLiteral === null || defaultLiteral.kind === 'Literal', 'RelayParser: Expected null or Literal default value, got: `%s`. ' + 'Source: %s.', defaultLiteral && defaultLiteral.kind, _this3._getErrorContext());
-      return {
-        kind: 'LocalArgumentDefinition',
-        metadata: null,
-        name: name,
-        defaultValue: defaultLiteral ? defaultLiteral.value : null,
-        type: type
-      };
-    });
-  };
-
-  RelayParser.prototype._transformSelections = function _transformSelections(selectionSet, parentType) {
-    var _this4 = this;
-
-    return selectionSet.selections.map(function (selection) {
-      var node = void 0;
-      if (selection.kind === 'Field') {
-        node = _this4._transformField(selection, parentType);
-      } else if (selection.kind === 'FragmentSpread') {
-        node = _this4._transformFragmentSpread(selection, parentType);
-      } else if (selection.kind === 'InlineFragment') {
-        node = _this4._transformInlineFragment(selection, parentType);
-      } else {
-        require('fbjs/lib/invariant')(false, 'RelayParser: Unexpected AST kind `%s`. Source: %s.', selection.kind, _this4._getErrorContext());
-      }
-
-      var _splitConditions2 = _this4._splitConditions(node.directives),
-          conditions = _splitConditions2[0],
-          directives = _splitConditions2[1];
-
-      var conditionalNodes = applyConditions(conditions,
-      // $FlowFixMe(>=0.28.0)
-      [(0, _extends3['default'])({}, node, { directives: directives })]);
-      require('fbjs/lib/invariant')(conditionalNodes.length === 1, 'RelayParser: Expected exactly one conditional node, got `%s`. ' + 'Source: %s.', conditionalNodes.length, _this4._getErrorContext());
-      return conditionalNodes[0];
-    });
-  };
-
-  RelayParser.prototype._transformInlineFragment = function _transformInlineFragment(fragment, parentType) {
-    var typeCondition = assertCompositeType(fragment.typeCondition ? getTypeFromAST(this._schema, fragment.typeCondition) : parentType);
-    var directives = this._transformDirectives(fragment.directives || []);
-    var selections = this._transformSelections(fragment.selectionSet, typeCondition);
-    return {
-      kind: 'InlineFragment',
-      directives: directives,
-      metadata: null,
-      selections: selections,
-      typeCondition: typeCondition
-    };
-  };
-
-  RelayParser.prototype._transformFragmentSpread = function _transformFragmentSpread(fragment, parentType) {
-    var _this5 = this;
-
-    var fragmentName = getName(fragment);
-
-    var _partitionArray = require('fbjs/lib/partitionArray')(fragment.directives || [], function (directive) {
-      return getName(directive) !== ARGUMENTS;
-    }),
-        otherDirectives = _partitionArray[0],
-        argumentDirectives = _partitionArray[1];
+    var _this = (0, _possibleConstructorReturn3['default'])(this, _Parser.call(this, schema, definition));
 
-    require('fbjs/lib/invariant')(argumentDirectives.length <= 1, 'RelayParser: Directive %s may be used at most once in fragment ' + 'spread `...%s`. Source: %s.', ARGUMENTS, fragmentName, this._getErrorContext());
-    var args = void 0;
-    if (argumentDirectives.length) {
-      args = (argumentDirectives[0].arguments || []).map(function (arg) {
-        var argValue = arg.value;
-        require('fbjs/lib/invariant')(argValue.kind === 'Variable', 'RelayParser: All @arguments() args must be variables, got %s. ' + 'Source: %s.', argValue.kind, _this5._getErrorContext());
-
-        return {
-          kind: 'Argument',
-          metadata: null,
-          name: getName(arg),
-          value: _this5._transformVariable(argValue),
-          type: null // TODO: can't get type until referenced fragment is defined
-        };
-      });
-    }
-    var directives = this._transformDirectives(otherDirectives);
-    return {
-      kind: 'FragmentSpread',
-      args: args || [],
-      metadata: null,
-      name: fragmentName,
-      directives: directives
-    };
-  };
-
-  RelayParser.prototype._transformField = function _transformField(field, parentType) {
-    var name = getName(field);
-    var fieldDef = getFieldDefinition(this._schema, parentType, name, field);
-    require('fbjs/lib/invariant')(fieldDef, 'RelayParser: Unknown field `%s` on type `%s`. Source: %s.', name, parentType, this._getErrorContext());
-    var alias = field.alias ? field.alias.value : null;
-    var args = this._transformArguments(field.arguments || [], fieldDef.args);
-
-    var _partitionArray2 = require('fbjs/lib/partitionArray')(field.directives || [], function (directive) {
-      return getName(directive) !== CLIENT_FIELD;
-    }),
-        otherDirectives = _partitionArray2[0],
-        clientFieldDirectives = _partitionArray2[1];
-
-    var directives = this._transformDirectives(otherDirectives);
-    var type = assertOutputType(fieldDef.type);
-    var handles = this._transformHandle(name, args, clientFieldDirectives);
-    if (isLeafType(getNamedType(type))) {
-      require('fbjs/lib/invariant')(!field.selectionSet || !field.selectionSet.selections || !field.selectionSet.selections.length, 'RelayParser: Expected no selections for scalar field `%s` on type ' + '`%s`. Source: %s.', name, this._getErrorContext());
-      return {
-        kind: 'ScalarField',
-        alias: alias,
-        args: args,
-        directives: directives,
-        handles: handles,
-        metadata: null,
-        name: name,
-        type: assertScalarFieldType(type)
-      };
-    } else {
-      var selections = field.selectionSet ? this._transformSelections(field.selectionSet, type) : null;
-      require('fbjs/lib/invariant')(selections && selections.length, 'RelayParser: Expected at least one selection for non-scalar field ' + '`%s` on type `%s`. Source: %s.', name, type, this._getErrorContext());
-      return {
-        kind: 'LinkedField',
-        alias: alias,
-        args: args,
-        directives: directives,
-        handles: handles,
-        metadata: null,
-        name: name,
-        selections: selections,
-        type: type
-      };
-    }
-  };
-
-  RelayParser.prototype._transformHandle = function _transformHandle(fieldName, fieldArgs, clientFieldDirectives) {
-    var _this6 = this;
-
-    var handles = void 0;
-    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 = _this6._transformValue(handleArgument.value);
-        require('fbjs/lib/invariant')(maybeHandle.kind === 'Literal' && typeof maybeHandle.value === 'string', 'RelayParser: Expected the %s argument to @%s to be a literal ' + 'string, got `%s` on field `%s`. Source: %s.', CLIENT_FIELD_HANDLE, CLIENT_FIELD, maybeHandle, fieldName, _this6._getErrorContext());
-        _name = maybeHandle.value;
-
-        var keyArgument = (clientFieldDirective.arguments || []).find(function (arg) {
-          return getName(arg) === CLIENT_FIELD_KEY;
-        });
-        if (keyArgument) {
-          var maybeKey = _this6._transformValue(keyArgument.value);
-          require('fbjs/lib/invariant')(maybeKey.kind === 'Literal' && typeof maybeKey.value === 'string', 'RelayParser: Expected %s argument to @%s to be a literal ' + 'string, got `%s` on field `%s`. Source: %s.', CLIENT_FIELD_KEY, CLIENT_FIELD, maybeKey, fieldName, _this6._getErrorContext());
-          key = maybeKey.value;
-        }
-        var filtersArgument = (clientFieldDirective.arguments || []).find(function (arg) {
-          return getName(arg) === CLIENT_FIELD_FILTERS;
-        });
-        if (filtersArgument) {
-          var maybeFilters = _this6._transformValue(filtersArgument.value);
-          require('fbjs/lib/invariant')(maybeFilters.kind === 'Literal' && Array.isArray(maybeFilters.value) && maybeFilters.value.every(function (filter) {
-            return fieldArgs.some(function (fieldArg) {
-              return fieldArg.name === filter;
-            });
-          }), 'RelayParser: Expected %s argument to @%s to be an array of ' + 'argument names on field `%s`, but get %s. Source: %s.', CLIENT_FIELD_FILTERS, CLIENT_FIELD, fieldName, maybeFilters, _this6._getErrorContext());
-          // $FlowFixMe
-          filters = maybeFilters.value;
-        }
-        handles = handles || [];
-        handles.push({ name: _name, key: key, filters: filters });
-      }
-    });
-    return handles;
-  };
-
-  RelayParser.prototype._transformDirectives = function _transformDirectives(directives) {
-    var _this7 = this;
-
-    return directives.map(function (directive) {
-      var name = getName(directive);
-      var directiveDef = _this7._schema.getDirective(name);
-      require('fbjs/lib/invariant')(directiveDef, 'RelayParser: Unknown directive `@%s`. Source: %s.', name, _this7._getErrorContext());
-      var args = _this7._transformArguments(directive.arguments || [], directiveDef.args);
-      return {
-        kind: 'Directive',
-        metadata: null,
-        name: name,
-        args: args
-      };
-    });
-  };
-
-  RelayParser.prototype._transformArguments = function _transformArguments(args, argumentDefinitions) {
-    var _this8 = this;
-
-    return args.map(function (arg) {
-      var argName = getName(arg);
-      var argDef = argumentDefinitions.find(function (def) {
-        return def.name === argName;
-      });
-      require('fbjs/lib/invariant')(argDef, 'RelayParser: Unknown argument `%s`. Source: %s.', argName, _this8._getErrorContext());
-      var value = _this8._transformValue(arg.value, argDef.type);
-      return {
-        kind: 'Argument',
-        metadata: null,
-        name: argName,
-        value: value,
-        type: argDef.type
-      };
-    });
-  };
-
-  RelayParser.prototype._splitConditions = function _splitConditions(mixedDirectives) {
-    var _this9 = this;
-
-    var conditions = [];
-    var directives = [];
-    mixedDirectives.forEach(function (directive) {
-      if (directive.name === INCLUDE || directive.name === SKIP) {
-        var passingValue = directive.name === INCLUDE;
-        var arg = directive.args[0];
-        require('fbjs/lib/invariant')(arg && arg.name === IF, 'RelayParser: Expected an `if` argument to @%s. Source: %s.', directive.name, _this9._getErrorContext());
-        require('fbjs/lib/invariant')(arg.value.kind === 'Variable' || arg.value.kind === 'Literal', 'RelayParser: Expected the `if` argument to @%s to be a variable. ' + 'Source: %s.', directive.name, _this9._getErrorContext());
-        conditions.push({
-          kind: 'Condition',
-          condition: arg.value,
-          metadata: null,
-          passingValue: passingValue,
-          selections: []
-        });
-      } else {
-        directives.push(directive);
-      }
-    });
-    var sortedConditions = [].concat(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, directives];
-  };
-
-  RelayParser.prototype._transformVariable = function _transformVariable(ast, type) {
-    var variableName = getName(ast);
-    this._recordVariableReference(variableName, type);
-    return {
-      kind: 'Variable',
-      metadata: null,
-      variableName: variableName
-    };
-  };
+    _this._definition = definition;
+    _this._schema = schema;
+    return _this;
+  }
 
   /**
-   * Transforms AST values into IR values, extracting the literal JS values of any
-   * subtree of the AST that does not contain a variable.
+   * Find the definition of a field of the specified type.
    */
 
 
-  RelayParser.prototype._transformValue = function _transformValue(ast, type) {
-    var _this10 = this;
-
-    switch (ast.kind) {
-      case 'IntValue':
-        return {
-          kind: 'Literal',
-          metadata: null,
-          value: parseInt(ast.value, 10)
-        };
-      case 'FloatValue':
-        return {
-          kind: 'Literal',
-          metadata: null,
-          value: parseFloat(ast.value)
-        };
-      case 'StringValue':
-      case 'BooleanValue':
-      case 'EnumValue':
-        return {
-          kind: 'Literal',
-          metadata: null,
-          value: ast.value
-        };
-      case 'ListValue':
-        var itemType = void 0;
-        if (type) {
-          var listType = getNullableType(type);
-          // The user entered a list, a `type` was expected; this is only valid
-          // if `type` is a List.
-          require('fbjs/lib/invariant')(listType instanceof GraphQLList, 'RelayParser: Expected a value matching type `%s`, but ' + 'got a list value. Source: %s.', type, this._getErrorContext());
-          itemType = assertInputType(listType.ofType);
-        }
-        var literalList = [];
-        var items = [];
-        var areAllItemsScalar = true;
-        ast.values.forEach(function (item) {
-          var itemValue = _this10._transformValue(item, itemType);
-          if (itemValue.kind === 'Literal') {
-            literalList.push(itemValue.value);
-          }
-          items.push(itemValue);
-          areAllItemsScalar = areAllItemsScalar && itemValue.kind === 'Literal';
-        });
-        if (areAllItemsScalar) {
-          return {
-            kind: 'Literal',
-            metadata: null,
-            value: literalList
-          };
-        } else {
-          return {
-            kind: 'ListValue',
-            metadata: null,
-            items: items
-          };
-        }
-      case 'NullValue':
-        return {
-          kind: 'Literal',
-          metadata: null,
-          value: null
-        };
-      case 'ObjectValue':
-        var literalObject = {};
-        var fields = [];
-        var areAllFieldsScalar = true;
-        ast.fields.forEach(function (field) {
-          var fieldName = getName(field);
-          var fieldType = void 0;
-          if (type) {
-            var objectType = getNullableType(type);
-            // The user entered an object, a `type` was expected; this is only
-            // valid if `type` is an Object.
-            require('fbjs/lib/invariant')(objectType instanceof GraphQLInputObjectType, 'RelayParser: Expected a value matching type `%s`, but ' + 'got an object value. Source: %s.', type, _this10._getErrorContext());
-            var fieldConfig = objectType.getFields()[fieldName];
-            require('fbjs/lib/invariant')(fieldConfig, 'RelayParser: Unknown field `%s` on type `%s`. Source: %s.', fieldName, type, _this10._getErrorContext());
-            fieldType = assertInputType(fieldConfig.type);
-          }
-          var fieldValue = _this10._transformValue(field.value, fieldType);
-          if (fieldValue.kind === 'Literal') {
-            literalObject[field.name.value] = fieldValue.value;
-          }
-          fields.push({
-            kind: 'ObjectFieldValue',
-            metadata: null,
-            name: fieldName,
-            value: fieldValue
-          });
-          areAllFieldsScalar = areAllFieldsScalar && fieldValue.kind === 'Literal';
-        });
-        if (areAllFieldsScalar) {
-          return {
-            kind: 'Literal',
-            metadata: null,
-            value: literalObject
-          };
-        } else {
-          return {
-            kind: 'ObjectValue',
-            metadata: null,
-            fields: fields
-          };
-        }
-      case 'Variable':
-        return this._transformVariable(ast, type);
-      // eslint-disable: no-fallthrough
-      default:
-        require('fbjs/lib/invariant')(false, 'RelayParser: Unknown ast kind: %s. Source: %s.', ast.kind, this._getErrorContext());
-      // eslint-enable
+  RelayParser.prototype.getFieldDefinition = function getFieldDefinition(parentType, fieldName, fieldAST) {
+    var schemaFieldDef = _Parser.prototype.getFieldDefinition.call(this, parentType, fieldName, fieldAST);
+    if (!schemaFieldDef) {
+      var type = getRawType(parentType);
+      schemaFieldDef = getClassicFieldDefinition(this._schema, type, fieldName, fieldAST);
     }
+    return schemaFieldDef || null;
   };
 
   return RelayParser;
-}();
-
-function isScalarFieldType(type) {
-  var namedType = getNamedType(type);
-  return namedType instanceof GraphQLScalarType || namedType instanceof GraphQLEnumType;
-}
-
-function assertScalarFieldType(type) {
-  require('fbjs/lib/invariant')(isScalarFieldType(type), 'Expected %s to be a Scalar Field type.', type);
-  return type;
-}
-
-function applyConditions(conditions, selections) {
-  var nextSelections = selections;
-  conditions.forEach(function (condition) {
-    nextSelections = [(0, _extends3['default'])({}, condition, {
-      selections: nextSelections
-    })];
-  });
-  return nextSelections;
-}
+}(Parser);
 
 function getName(ast) {
   var name = ast.name ? ast.name.value : null;
@@ -653,32 +65,6 @@ function getName(ast) {
   return name;
 }
 
-/**
- * Find the definition of a field of the specified type.
- */
-function getFieldDefinition(schema, parentType, fieldName, fieldAST) {
-  var type = getRawType(parentType);
-  var isQueryType = type === schema.getQueryType();
-  var hasTypeName = type instanceof GraphQLObjectType || type instanceof GraphQLInterfaceType || type instanceof GraphQLUnionType;
-
-  var schemaFieldDef = void 0;
-  if (isQueryType && fieldName === SchemaMetaFieldDef.name) {
-    schemaFieldDef = SchemaMetaFieldDef;
-  } else if (isQueryType && fieldName === TypeMetaFieldDef.name) {
-    schemaFieldDef = TypeMetaFieldDef;
-  } else if (hasTypeName && fieldName === TypeNameMetaFieldDef.name) {
-    schemaFieldDef = TypeNameMetaFieldDef;
-  } else if (type instanceof GraphQLInterfaceType || type instanceof GraphQLObjectType) {
-    schemaFieldDef = type.getFields()[fieldName];
-  }
-
-  if (!schemaFieldDef) {
-    schemaFieldDef = getClassicFieldDefinition(schema, type, fieldName, fieldAST);
-  }
-
-  return schemaFieldDef || null;
-}
-
 function getClassicFieldDefinition(schema, type, fieldName, fieldAST) {
   if (isAbstractType(type) && fieldAST && fieldAST.directives && fieldAST.directives.some(function (directive) {
     return getName(directive) === 'fixme_fat_interface';
@@ -715,7 +101,4 @@ function getClassicFieldDefinition(schema, type, fieldName, fieldAST) {
   }
 }
 
-module.exports = {
-  parse: parseRelay,
-  transform: transform
-};
+module.exports = RelayParser;