static.vendor.graphiql.graphiql-subscriptions-fetcher-browser-client.js Maven / Gradle / Ivy
var GraphiQLSubscriptionsFetcher =
/******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/
var installedModules = {}
/******/
/******/ // The require function
/******/
function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/
if (installedModules[moduleId])
/******/{
return installedModules[moduleId].exports
}
/******/
/******/ // Create a new module (and put it into the cache)
/******/
var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/
}
/******/
/******/ // Execute the module function
/******/
modules[moduleId].call(module.exports, module, module.exports, __webpack_require__)
/******/
/******/ // Flag the module as loaded
/******/
module.l = true
/******/
/******/ // Return the exports of the module
/******/
return module.exports
/******/
}
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/
__webpack_require__.m = modules
/******/
/******/ // expose the module cache
/******/
__webpack_require__.c = installedModules
/******/
/******/ // identity function for calling harmony imports with the correct context
/******/
__webpack_require__.i = function(value) {
return value
}
/******/
/******/ // define getter function for harmony exports
/******/
__webpack_require__.d = function(exports, name, getter) {
/******/
if (!__webpack_require__.o(exports, name)) {
/******/
Object.defineProperty(exports, name, {
/******/ configurable: false,
/******/ enumerable: true,
/******/ get: getter
/******/
})
/******/
}
/******/
}
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/
__webpack_require__.n = function(module) {
/******/
var getter = module && module.__esModule ?
/******/ function getDefault() {
return module['default']
} :
/******/ function getModuleExports() {
return module
}
/******/
__webpack_require__.d(getter, 'a', getter)
/******/
return getter
/******/
}
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/
__webpack_require__.o = function(object, property) {
return Object.prototype.hasOwnProperty.call(object, property)
}
/******/
/******/ // __webpack_public_path__
/******/
__webpack_require__.p = ""
/******/
/******/ // Load entry module and return exports
/******/
return __webpack_require__(__webpack_require__.s = 37)
/******/
})
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
var _GraphQLError = __webpack_require__(13)
Object.defineProperty(exports, 'GraphQLError', {
enumerable: true,
get: function get() {
return _GraphQLError.GraphQLError
}
})
var _syntaxError = __webpack_require__(40)
Object.defineProperty(exports, 'syntaxError', {
enumerable: true,
get: function get() {
return _syntaxError.syntaxError
}
})
var _locatedError = __webpack_require__(39)
Object.defineProperty(exports, 'locatedError', {
enumerable: true,
get: function get() {
return _locatedError.locatedError
}
})
var _formatError = __webpack_require__(38)
Object.defineProperty(exports, 'formatError', {
enumerable: true,
get: function get() {
return _formatError.formatError
}
})
/***/
}),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.GraphQLNonNull = exports.GraphQLList = exports.GraphQLInputObjectType = exports.GraphQLEnumType = exports.GraphQLUnionType = exports.GraphQLInterfaceType = exports.GraphQLObjectType = exports.GraphQLScalarType = undefined
var _extends = Object.assign || function(target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i]
for (var key in source) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key]
}
}
}
return target
}
exports.isType = isType
exports.assertType = assertType
exports.isInputType = isInputType
exports.assertInputType = assertInputType
exports.isOutputType = isOutputType
exports.assertOutputType = assertOutputType
exports.isLeafType = isLeafType
exports.assertLeafType = assertLeafType
exports.isCompositeType = isCompositeType
exports.assertCompositeType = assertCompositeType
exports.isAbstractType = isAbstractType
exports.assertAbstractType = assertAbstractType
exports.getNullableType = getNullableType
exports.isNamedType = isNamedType
exports.assertNamedType = assertNamedType
exports.getNamedType = getNamedType
var _invariant = __webpack_require__(3)
var _invariant2 = _interopRequireDefault(_invariant)
var _isNullish = __webpack_require__(6)
var _isNullish2 = _interopRequireDefault(_isNullish)
var _kinds = __webpack_require__(2)
var _assertValidName = __webpack_require__(28)
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function")
}
}
/**
* Copyright (c) 2015, 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.
*/
// Predicates & Assertions
/**
* These are all of the possible kinds of types.
*/
function isType(type) {
return type instanceof GraphQLScalarType || type instanceof GraphQLObjectType || type
instanceof GraphQLInterfaceType || type instanceof GraphQLUnionType || type instanceof GraphQLEnumType
|| type instanceof GraphQLInputObjectType || type instanceof GraphQLList || type
instanceof GraphQLNonNull
}
function assertType(type) {
(0, _invariant2.default)(isType(type), 'Expected ' + String(type) + ' to be a GraphQL type.')
return type
}
/**
* These types may be used as input types for arguments and directives.
*/
function isInputType(type) {
var namedType = getNamedType(type)
return namedType instanceof GraphQLScalarType || namedType instanceof GraphQLEnumType || namedType
instanceof GraphQLInputObjectType
}
function assertInputType(type) {
(0, _invariant2.default)(isInputType(type), 'Expected ' + String(type) + ' to be a GraphQL input type.')
return type
}
/**
* These types may be used as output types as the result of fields.
*/
function isOutputType(type) {
var namedType = getNamedType(type)
return namedType instanceof GraphQLScalarType || namedType instanceof GraphQLObjectType || namedType
instanceof GraphQLInterfaceType || namedType instanceof GraphQLUnionType || namedType
instanceof GraphQLEnumType
}
function assertOutputType(type) {
(0, _invariant2.default)(isOutputType(type), 'Expected ' + String(type) + ' to be a GraphQL output type.')
return type
}
/**
* These types may describe types which may be leaf values.
*/
function isLeafType(type) {
var namedType = getNamedType(type)
return namedType instanceof GraphQLScalarType || namedType instanceof GraphQLEnumType
}
function assertLeafType(type) {
(0, _invariant2.default)(isLeafType(type), 'Expected ' + String(type) + ' to be a GraphQL leaf type.')
return type
}
/**
* These types may describe the parent context of a selection set.
*/
function isCompositeType(type) {
return type instanceof GraphQLObjectType || type instanceof GraphQLInterfaceType || type
instanceof GraphQLUnionType
}
function assertCompositeType(type) {
(0, _invariant2.default)(isCompositeType(type),
'Expected ' + String(type) + ' to be a GraphQL composite type.')
return type
}
/**
* These types may describe the parent context of a selection set.
*/
function isAbstractType(type) {
return type instanceof GraphQLInterfaceType || type instanceof GraphQLUnionType
}
function assertAbstractType(type) {
(0, _invariant2.default)(isAbstractType(type),
'Expected ' + String(type) + ' to be a GraphQL abstract type.')
return type
}
/**
* These types can all accept null as a value.
*/
function getNullableType(type) {
return type instanceof GraphQLNonNull ? type.ofType : type
}
/**
* These named types do not include modifiers like List or NonNull.
*/
function isNamedType(type) {
return type instanceof GraphQLScalarType || type instanceof GraphQLObjectType || type
instanceof GraphQLInterfaceType || type instanceof GraphQLUnionType || type instanceof GraphQLEnumType
|| type instanceof GraphQLInputObjectType
}
function assertNamedType(type) {
(0, _invariant2.default)(isNamedType(type), 'Expected ' + String(type) + ' to be a GraphQL named type.')
return type
}
function getNamedType(type) {
var unmodifiedType = type
while (unmodifiedType instanceof GraphQLList || unmodifiedType instanceof GraphQLNonNull) {
unmodifiedType = unmodifiedType.ofType
}
return unmodifiedType
}
/**
* Used while defining GraphQL types to allow for circular references in
* otherwise immutable type definitions.
*/
function resolveThunk(thunk) {
return typeof thunk === 'function' ? thunk() : thunk
}
/**
* Scalar Type Definition
*
* The leaf values of any request and input values to arguments are
* Scalars (or Enums) and are defined with a name and a series of functions
* used to parse input from ast or variables and to ensure validity.
*
* Example:
*
* const OddType = new GraphQLScalarType({
* name: 'Odd',
* serialize(value) {
* return value % 2 === 1 ? value : null;
* }
* });
*
*/
var GraphQLScalarType = exports.GraphQLScalarType = function() {
function GraphQLScalarType(config) {
_classCallCheck(this, GraphQLScalarType);
(0, _assertValidName.assertValidName)(config.name)
this.name = config.name
this.description = config.description;
(0, _invariant2.default)(typeof config.serialize === 'function',
this.name + ' must provide "serialize" function. If this custom Scalar '
+ 'is also used as an input type, ensure "parseValue" and "parseLiteral" '
+ 'functions are also provided.')
if (config.parseValue || config.parseLiteral) {
(0, _invariant2.default)(
typeof config.parseValue === 'function' && typeof config.parseLiteral === 'function',
this.name + ' must provide both "parseValue" and "parseLiteral" ' + 'functions.')
}
this._scalarConfig = config
}
// Serializes an internal value to include in a response.
GraphQLScalarType.prototype.serialize = function serialize(value) {
var serializer = this._scalarConfig.serialize
return serializer(value)
}
// Parses an externally provided value to use as an input.
GraphQLScalarType.prototype.parseValue = function parseValue(value) {
var parser = this._scalarConfig.parseValue
return parser ? parser(value) : null
}
// Parses an externally provided literal value to use as an input.
GraphQLScalarType.prototype.parseLiteral = function parseLiteral(valueNode) {
var parser = this._scalarConfig.parseLiteral
return parser ? parser(valueNode) : null
}
GraphQLScalarType.prototype.toString = function toString() {
return this.name
}
return GraphQLScalarType
}()
// Also provide toJSON and inspect aliases for toString.
GraphQLScalarType.prototype.toJSON = GraphQLScalarType.prototype.inspect = GraphQLScalarType.prototype.toString
/**
* Object Type Definition
*
* Almost all of the GraphQL types you define will be object types. Object types
* have a name, but most importantly describe their fields.
*
* Example:
*
* const AddressType = new GraphQLObjectType({
* name: 'Address',
* fields: {
* street: { type: GraphQLString },
* number: { type: GraphQLInt },
* formatted: {
* type: GraphQLString,
* resolve(obj) {
* return obj.number + ' ' + obj.street
* }
* }
* }
* });
*
* When two types need to refer to each other, or a type needs to refer to
* itself in a field, you can use a function expression (aka a closure or a
* thunk) to supply the fields lazily.
*
* Example:
*
* const PersonType = new GraphQLObjectType({
* name: 'Person',
* fields: () => ({
* name: { type: GraphQLString },
* bestFriend: { type: PersonType },
* })
* });
*
*/
var GraphQLObjectType = exports.GraphQLObjectType = function() {
function GraphQLObjectType(config) {
_classCallCheck(this, GraphQLObjectType);
(0, _assertValidName.assertValidName)(config.name, config.isIntrospection)
this.name = config.name
this.description = config.description
if (config.isTypeOf) {
(0, _invariant2.default)(typeof config.isTypeOf === 'function',
this.name + ' must provide "isTypeOf" as a function.')
}
this.isTypeOf = config.isTypeOf
this._typeConfig = config
}
GraphQLObjectType.prototype.getFields = function getFields() {
return this._fields || (this._fields = defineFieldMap(this, this._typeConfig.fields))
}
GraphQLObjectType.prototype.getInterfaces = function getInterfaces() {
return this._interfaces || (this._interfaces = defineInterfaces(this, this._typeConfig.interfaces))
}
GraphQLObjectType.prototype.toString = function toString() {
return this.name
}
return GraphQLObjectType
}()
// Also provide toJSON and inspect aliases for toString.
GraphQLObjectType.prototype.toJSON = GraphQLObjectType.prototype.inspect = GraphQLObjectType.prototype.toString
function defineInterfaces(type, interfacesThunk) {
var interfaces = resolveThunk(interfacesThunk)
if (!interfaces) {
return []
}
(0, _invariant2.default)(Array.isArray(interfaces),
type.name + ' interfaces must be an Array or a function which returns ' + 'an Array.')
interfaces.forEach(function(iface) {
(0, _invariant2.default)(iface instanceof GraphQLInterfaceType,
type.name + ' may only implement Interface types, it cannot ' + ('implement: ' + String(iface) + '.'))
if (typeof iface.resolveType !== 'function') {
(0, _invariant2.default)(typeof type.isTypeOf === 'function',
'Interface Type ' + iface.name + ' does not provide a "resolveType" '
+ ('function and implementing Type ' + type.name + ' does not provide a ')
+ '"isTypeOf" function. There is no way to resolve this implementing ' + 'type during execution.')
}
})
return interfaces
}
function defineFieldMap(type, fieldsThunk) {
var fieldMap = resolveThunk(fieldsThunk);
(0, _invariant2.default)(isPlainObj(fieldMap),
type.name + ' fields must be an object with field names as keys or a '
+ 'function which returns such an object.')
var fieldNames = Object.keys(fieldMap);
(0, _invariant2.default)(fieldNames.length > 0,
type.name + ' fields must be an object with field names as keys or a '
+ 'function which returns such an object.')
var resultFieldMap = {}
fieldNames.forEach(function(fieldName) {
(0, _assertValidName.assertValidName)(fieldName)
var fieldConfig = fieldMap[fieldName];
(0, _invariant2.default)(!fieldConfig.hasOwnProperty('isDeprecated'),
type.name + '.' + fieldName + ' should provide "deprecationReason" instead ' + 'of "isDeprecated".')
var field = _extends({}, fieldConfig, {
isDeprecated: Boolean(fieldConfig.deprecationReason),
name: fieldName
});
(0, _invariant2.default)(isOutputType(field.type),
type.name + '.' + fieldName + ' field type must be Output Type but ' + ('got: ' + String(field.type)
+ '.'));
(0, _invariant2.default)(isValidResolver(field.resolve),
type.name + '.' + fieldName + ' field resolver must be a function if ' + ('provided, but got: '
+ String(field.resolve) + '.'))
var argsConfig = fieldConfig.args
if (!argsConfig) {
field.args = []
} else {
(0, _invariant2.default)(isPlainObj(argsConfig),
type.name + '.' + fieldName + ' args must be an object with argument ' + 'names as keys.')
field.args = Object.keys(argsConfig).map(function(argName) {
(0, _assertValidName.assertValidName)(argName)
var arg = argsConfig[argName];
(0, _invariant2.default)(isInputType(arg.type),
type.name + '.' + fieldName + '(' + argName + ':) argument type must be ' + ('Input Type but got: '
+ String(arg.type) + '.'))
return {
name: argName,
description: arg.description === undefined ? null : arg.description,
type: arg.type,
defaultValue: arg.defaultValue
}
})
}
resultFieldMap[fieldName] = field
})
return resultFieldMap
}
function isPlainObj(obj) {
return obj && typeof obj === 'object' && !Array.isArray(obj)
}
// If a resolver is defined, it must be a function.
function isValidResolver(resolver) {
return resolver == null || typeof resolver === 'function'
}
/**
* Interface Type Definition
*
* When a field can return one of a heterogeneous set of types, a Interface type
* is used to describe what types are possible, what fields are in common across
* all types, as well as a function to determine which type is actually used
* when the field is resolved.
*
* Example:
*
* const EntityType = new GraphQLInterfaceType({
* name: 'Entity',
* fields: {
* name: { type: GraphQLString }
* }
* });
*
*/
var GraphQLInterfaceType = exports.GraphQLInterfaceType = function() {
function GraphQLInterfaceType(config) {
_classCallCheck(this, GraphQLInterfaceType);
(0, _assertValidName.assertValidName)(config.name)
this.name = config.name
this.description = config.description
if (config.resolveType) {
(0, _invariant2.default)(typeof config.resolveType === 'function',
this.name + ' must provide "resolveType" as a function.')
}
this.resolveType = config.resolveType
this._typeConfig = config
}
GraphQLInterfaceType.prototype.getFields = function getFields() {
return this._fields || (this._fields = defineFieldMap(this, this._typeConfig.fields))
}
GraphQLInterfaceType.prototype.toString = function toString() {
return this.name
}
return GraphQLInterfaceType
}()
// Also provide toJSON and inspect aliases for toString.
GraphQLInterfaceType.prototype.toJSON = GraphQLInterfaceType.prototype.inspect = GraphQLInterfaceType.prototype.toString
/**
* Union Type Definition
*
* When a field can return one of a heterogeneous set of types, a Union type
* is used to describe what types are possible as well as providing a function
* to determine which type is actually used when the field is resolved.
*
* Example:
*
* const PetType = new GraphQLUnionType({
* name: 'Pet',
* types: [ DogType, CatType ],
* resolveType(value) {
* if (value instanceof Dog) {
* return DogType;
* }
* if (value instanceof Cat) {
* return CatType;
* }
* }
* });
*
*/
var GraphQLUnionType = exports.GraphQLUnionType = function() {
function GraphQLUnionType(config) {
_classCallCheck(this, GraphQLUnionType);
(0, _assertValidName.assertValidName)(config.name)
this.name = config.name
this.description = config.description
if (config.resolveType) {
(0, _invariant2.default)(typeof config.resolveType === 'function',
this.name + ' must provide "resolveType" as a function.')
}
this.resolveType = config.resolveType
this._typeConfig = config
}
GraphQLUnionType.prototype.getTypes = function getTypes() {
return this._types || (this._types = defineTypes(this, this._typeConfig.types))
}
GraphQLUnionType.prototype.toString = function toString() {
return this.name
}
return GraphQLUnionType
}()
// Also provide toJSON and inspect aliases for toString.
GraphQLUnionType.prototype.toJSON = GraphQLUnionType.prototype.inspect = GraphQLUnionType.prototype.toString
function defineTypes(unionType, typesThunk) {
var types = resolveThunk(typesThunk);
(0, _invariant2.default)(Array.isArray(types) && types.length > 0,
'Must provide Array of types or a function which returns ' + ('such an array for Union ' + unionType.name
+ '.'))
types.forEach(function(objType) {
(0, _invariant2.default)(objType instanceof GraphQLObjectType,
unionType.name + ' may only contain Object types, it cannot contain: ' + (String(objType) + '.'))
if (typeof unionType.resolveType !== 'function') {
(0, _invariant2.default)(typeof objType.isTypeOf === 'function',
'Union type "' + unionType.name + '" does not provide a "resolveType" '
+ ('function and possible type "' + objType.name + '" does not provide an ')
+ '"isTypeOf" function. There is no way to resolve this possible type ' + 'during execution.')
}
})
return types
}
/**
* Enum Type Definition
*
* Some leaf values of requests and input values are Enums. GraphQL serializes
* Enum values as strings, however internally Enums can be represented by any
* kind of type, often integers.
*
* Example:
*
* const RGBType = new GraphQLEnumType({
* name: 'RGB',
* values: {
* RED: { value: 0 },
* GREEN: { value: 1 },
* BLUE: { value: 2 }
* }
* });
*
* Note: If a value is not provided in a definition, the name of the enum value
* will be used as its internal value.
*/
var GraphQLEnumType /* */ = exports.GraphQLEnumType = function() {
function GraphQLEnumType(config /* */) {
_classCallCheck(this, GraphQLEnumType)
this.name = config.name;
(0, _assertValidName.assertValidName)(config.name, config.isIntrospection)
this.description = config.description
this._values = defineEnumValues(this, config.values)
this._enumConfig = config
}
GraphQLEnumType.prototype.getValues = function getValues() {
return this._values
}
GraphQLEnumType.prototype.getValue = function getValue(name) {
return this._getNameLookup()[name]
}
GraphQLEnumType.prototype.serialize = function serialize(value /* T */) {
var enumValue = this._getValueLookup().get(value)
return enumValue ? enumValue.name : null
}
GraphQLEnumType.prototype.parseValue = function parseValue(value) /* T */ {
if (typeof value === 'string') {
var enumValue = this._getNameLookup()[value]
if (enumValue) {
return enumValue.value
}
}
}
GraphQLEnumType.prototype.parseLiteral = function parseLiteral(valueNode) /* T */ {
if (valueNode.kind === _kinds.ENUM) {
var enumValue = this._getNameLookup()[valueNode.value]
if (enumValue) {
return enumValue.value
}
}
}
GraphQLEnumType.prototype._getValueLookup = function _getValueLookup() {
var _this = this
if (!this._valueLookup) {
(function() {
var lookup = new Map()
_this.getValues().forEach(function(value) {
lookup.set(value.value, value)
})
_this._valueLookup = lookup
})()
}
return this._valueLookup
}
GraphQLEnumType.prototype._getNameLookup = function _getNameLookup() {
var _this2 = this
if (!this._nameLookup) {
(function() {
var lookup = Object.create(null)
_this2.getValues().forEach(function(value) {
lookup[value.name] = value
})
_this2._nameLookup = lookup
})()
}
return this._nameLookup
}
GraphQLEnumType.prototype.toString = function toString() {
return this.name
}
return GraphQLEnumType
}()
// Also provide toJSON and inspect aliases for toString.
GraphQLEnumType.prototype.toJSON = GraphQLEnumType.prototype.inspect = GraphQLEnumType.prototype.toString
function defineEnumValues(type, valueMap /* */
) {
(0, _invariant2.default)(isPlainObj(valueMap),
type.name + ' values must be an object with value names as keys.')
var valueNames = Object.keys(valueMap);
(0, _invariant2.default)(valueNames.length > 0,
type.name + ' values must be an object with value names as keys.')
return valueNames.map(function(valueName) {
(0, _assertValidName.assertValidName)(valueName)
var value = valueMap[valueName];
(0, _invariant2.default)(isPlainObj(value),
type.name + '.' + valueName + ' must refer to an object with a "value" key '
+ ('representing an internal value but got: ' + String(value) + '.'));
(0, _invariant2.default)(!value.hasOwnProperty('isDeprecated'),
type.name + '.' + valueName + ' should provide "deprecationReason" instead ' + 'of "isDeprecated".')
return {
name: valueName,
description: value.description,
isDeprecated: Boolean(value.deprecationReason),
deprecationReason: value.deprecationReason,
value: (0, _isNullish2.default)(value.value) ? valueName : value.value
}
})
} /* */
/**
* Input Object Type Definition
*
* An input object defines a structured collection of fields which may be
* supplied to a field argument.
*
* Using `NonNull` will ensure that a value must be provided by the query
*
* Example:
*
* const GeoPoint = new GraphQLInputObjectType({
* name: 'GeoPoint',
* fields: {
* lat: { type: new GraphQLNonNull(GraphQLFloat) },
* lon: { type: new GraphQLNonNull(GraphQLFloat) },
* alt: { type: GraphQLFloat, defaultValue: 0 },
* }
* });
*
*/
var GraphQLInputObjectType = exports.GraphQLInputObjectType = function() {
function GraphQLInputObjectType(config) {
_classCallCheck(this, GraphQLInputObjectType);
(0, _assertValidName.assertValidName)(config.name)
this.name = config.name
this.description = config.description
this._typeConfig = config
}
GraphQLInputObjectType.prototype.getFields = function getFields() {
return this._fields || (this._fields = this._defineFieldMap())
}
GraphQLInputObjectType.prototype._defineFieldMap = function _defineFieldMap() {
var _this3 = this
var fieldMap = resolveThunk(this._typeConfig.fields);
(0, _invariant2.default)(isPlainObj(fieldMap),
this.name + ' fields must be an object with field names as keys or a '
+ 'function which returns such an object.')
var fieldNames = Object.keys(fieldMap);
(0, _invariant2.default)(fieldNames.length > 0,
this.name + ' fields must be an object with field names as keys or a '
+ 'function which returns such an object.')
var resultFieldMap = {}
fieldNames.forEach(function(fieldName) {
(0, _assertValidName.assertValidName)(fieldName)
var field = _extends({}, fieldMap[fieldName], {
name: fieldName
});
(0, _invariant2.default)(isInputType(field.type),
_this3.name + '.' + fieldName + ' field type must be Input Type but ' + ('got: ' + String(field.type)
+ '.'));
(0, _invariant2.default)(field.resolve == null,
_this3.name + '.' + fieldName + ' field type has a resolve property, but '
+ 'Input Types cannot define resolvers.')
resultFieldMap[fieldName] = field
})
return resultFieldMap
}
GraphQLInputObjectType.prototype.toString = function toString() {
return this.name
}
return GraphQLInputObjectType
}()
// Also provide toJSON and inspect aliases for toString.
GraphQLInputObjectType.prototype.toJSON = GraphQLInputObjectType.prototype.inspect = GraphQLInputObjectType.prototype.toString
/**
* List Modifier
*
* A list is a kind of type marker, a wrapping type which points to another
* type. Lists are often created within the context of defining the fields of
* an object type.
*
* Example:
*
* const PersonType = new GraphQLObjectType({
* name: 'Person',
* fields: () => ({
* parents: { type: new GraphQLList(Person) },
* children: { type: new GraphQLList(Person) },
* })
* })
*
*/
var GraphQLList = exports.GraphQLList = function() {
function GraphQLList(type) {
_classCallCheck(this, GraphQLList);
(0, _invariant2.default)(isType(type),
'Can only create List of a GraphQLType but got: ' + String(type) + '.')
this.ofType = type
}
GraphQLList.prototype.toString = function toString() {
return '[' + String(this.ofType) + ']'
}
return GraphQLList
}()
// Also provide toJSON and inspect aliases for toString.
GraphQLList.prototype.toJSON = GraphQLList.prototype.inspect = GraphQLList.prototype.toString
/**
* Non-Null Modifier
*
* A non-null is a kind of type marker, a wrapping type which points to another
* type. Non-null types enforce that their values are never null and can ensure
* an error is raised if this ever occurs during a request. It is useful for
* fields which you can make a strong guarantee on non-nullability, for example
* usually the id field of a database row will never be null.
*
* Example:
*
* const RowType = new GraphQLObjectType({
* name: 'Row',
* fields: () => ({
* id: { type: new GraphQLNonNull(GraphQLString) },
* })
* })
*
* Note: the enforcement of non-nullability occurs within the executor.
*/
var GraphQLNonNull = exports.GraphQLNonNull = function() {
function GraphQLNonNull(type) {
_classCallCheck(this, GraphQLNonNull);
(0, _invariant2.default)(isType(type) && !(type instanceof GraphQLNonNull),
'Can only create NonNull of a Nullable GraphQLType but got: ' + (String(type) + '.'))
this.ofType = type
}
GraphQLNonNull.prototype.toString = function toString() {
return this.ofType.toString() + '!'
}
return GraphQLNonNull
}()
// Also provide toJSON and inspect aliases for toString.
GraphQLNonNull.prototype.toJSON = GraphQLNonNull.prototype.inspect = GraphQLNonNull.prototype.toString
/***/
}),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
/**
* Copyright (c) 2015, 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.
*/
// Name
var NAME = exports.NAME = 'Name'
// Document
var DOCUMENT = exports.DOCUMENT = 'Document'
var OPERATION_DEFINITION = exports.OPERATION_DEFINITION = 'OperationDefinition'
var VARIABLE_DEFINITION = exports.VARIABLE_DEFINITION = 'VariableDefinition'
var VARIABLE = exports.VARIABLE = 'Variable'
var SELECTION_SET = exports.SELECTION_SET = 'SelectionSet'
var FIELD = exports.FIELD = 'Field'
var ARGUMENT = exports.ARGUMENT = 'Argument'
// Fragments
var FRAGMENT_SPREAD = exports.FRAGMENT_SPREAD = 'FragmentSpread'
var INLINE_FRAGMENT = exports.INLINE_FRAGMENT = 'InlineFragment'
var FRAGMENT_DEFINITION = exports.FRAGMENT_DEFINITION = 'FragmentDefinition'
// Values
var INT = exports.INT = 'IntValue'
var FLOAT = exports.FLOAT = 'FloatValue'
var STRING = exports.STRING = 'StringValue'
var BOOLEAN = exports.BOOLEAN = 'BooleanValue'
var NULL = exports.NULL = 'NullValue'
var ENUM = exports.ENUM = 'EnumValue'
var LIST = exports.LIST = 'ListValue'
var OBJECT = exports.OBJECT = 'ObjectValue'
var OBJECT_FIELD = exports.OBJECT_FIELD = 'ObjectField'
// Directives
var DIRECTIVE = exports.DIRECTIVE = 'Directive'
// Types
var NAMED_TYPE = exports.NAMED_TYPE = 'NamedType'
var LIST_TYPE = exports.LIST_TYPE = 'ListType'
var NON_NULL_TYPE = exports.NON_NULL_TYPE = 'NonNullType'
// Type System Definitions
var SCHEMA_DEFINITION = exports.SCHEMA_DEFINITION = 'SchemaDefinition'
var OPERATION_TYPE_DEFINITION = exports.OPERATION_TYPE_DEFINITION = 'OperationTypeDefinition'
// Type Definitions
var SCALAR_TYPE_DEFINITION = exports.SCALAR_TYPE_DEFINITION = 'ScalarTypeDefinition'
var OBJECT_TYPE_DEFINITION = exports.OBJECT_TYPE_DEFINITION = 'ObjectTypeDefinition'
var FIELD_DEFINITION = exports.FIELD_DEFINITION = 'FieldDefinition'
var INPUT_VALUE_DEFINITION = exports.INPUT_VALUE_DEFINITION = 'InputValueDefinition'
var INTERFACE_TYPE_DEFINITION = exports.INTERFACE_TYPE_DEFINITION = 'InterfaceTypeDefinition'
var UNION_TYPE_DEFINITION = exports.UNION_TYPE_DEFINITION = 'UnionTypeDefinition'
var ENUM_TYPE_DEFINITION = exports.ENUM_TYPE_DEFINITION = 'EnumTypeDefinition'
var ENUM_VALUE_DEFINITION = exports.ENUM_VALUE_DEFINITION = 'EnumValueDefinition'
var INPUT_OBJECT_TYPE_DEFINITION = exports.INPUT_OBJECT_TYPE_DEFINITION = 'InputObjectTypeDefinition'
// Type Extensions
var TYPE_EXTENSION_DEFINITION = exports.TYPE_EXTENSION_DEFINITION = 'TypeExtensionDefinition'
// Directive Definitions
var DIRECTIVE_DEFINITION = exports.DIRECTIVE_DEFINITION = 'DirectiveDefinition'
/***/
}),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.default = invariant
/**
* Copyright (c) 2015, 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.
*/
function invariant(condition, message) {
if (!condition) {
throw new Error(message)
}
}
/***/
}),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.print = print
var _visitor = __webpack_require__(15)
/**
* Converts an AST into a string, using one set of reasonable
* formatting rules.
*/
function print(ast) {
return (0, _visitor.visit)(ast, { leave: printDocASTReducer })
}
/**
* Copyright (c) 2015, 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.
*/
var printDocASTReducer = {
Name: function Name(node) {
return node.value
},
Variable: function Variable(node) {
return '$' + node.name
},
// Document
Document: function Document(node) {
return join(node.definitions, '\n\n') + '\n'
},
OperationDefinition: function OperationDefinition(node) {
var op = node.operation
var name = node.name
var varDefs = wrap('(', join(node.variableDefinitions, ', '), ')')
var directives = join(node.directives, ' ')
var selectionSet = node.selectionSet
// Anonymous queries with no directives or variable definitions can use
// the query short form.
return !name && !directives && !varDefs && op === 'query' ? selectionSet : join(
[op, join([name, varDefs]), directives, selectionSet], ' ')
},
VariableDefinition: function VariableDefinition(_ref) {
var variable = _ref.variable,
type = _ref.type,
defaultValue = _ref.defaultValue
return variable + ': ' + type + wrap(' = ', defaultValue)
},
SelectionSet: function SelectionSet(_ref2) {
var selections = _ref2.selections
return block(selections)
},
Field: function Field(_ref3) {
var alias = _ref3.alias,
name = _ref3.name,
args = _ref3.arguments,
directives = _ref3.directives,
selectionSet = _ref3.selectionSet
return join(
[wrap('', alias, ': ') + name + wrap('(', join(args, ', '), ')'), join(directives, ' '), selectionSet],
' ')
},
Argument: function Argument(_ref4) {
var name = _ref4.name,
value = _ref4.value
return name + ': ' + value
},
// Fragments
FragmentSpread: function FragmentSpread(_ref5) {
var name = _ref5.name,
directives = _ref5.directives
return '...' + name + wrap(' ', join(directives, ' '))
},
InlineFragment: function InlineFragment(_ref6) {
var typeCondition = _ref6.typeCondition,
directives = _ref6.directives,
selectionSet = _ref6.selectionSet
return join(['...', wrap('on ', typeCondition), join(directives, ' '), selectionSet], ' ')
},
FragmentDefinition: function FragmentDefinition(_ref7) {
var name = _ref7.name,
typeCondition = _ref7.typeCondition,
directives = _ref7.directives,
selectionSet = _ref7.selectionSet
return 'fragment ' + name + ' on ' + typeCondition + ' ' + wrap('', join(directives, ' '), ' ')
+ selectionSet
},
// Value
IntValue: function IntValue(_ref8) {
var value = _ref8.value
return value
},
FloatValue: function FloatValue(_ref9) {
var value = _ref9.value
return value
},
StringValue: function StringValue(_ref10) {
var value = _ref10.value
return JSON.stringify(value)
},
BooleanValue: function BooleanValue(_ref11) {
var value = _ref11.value
return JSON.stringify(value)
},
NullValue: function NullValue() {
return 'null'
},
EnumValue: function EnumValue(_ref12) {
var value = _ref12.value
return value
},
ListValue: function ListValue(_ref13) {
var values = _ref13.values
return '[' + join(values, ', ') + ']'
},
ObjectValue: function ObjectValue(_ref14) {
var fields = _ref14.fields
return '{' + join(fields, ', ') + '}'
},
ObjectField: function ObjectField(_ref15) {
var name = _ref15.name,
value = _ref15.value
return name + ': ' + value
},
// Directive
Directive: function Directive(_ref16) {
var name = _ref16.name,
args = _ref16.arguments
return '@' + name + wrap('(', join(args, ', '), ')')
},
// Type
NamedType: function NamedType(_ref17) {
var name = _ref17.name
return name
},
ListType: function ListType(_ref18) {
var type = _ref18.type
return '[' + type + ']'
},
NonNullType: function NonNullType(_ref19) {
var type = _ref19.type
return type + '!'
},
// Type System Definitions
SchemaDefinition: function SchemaDefinition(_ref20) {
var directives = _ref20.directives,
operationTypes = _ref20.operationTypes
return join(['schema', join(directives, ' '), block(operationTypes)], ' ')
},
OperationTypeDefinition: function OperationTypeDefinition(_ref21) {
var operation = _ref21.operation,
type = _ref21.type
return operation + ': ' + type
},
ScalarTypeDefinition: function ScalarTypeDefinition(_ref22) {
var name = _ref22.name,
directives = _ref22.directives
return join(['scalar', name, join(directives, ' ')], ' ')
},
ObjectTypeDefinition: function ObjectTypeDefinition(_ref23) {
var name = _ref23.name,
interfaces = _ref23.interfaces,
directives = _ref23.directives,
fields = _ref23.fields
return join(
['type', name, wrap('implements ', join(interfaces, ', ')), join(directives, ' '), block(fields)], ' ')
},
FieldDefinition: function FieldDefinition(_ref24) {
var name = _ref24.name,
args = _ref24.arguments,
type = _ref24.type,
directives = _ref24.directives
return name + wrap('(', join(args, ', '), ')') + ': ' + type + wrap(' ', join(directives, ' '))
},
InputValueDefinition: function InputValueDefinition(_ref25) {
var name = _ref25.name,
type = _ref25.type,
defaultValue = _ref25.defaultValue,
directives = _ref25.directives
return join([name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ')], ' ')
},
InterfaceTypeDefinition: function InterfaceTypeDefinition(_ref26) {
var name = _ref26.name,
directives = _ref26.directives,
fields = _ref26.fields
return join(['interface', name, join(directives, ' '), block(fields)], ' ')
},
UnionTypeDefinition: function UnionTypeDefinition(_ref27) {
var name = _ref27.name,
directives = _ref27.directives,
types = _ref27.types
return join(['union', name, join(directives, ' '), '= ' + join(types, ' | ')], ' ')
},
EnumTypeDefinition: function EnumTypeDefinition(_ref28) {
var name = _ref28.name,
directives = _ref28.directives,
values = _ref28.values
return join(['enum', name, join(directives, ' '), block(values)], ' ')
},
EnumValueDefinition: function EnumValueDefinition(_ref29) {
var name = _ref29.name,
directives = _ref29.directives
return join([name, join(directives, ' ')], ' ')
},
InputObjectTypeDefinition: function InputObjectTypeDefinition(_ref30) {
var name = _ref30.name,
directives = _ref30.directives,
fields = _ref30.fields
return join(['input', name, join(directives, ' '), block(fields)], ' ')
},
TypeExtensionDefinition: function TypeExtensionDefinition(_ref31) {
var definition = _ref31.definition
return 'extend ' + definition
},
DirectiveDefinition: function DirectiveDefinition(_ref32) {
var name = _ref32.name,
args = _ref32.arguments,
locations = _ref32.locations
return 'directive @' + name + wrap('(', join(args, ', '), ')') + ' on ' + join(locations, ' | ')
}
}
/**
* Given maybeArray, print an empty string if it is null or empty, otherwise
* print all items together separated by separator if provided
*/
function join(maybeArray, separator) {
return maybeArray ? maybeArray.filter(function(x) {
return x
}).join(separator || '') : ''
}
/**
* Given array, print each item on its own line, wrapped in an
* indented "{ }" block.
*/
function block(array) {
return array && array.length !== 0 ? indent('{\n' + join(array, '\n')) + '\n}' : '{}'
}
/**
* If maybeString is not null or empty, then wrap with start and end, otherwise
* print an empty string.
*/
function wrap(start, maybeString, end) {
return maybeString ? start + maybeString + (end || '') : ''
}
function indent(maybeString) {
return maybeString && maybeString.replace(/\n/g, '\n ')
}
/***/
}),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.specifiedDirectives = exports.GraphQLDeprecatedDirective = exports.DEFAULT_DEPRECATION_REASON = exports.GraphQLSkipDirective = exports.GraphQLIncludeDirective = exports.GraphQLDirective = exports.DirectiveLocation = undefined
var _definition = __webpack_require__(1)
var _scalars = __webpack_require__(7)
var _invariant = __webpack_require__(3)
var _invariant2 = _interopRequireDefault(_invariant)
var _assertValidName = __webpack_require__(28)
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function")
}
}
/**
* Copyright (c) 2015, 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.
*/
var DirectiveLocation = exports.DirectiveLocation = {
// Operations
QUERY: 'QUERY',
MUTATION: 'MUTATION',
SUBSCRIPTION: 'SUBSCRIPTION',
FIELD: 'FIELD',
FRAGMENT_DEFINITION: 'FRAGMENT_DEFINITION',
FRAGMENT_SPREAD: 'FRAGMENT_SPREAD',
INLINE_FRAGMENT: 'INLINE_FRAGMENT',
// Schema Definitions
SCHEMA: 'SCHEMA',
SCALAR: 'SCALAR',
OBJECT: 'OBJECT',
FIELD_DEFINITION: 'FIELD_DEFINITION',
ARGUMENT_DEFINITION: 'ARGUMENT_DEFINITION',
INTERFACE: 'INTERFACE',
UNION: 'UNION',
ENUM: 'ENUM',
ENUM_VALUE: 'ENUM_VALUE',
INPUT_OBJECT: 'INPUT_OBJECT',
INPUT_FIELD_DEFINITION: 'INPUT_FIELD_DEFINITION'
}
// eslint-disable-line
/**
* Directives are used by the GraphQL runtime as a way of modifying execution
* behavior. Type system creators will usually not create these directly.
*/
var GraphQLDirective = exports.GraphQLDirective = function GraphQLDirective(config) {
_classCallCheck(this, GraphQLDirective);
(0, _invariant2.default)(config.name, 'Directive must be named.');
(0, _assertValidName.assertValidName)(config.name);
(0, _invariant2.default)(Array.isArray(config.locations), 'Must provide locations for directive.')
this.name = config.name
this.description = config.description
this.locations = config.locations
var args = config.args
if (!args) {
this.args = []
} else {
(0, _invariant2.default)(!Array.isArray(args),
'@' + config.name + ' args must be an object with argument names as keys.')
this.args = Object.keys(args).map(function(argName) {
(0, _assertValidName.assertValidName)(argName)
var arg = args[argName];
(0, _invariant2.default)((0, _definition.isInputType)(arg.type),
'@' + config.name + '(' + argName + ':) argument type must be ' + ('Input Type but got: ' + String(
arg.type) + '.'))
return {
name: argName,
description: arg.description === undefined ? null : arg.description,
type: arg.type,
defaultValue: arg.defaultValue
}
})
}
}
/**
* Used to conditionally include fields or fragments.
*/
var GraphQLIncludeDirective = exports.GraphQLIncludeDirective = new GraphQLDirective({
name: 'include',
description: 'Directs the executor to include this field or fragment only when '
+ 'the `if` argument is true.',
locations: [DirectiveLocation.FIELD, DirectiveLocation.FRAGMENT_SPREAD, DirectiveLocation.INLINE_FRAGMENT],
args: {
'if': {
type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean),
description: 'Included when true.'
}
}
})
/**
* Used to conditionally skip (exclude) fields or fragments.
*/
var GraphQLSkipDirective = exports.GraphQLSkipDirective = new GraphQLDirective({
name: 'skip',
description: 'Directs the executor to skip this field or fragment when the `if` ' + 'argument is true.',
locations: [DirectiveLocation.FIELD, DirectiveLocation.FRAGMENT_SPREAD, DirectiveLocation.INLINE_FRAGMENT],
args: {
'if': {
type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean),
description: 'Skipped when true.'
}
}
})
/**
* Constant string used for default reason for a deprecation.
*/
var DEFAULT_DEPRECATION_REASON = exports.DEFAULT_DEPRECATION_REASON = 'No longer supported'
/**
* Used to declare element of a GraphQL schema as deprecated.
*/
var GraphQLDeprecatedDirective = exports.GraphQLDeprecatedDirective = new GraphQLDirective({
name: 'deprecated',
description: 'Marks an element of a GraphQL schema as no longer supported.',
locations: [DirectiveLocation.FIELD_DEFINITION, DirectiveLocation.ENUM_VALUE],
args: {
reason: {
type: _scalars.GraphQLString,
description: 'Explains why this element was deprecated, usually also including a '
+ 'suggestion for how to access supported similar data. Formatted '
+ 'in [Markdown](https://daringfireball.net/projects/markdown/).',
defaultValue: DEFAULT_DEPRECATION_REASON
}
}
})
/**
* The full list of specified directives.
*/
var specifiedDirectives = exports.specifiedDirectives = [GraphQLIncludeDirective, GraphQLSkipDirective,
GraphQLDeprecatedDirective]
/***/
}),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.default = isNullish
/**
* Copyright (c) 2015, 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.
*/
/**
* Returns true if a value is null, undefined, or NaN.
*/
function isNullish(value) {
return value === null || value === undefined || value !== value
}
/***/
}),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.GraphQLID = exports.GraphQLBoolean = exports.GraphQLString = exports.GraphQLFloat = exports.GraphQLInt = undefined
var _definition = __webpack_require__(1)
var _kinds = __webpack_require__(2)
var Kind = _interopRequireWildcard(_kinds)
function _interopRequireWildcard(obj) {
if (obj && obj.__esModule) {
return obj
} else {
var newObj = {}
if (obj != null) {
for (var key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) {
newObj[key] = obj[key]
}
}
}
newObj.default = obj
return newObj
}
}
// As per the GraphQL Spec, Integers are only treated as valid when a valid
// 32-bit signed integer, providing the broadest support across platforms.
//
// n.b. JavaScript's integers are safe between -(2^53 - 1) and 2^53 - 1 because
// they are internally represented as IEEE 754 doubles.
/**
* Copyright (c) 2015, 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.
*/
var MAX_INT = 2147483647
var MIN_INT = -2147483648
function coerceInt(value) {
if (value === '') {
throw new TypeError('Int cannot represent non 32-bit signed integer value: (empty string)')
}
var num = Number(value)
if (num === num && num <= MAX_INT && num >= MIN_INT) {
return (num < 0 ? Math.ceil : Math.floor)(num)
}
throw new TypeError('Int cannot represent non 32-bit signed integer value: ' + String(value))
}
var GraphQLInt = exports.GraphQLInt = new _definition.GraphQLScalarType({
name: 'Int',
description: 'The `Int` scalar type represents non-fractional signed whole numeric '
+ 'values. Int can represent values between -(2^31) and 2^31 - 1. ',
serialize: coerceInt,
parseValue: coerceInt,
parseLiteral: function parseLiteral(ast) {
if (ast.kind === Kind.INT) {
var num = parseInt(ast.value, 10)
if (num <= MAX_INT && num >= MIN_INT) {
return num
}
}
return null
}
})
function coerceFloat(value) {
if (value === '') {
throw new TypeError('Float cannot represent non numeric value: (empty string)')
}
var num = Number(value)
if (num === num) {
return num
}
throw new TypeError('Float cannot represent non numeric value: ' + String(value))
}
var GraphQLFloat = exports.GraphQLFloat = new _definition.GraphQLScalarType({
name: 'Float',
description: 'The `Float` scalar type represents signed double-precision fractional '
+ 'values as specified by ' + '[IEEE 754](http://en.wikipedia.org/wiki/IEEE_floating_point). ',
serialize: coerceFloat,
parseValue: coerceFloat,
parseLiteral: function parseLiteral(ast) {
return ast.kind === Kind.FLOAT || ast.kind === Kind.INT ? parseFloat(ast.value) : null
}
})
var GraphQLString = exports.GraphQLString = new _definition.GraphQLScalarType({
name: 'String',
description: 'The `String` scalar type represents textual data, represented as UTF-8 '
+ 'character sequences. The String type is most often used by GraphQL to '
+ 'represent free-form human-readable text.',
serialize: String,
parseValue: String,
parseLiteral: function parseLiteral(ast) {
return ast.kind === Kind.STRING ? ast.value : null
}
})
var GraphQLBoolean = exports.GraphQLBoolean = new _definition.GraphQLScalarType({
name: 'Boolean',
description: 'The `Boolean` scalar type represents `true` or `false`.',
serialize: Boolean,
parseValue: Boolean,
parseLiteral: function parseLiteral(ast) {
return ast.kind === Kind.BOOLEAN ? ast.value : null
}
})
var GraphQLID = exports.GraphQLID = new _definition.GraphQLScalarType({
name: 'ID',
description: 'The `ID` scalar type represents a unique identifier, often used to '
+ 'refetch an object or as key for a cache. The ID type appears in a JSON '
+ 'response as a String; however, it is not intended to be human-readable. '
+ 'When expected as an input type, any string (such as `"4"`) or integer '
+ '(such as `4`) input value will be accepted as an ID.',
serialize: String,
parseValue: String,
parseLiteral: function parseLiteral(ast) {
return ast.kind === Kind.STRING || ast.kind === Kind.INT ? ast.value : null
}
})
/***/
}),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.GraphQLSchema = undefined
var _definition = __webpack_require__(1)
var _directives = __webpack_require__(5)
var _introspection = __webpack_require__(11)
var _find = __webpack_require__(10)
var _find2 = _interopRequireDefault(_find)
var _invariant = __webpack_require__(3)
var _invariant2 = _interopRequireDefault(_invariant)
var _typeComparators = __webpack_require__(19)
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function")
}
}
/**
* Copyright (c) 2015, 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.
*/
/**
* Schema Definition
*
* A Schema is created by supplying the root types of each type of operation,
* query and mutation (optional). A schema definition is then supplied to the
* validator and executor.
*
* Example:
*
* const MyAppSchema = new GraphQLSchema({
* query: MyAppQueryRootType,
* mutation: MyAppMutationRootType,
* })
*
* Note: If an array of `directives` are provided to GraphQLSchema, that will be
* the exact list of directives represented and allowed. If `directives` is not
* provided then a default set of the specified directives (e.g. @include and
* @skip) will be used. If you wish to provide *additional* directives to these
* specified directives, you must explicitly declare them. Example:
*
* const MyAppSchema = new GraphQLSchema({
* ...
* directives: specifiedDirectives.concat([ myCustomDirective ]),
* })
*
*/
var GraphQLSchema = exports.GraphQLSchema = function() {
function GraphQLSchema(config) {
var _this = this
_classCallCheck(this, GraphQLSchema);
(0, _invariant2.default)(typeof config === 'object', 'Must provide configuration object.');
(0, _invariant2.default)(config.query instanceof _definition.GraphQLObjectType,
'Schema query must be Object Type but got: ' + String(config.query) + '.')
this._queryType = config.query;
(0, _invariant2.default)(!config.mutation || config.mutation instanceof _definition.GraphQLObjectType,
'Schema mutation must be Object Type if provided but got: ' + String(config.mutation) + '.')
this._mutationType = config.mutation;
(0, _invariant2.default)(
!config.subscription || config.subscription instanceof _definition.GraphQLObjectType,
'Schema subscription must be Object Type if provided but got: ' + String(config.subscription) + '.')
this._subscriptionType = config.subscription;
(0, _invariant2.default)(!config.types || Array.isArray(config.types),
'Schema types must be Array if provided but got: ' + String(config.types) + '.');
(0, _invariant2.default)(
!config.directives || Array.isArray(config.directives) && config.directives.every(function(directive) {
return directive instanceof _directives.GraphQLDirective
}), 'Schema directives must be Array if provided but got: ' + String(config.directives)
+ '.')
// Provide specified directives (e.g. @include and @skip) by default.
this._directives = config.directives || _directives.specifiedDirectives
// Build type map now to detect any errors within this schema.
var initialTypes = [this.getQueryType(), this.getMutationType(), this.getSubscriptionType(),
_introspection.__Schema]
var types = config.types
if (types) {
initialTypes = initialTypes.concat(types)
}
this._typeMap = initialTypes.reduce(typeMapReducer, Object.create(null))
// Keep track of all implementations by interface name.
this._implementations = Object.create(null)
Object.keys(this._typeMap).forEach(function(typeName) {
var type = _this._typeMap[typeName]
if (type instanceof _definition.GraphQLObjectType) {
type.getInterfaces().forEach(function(iface) {
var impls = _this._implementations[iface.name]
if (impls) {
impls.push(type)
} else {
_this._implementations[iface.name] = [type]
}
})
}
})
// Enforce correct interface implementations.
Object.keys(this._typeMap).forEach(function(typeName) {
var type = _this._typeMap[typeName]
if (type instanceof _definition.GraphQLObjectType) {
type.getInterfaces().forEach(function(iface) {
return assertObjectImplementsInterface(_this, type, iface)
})
}
})
}
GraphQLSchema.prototype.getQueryType = function getQueryType() {
return this._queryType
}
GraphQLSchema.prototype.getMutationType = function getMutationType() {
return this._mutationType
}
GraphQLSchema.prototype.getSubscriptionType = function getSubscriptionType() {
return this._subscriptionType
}
GraphQLSchema.prototype.getTypeMap = function getTypeMap() {
return this._typeMap
}
GraphQLSchema.prototype.getType = function getType(name) {
return this.getTypeMap()[name]
}
GraphQLSchema.prototype.getPossibleTypes = function getPossibleTypes(abstractType) {
if (abstractType instanceof _definition.GraphQLUnionType) {
return abstractType.getTypes()
}
(0, _invariant2.default)(abstractType instanceof _definition.GraphQLInterfaceType)
return this._implementations[abstractType.name]
}
GraphQLSchema.prototype.isPossibleType = function isPossibleType(abstractType, possibleType) {
var possibleTypeMap = this._possibleTypeMap
if (!possibleTypeMap) {
this._possibleTypeMap = possibleTypeMap = Object.create(null)
}
if (!possibleTypeMap[abstractType.name]) {
var possibleTypes = this.getPossibleTypes(abstractType);
(0, _invariant2.default)(Array.isArray(possibleTypes),
'Could not find possible implementing types for ' + abstractType.name + ' '
+ 'in schema. Check that schema.types is defined and is an array of '
+ 'all possible types in the schema.')
possibleTypeMap[abstractType.name] = possibleTypes.reduce(function(map, type) {
return map[type.name] = true, map
}, Object.create(null))
}
return Boolean(possibleTypeMap[abstractType.name][possibleType.name])
}
GraphQLSchema.prototype.getDirectives = function getDirectives() {
return this._directives
}
GraphQLSchema.prototype.getDirective = function getDirective(name) {
return (0, _find2.default)(this.getDirectives(), function(directive) {
return directive.name === name
})
}
return GraphQLSchema
}()
function typeMapReducer(map, type) {
if (!type) {
return map
}
if (type instanceof _definition.GraphQLList || type instanceof _definition.GraphQLNonNull) {
return typeMapReducer(map, type.ofType)
}
if (map[type.name]) {
(0, _invariant2.default)(map[type.name] === type,
'Schema must contain unique named types but contains multiple ' + ('types named "' + type.name + '".'))
return map
}
map[type.name] = type
var reducedMap = map
if (type instanceof _definition.GraphQLUnionType) {
reducedMap = type.getTypes().reduce(typeMapReducer, reducedMap)
}
if (type instanceof _definition.GraphQLObjectType) {
reducedMap = type.getInterfaces().reduce(typeMapReducer, reducedMap)
}
if (type instanceof _definition.GraphQLObjectType || type instanceof _definition.GraphQLInterfaceType) {
(function() {
var fieldMap = type.getFields()
Object.keys(fieldMap).forEach(function(fieldName) {
var field = fieldMap[fieldName]
if (field.args) {
var fieldArgTypes = field.args.map(function(arg) {
return arg.type
})
reducedMap = fieldArgTypes.reduce(typeMapReducer, reducedMap)
}
reducedMap = typeMapReducer(reducedMap, field.type)
})
})()
}
if (type instanceof _definition.GraphQLInputObjectType) {
(function() {
var fieldMap = type.getFields()
Object.keys(fieldMap).forEach(function(fieldName) {
var field = fieldMap[fieldName]
reducedMap = typeMapReducer(reducedMap, field.type)
})
})()
}
return reducedMap
}
function assertObjectImplementsInterface(schema, object, iface) {
var objectFieldMap = object.getFields()
var ifaceFieldMap = iface.getFields()
// Assert each interface field is implemented.
Object.keys(ifaceFieldMap).forEach(function(fieldName) {
var objectField = objectFieldMap[fieldName]
var ifaceField = ifaceFieldMap[fieldName];
// Assert interface field exists on object.
(0, _invariant2.default)(objectField,
'"' + iface.name + '" expects field "' + fieldName + '" but "' + object.name + '" '
+ 'does not provide it.');
// Assert interface field type is satisfied by object field type, by being
// a valid subtype. (covariant)
(0, _invariant2.default)((0, _typeComparators.isTypeSubTypeOf)(schema, objectField.type, ifaceField.type),
iface.name + '.' + fieldName + ' expects type "' + String(ifaceField.type) + '" ' + 'but '
+ (object.name + '.' + fieldName + ' provides type "' + String(objectField.type) + '".'))
// Assert each interface field arg is implemented.
ifaceField.args.forEach(function(ifaceArg) {
var argName = ifaceArg.name
var objectArg = (0, _find2.default)(objectField.args, function(arg) {
return arg.name === argName
});
// Assert interface field arg exists on object field.
(0, _invariant2.default)(objectArg,
iface.name + '.' + fieldName + ' expects argument "' + argName + '" but ' + (object.name + '.'
+ fieldName + ' does not provide it.'));
// Assert interface field arg type matches object field arg type.
// (invariant)
(0, _invariant2.default)((0, _typeComparators.isEqualType)(ifaceArg.type, objectArg.type),
iface.name + '.' + fieldName + '(' + argName + ':) expects type ' + ('"' + String(ifaceArg.type)
+ '" but ') + (object.name + '.' + fieldName + '(' + argName + ':) provides type ') + ('"' + String(
objectArg.type) + '".'))
})
// Assert additional arguments must not be required.
objectField.args.forEach(function(objectArg) {
var argName = objectArg.name
var ifaceArg = (0, _find2.default)(ifaceField.args, function(arg) {
return arg.name === argName
})
if (!ifaceArg) {
(0, _invariant2.default)(!(objectArg.type instanceof _definition.GraphQLNonNull),
object.name + '.' + fieldName + '(' + argName + ':) is of required type ' + ('"' + String(
objectArg.type) + '" but is not also provided by the ') + ('interface ' + iface.name + '.'
+ fieldName + '.'))
}
})
})
}
/***/
}),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.typeFromAST = typeFromAST
var _invariant = __webpack_require__(3)
var _invariant2 = _interopRequireDefault(_invariant)
var _kinds = __webpack_require__(2)
var _definition = __webpack_require__(1)
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
function typeFromAST(schema, typeNode) {
var innerType = void 0
if (typeNode.kind === _kinds.LIST_TYPE) {
innerType = typeFromAST(schema, typeNode.type)
return innerType && new _definition.GraphQLList(innerType)
}
if (typeNode.kind === _kinds.NON_NULL_TYPE) {
innerType = typeFromAST(schema, typeNode.type)
return innerType && new _definition.GraphQLNonNull(innerType)
}
(0, _invariant2.default)(typeNode.kind === _kinds.NAMED_TYPE, 'Must be a named type.')
return schema.getType(typeNode.name.value)
}
/**
* Copyright (c) 2015, 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.
*/
/***/
}),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.default = find
/**
* Copyright (c) 2015, 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.
*/
function find(list, predicate) {
for (var i = 0; i < list.length; i++) {
if (predicate(list[i])) {
return list[i]
}
}
}
/***/
}),
/* 11 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.TypeNameMetaFieldDef = exports.TypeMetaFieldDef = exports.SchemaMetaFieldDef = exports.__TypeKind = exports.TypeKind = exports.__EnumValue = exports.__InputValue = exports.__Field = exports.__Type = exports.__DirectiveLocation = exports.__Directive = exports.__Schema = undefined
var _isInvalid = __webpack_require__(14)
var _isInvalid2 = _interopRequireDefault(_isInvalid)
var _astFromValue = __webpack_require__(29)
var _printer = __webpack_require__(4)
var _definition = __webpack_require__(1)
var _scalars = __webpack_require__(7)
var _directives = __webpack_require__(5)
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
/**
* Copyright (c) 2015, 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.
*/
var __Schema = exports.__Schema = new _definition.GraphQLObjectType({
name: '__Schema',
isIntrospection: true,
description: 'A GraphQL Schema defines the capabilities of a GraphQL server. It '
+ 'exposes all available types and directives on the server, as well as '
+ 'the entry points for query, mutation, and subscription operations.',
fields: function fields() {
return {
types: {
description: 'A list of all types supported by this server.',
type: new _definition.GraphQLNonNull(
new _definition.GraphQLList(new _definition.GraphQLNonNull(__Type))),
resolve: function resolve(schema) {
var typeMap = schema.getTypeMap()
return Object.keys(typeMap).map(function(key) {
return typeMap[key]
})
}
},
queryType: {
description: 'The type that query operations will be rooted at.',
type: new _definition.GraphQLNonNull(__Type),
resolve: function resolve(schema) {
return schema.getQueryType()
}
},
mutationType: {
description: 'If this server supports mutation, the type that '
+ 'mutation operations will be rooted at.',
type: __Type,
resolve: function resolve(schema) {
return schema.getMutationType()
}
},
subscriptionType: {
description: 'If this server support subscription, the type that '
+ 'subscription operations will be rooted at.',
type: __Type,
resolve: function resolve(schema) {
return schema.getSubscriptionType()
}
},
directives: {
description: 'A list of all directives supported by this server.',
type: new _definition.GraphQLNonNull(
new _definition.GraphQLList(new _definition.GraphQLNonNull(__Directive))),
resolve: function resolve(schema) {
return schema.getDirectives()
}
}
}
}
})
var __Directive = exports.__Directive = new _definition.GraphQLObjectType({
name: '__Directive',
isIntrospection: true,
description: 'A Directive provides a way to describe alternate runtime execution and '
+ 'type validation behavior in a GraphQL document.'
+ '\n\nIn some cases, you need to provide options to alter GraphQL\'s '
+ 'execution behavior in ways field arguments will not suffice, such as '
+ 'conditionally including or skipping a field. Directives provide this by '
+ 'describing additional information to the executor.',
fields: function fields() {
return {
name: { type: new _definition.GraphQLNonNull(_scalars.GraphQLString) },
description: { type: _scalars.GraphQLString },
locations: {
type: new _definition.GraphQLNonNull(
new _definition.GraphQLList(new _definition.GraphQLNonNull(__DirectiveLocation)))
},
args: {
type: new _definition.GraphQLNonNull(
new _definition.GraphQLList(new _definition.GraphQLNonNull(__InputValue))),
resolve: function resolve(directive) {
return directive.args || []
}
},
// NOTE: the following three fields are deprecated and are no longer part
// of the GraphQL specification.
onOperation: {
deprecationReason: 'Use `locations`.',
type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean),
resolve: function resolve(d) {
return d.locations.indexOf(_directives.DirectiveLocation.QUERY) !== -1 || d.locations.indexOf(
_directives.DirectiveLocation.MUTATION) !== -1 || d.locations.indexOf(
_directives.DirectiveLocation.SUBSCRIPTION) !== -1
}
},
onFragment: {
deprecationReason: 'Use `locations`.',
type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean),
resolve: function resolve(d) {
return d.locations.indexOf(_directives.DirectiveLocation.FRAGMENT_SPREAD) !== -1
|| d.locations.indexOf(_directives.DirectiveLocation.INLINE_FRAGMENT) !== -1
|| d.locations.indexOf(_directives.DirectiveLocation.FRAGMENT_DEFINITION) !== -1
}
},
onField: {
deprecationReason: 'Use `locations`.',
type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean),
resolve: function resolve(d) {
return d.locations.indexOf(_directives.DirectiveLocation.FIELD) !== -1
}
}
}
}
})
var __DirectiveLocation = exports.__DirectiveLocation = new _definition.GraphQLEnumType({
name: '__DirectiveLocation',
isIntrospection: true,
description: 'A Directive can be adjacent to many parts of the GraphQL language, a '
+ '__DirectiveLocation describes one such possible adjacencies.',
values: {
QUERY: {
value: _directives.DirectiveLocation.QUERY,
description: 'Location adjacent to a query operation.'
},
MUTATION: {
value: _directives.DirectiveLocation.MUTATION,
description: 'Location adjacent to a mutation operation.'
},
SUBSCRIPTION: {
value: _directives.DirectiveLocation.SUBSCRIPTION,
description: 'Location adjacent to a subscription operation.'
},
FIELD: {
value: _directives.DirectiveLocation.FIELD,
description: 'Location adjacent to a field.'
},
FRAGMENT_DEFINITION: {
value: _directives.DirectiveLocation.FRAGMENT_DEFINITION,
description: 'Location adjacent to a fragment definition.'
},
FRAGMENT_SPREAD: {
value: _directives.DirectiveLocation.FRAGMENT_SPREAD,
description: 'Location adjacent to a fragment spread.'
},
INLINE_FRAGMENT: {
value: _directives.DirectiveLocation.INLINE_FRAGMENT,
description: 'Location adjacent to an inline fragment.'
},
SCHEMA: {
value: _directives.DirectiveLocation.SCHEMA,
description: 'Location adjacent to a schema definition.'
},
SCALAR: {
value: _directives.DirectiveLocation.SCALAR,
description: 'Location adjacent to a scalar definition.'
},
OBJECT: {
value: _directives.DirectiveLocation.OBJECT,
description: 'Location adjacent to an object type definition.'
},
FIELD_DEFINITION: {
value: _directives.DirectiveLocation.FIELD_DEFINITION,
description: 'Location adjacent to a field definition.'
},
ARGUMENT_DEFINITION: {
value: _directives.DirectiveLocation.ARGUMENT_DEFINITION,
description: 'Location adjacent to an argument definition.'
},
INTERFACE: {
value: _directives.DirectiveLocation.INTERFACE,
description: 'Location adjacent to an interface definition.'
},
UNION: {
value: _directives.DirectiveLocation.UNION,
description: 'Location adjacent to a union definition.'
},
ENUM: {
value: _directives.DirectiveLocation.ENUM,
description: 'Location adjacent to an enum definition.'
},
ENUM_VALUE: {
value: _directives.DirectiveLocation.ENUM_VALUE,
description: 'Location adjacent to an enum value definition.'
},
INPUT_OBJECT: {
value: _directives.DirectiveLocation.INPUT_OBJECT,
description: 'Location adjacent to an input object type definition.'
},
INPUT_FIELD_DEFINITION: {
value: _directives.DirectiveLocation.INPUT_FIELD_DEFINITION,
description: 'Location adjacent to an input object field definition.'
}
}
})
var __Type = exports.__Type = new _definition.GraphQLObjectType({
name: '__Type',
isIntrospection: true,
description: 'The fundamental unit of any GraphQL Schema is the type. There are '
+ 'many kinds of types in GraphQL as represented by the `__TypeKind` enum.'
+ '\n\nDepending on the kind of a type, certain fields describe '
+ 'information about that type. Scalar types provide no information '
+ 'beyond a name and description, while Enum types provide their values. '
+ 'Object and Interface types provide the fields they describe. Abstract '
+ 'types, Union and Interface, provide the Object types possible '
+ 'at runtime. List and NonNull types compose other types.',
fields: function fields() {
return {
kind: {
type: new _definition.GraphQLNonNull(__TypeKind),
resolve: function resolve(type) {
if (type instanceof _definition.GraphQLScalarType) {
return TypeKind.SCALAR
} else if (type instanceof _definition.GraphQLObjectType) {
return TypeKind.OBJECT
} else if (type instanceof _definition.GraphQLInterfaceType) {
return TypeKind.INTERFACE
} else if (type instanceof _definition.GraphQLUnionType) {
return TypeKind.UNION
} else if (type instanceof _definition.GraphQLEnumType) {
return TypeKind.ENUM
} else if (type instanceof _definition.GraphQLInputObjectType) {
return TypeKind.INPUT_OBJECT
} else if (type instanceof _definition.GraphQLList) {
return TypeKind.LIST
} else if (type instanceof _definition.GraphQLNonNull) {
return TypeKind.NON_NULL
}
throw new Error('Unknown kind of type: ' + type)
}
},
name: { type: _scalars.GraphQLString },
description: { type: _scalars.GraphQLString },
fields: {
type: new _definition.GraphQLList(new _definition.GraphQLNonNull(__Field)),
args: {
includeDeprecated: { type: _scalars.GraphQLBoolean, defaultValue: false }
},
resolve: function resolve(type, _ref) {
var includeDeprecated = _ref.includeDeprecated
if (type instanceof _definition.GraphQLObjectType || type
instanceof _definition.GraphQLInterfaceType) {
var _ret = function() {
var fieldMap = type.getFields()
var fields = Object.keys(fieldMap).map(function(fieldName) {
return fieldMap[fieldName]
})
if (!includeDeprecated) {
fields = fields.filter(function(field) {
return !field.deprecationReason
})
}
return {
v: fields
}
}()
if (typeof _ret === "object") {
return _ret.v
}
}
return null
}
},
interfaces: {
type: new _definition.GraphQLList(new _definition.GraphQLNonNull(__Type)),
resolve: function resolve(type) {
if (type instanceof _definition.GraphQLObjectType) {
return type.getInterfaces()
}
}
},
possibleTypes: {
type: new _definition.GraphQLList(new _definition.GraphQLNonNull(__Type)),
resolve: function resolve(type, args, context, _ref2) {
var schema = _ref2.schema
if (type instanceof _definition.GraphQLInterfaceType || type
instanceof _definition.GraphQLUnionType) {
return schema.getPossibleTypes(type)
}
}
},
enumValues: {
type: new _definition.GraphQLList(new _definition.GraphQLNonNull(__EnumValue)),
args: {
includeDeprecated: { type: _scalars.GraphQLBoolean, defaultValue: false }
},
resolve: function resolve(type, _ref3) {
var includeDeprecated = _ref3.includeDeprecated
if (type instanceof _definition.GraphQLEnumType) {
var values = type.getValues()
if (!includeDeprecated) {
values = values.filter(function(value) {
return !value.deprecationReason
})
}
return values
}
}
},
inputFields: {
type: new _definition.GraphQLList(new _definition.GraphQLNonNull(__InputValue)),
resolve: function resolve(type) {
if (type instanceof _definition.GraphQLInputObjectType) {
var _ret2 = function() {
var fieldMap = type.getFields()
return {
v: Object.keys(fieldMap).map(function(fieldName) {
return fieldMap[fieldName]
})
}
}()
if (typeof _ret2 === "object") {
return _ret2.v
}
}
}
},
ofType: { type: __Type }
}
}
})
var __Field = exports.__Field = new _definition.GraphQLObjectType({
name: '__Field',
isIntrospection: true,
description: 'Object and Interface types are described by a list of Fields, each of '
+ 'which has a name, potentially a list of arguments, and a return type.',
fields: function fields() {
return {
name: { type: new _definition.GraphQLNonNull(_scalars.GraphQLString) },
description: { type: _scalars.GraphQLString },
args: {
type: new _definition.GraphQLNonNull(
new _definition.GraphQLList(new _definition.GraphQLNonNull(__InputValue))),
resolve: function resolve(field) {
return field.args || []
}
},
type: { type: new _definition.GraphQLNonNull(__Type) },
isDeprecated: { type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean) },
deprecationReason: {
type: _scalars.GraphQLString
}
}
}
})
var __InputValue = exports.__InputValue = new _definition.GraphQLObjectType({
name: '__InputValue',
isIntrospection: true,
description: 'Arguments provided to Fields or Directives and the input fields of an '
+ 'InputObject are represented as Input Values which describe their type '
+ 'and optionally a default value.',
fields: function fields() {
return {
name: { type: new _definition.GraphQLNonNull(_scalars.GraphQLString) },
description: { type: _scalars.GraphQLString },
type: { type: new _definition.GraphQLNonNull(__Type) },
defaultValue: {
type: _scalars.GraphQLString,
description: 'A GraphQL-formatted string representing the default value for this ' + 'input value.',
resolve: function resolve(inputVal) {
return (0, _isInvalid2.default)(inputVal.defaultValue) ? null : (0, _printer.print)(
(0, _astFromValue.astFromValue)(inputVal.defaultValue, inputVal.type))
}
}
}
}
})
var __EnumValue = exports.__EnumValue = new _definition.GraphQLObjectType({
name: '__EnumValue',
isIntrospection: true,
description: 'One possible value for a given Enum. Enum values are unique values, not '
+ 'a placeholder for a string or numeric value. However an Enum value is '
+ 'returned in a JSON response as a string.',
fields: function fields() {
return {
name: { type: new _definition.GraphQLNonNull(_scalars.GraphQLString) },
description: { type: _scalars.GraphQLString },
isDeprecated: { type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean) },
deprecationReason: {
type: _scalars.GraphQLString
}
}
}
})
var TypeKind = exports.TypeKind = {
SCALAR: 'SCALAR',
OBJECT: 'OBJECT',
INTERFACE: 'INTERFACE',
UNION: 'UNION',
ENUM: 'ENUM',
INPUT_OBJECT: 'INPUT_OBJECT',
LIST: 'LIST',
NON_NULL: 'NON_NULL'
}
var __TypeKind = exports.__TypeKind = new _definition.GraphQLEnumType({
name: '__TypeKind',
isIntrospection: true,
description: 'An enum describing what kind of type a given `__Type` is.',
values: {
SCALAR: {
value: TypeKind.SCALAR,
description: 'Indicates this type is a scalar.'
},
OBJECT: {
value: TypeKind.OBJECT,
description: 'Indicates this type is an object. ' + '`fields` and `interfaces` are valid fields.'
},
INTERFACE: {
value: TypeKind.INTERFACE,
description: 'Indicates this type is an interface. ' + '`fields` and `possibleTypes` are valid fields.'
},
UNION: {
value: TypeKind.UNION,
description: 'Indicates this type is a union. ' + '`possibleTypes` is a valid field.'
},
ENUM: {
value: TypeKind.ENUM,
description: 'Indicates this type is an enum. ' + '`enumValues` is a valid field.'
},
INPUT_OBJECT: {
value: TypeKind.INPUT_OBJECT,
description: 'Indicates this type is an input object. ' + '`inputFields` is a valid field.'
},
LIST: {
value: TypeKind.LIST,
description: 'Indicates this type is a list. ' + '`ofType` is a valid field.'
},
NON_NULL: {
value: TypeKind.NON_NULL,
description: 'Indicates this type is a non-null. ' + '`ofType` is a valid field.'
}
}
})
/**
* Note that these are GraphQLField and not GraphQLFieldConfig,
* so the format for args is different.
*/
var SchemaMetaFieldDef = exports.SchemaMetaFieldDef = {
name: '__schema',
type: new _definition.GraphQLNonNull(__Schema),
description: 'Access the current type schema of this server.',
args: [],
resolve: function resolve(source, args, context, _ref4) {
var schema = _ref4.schema
return schema
}
}
var TypeMetaFieldDef = exports.TypeMetaFieldDef = {
name: '__type',
type: __Type,
description: 'Request the type information of a single type.',
args: [{ name: 'name', type: new _definition.GraphQLNonNull(_scalars.GraphQLString) }],
resolve: function resolve(source, _ref5, context, _ref6) {
var name = _ref5.name
var schema = _ref6.schema
return schema.getType(name)
}
}
var TypeNameMetaFieldDef = exports.TypeNameMetaFieldDef = {
name: '__typename',
type: new _definition.GraphQLNonNull(_scalars.GraphQLString),
description: 'The name of the current Object type at runtime.',
args: [],
resolve: function resolve(source, args, context, _ref7) {
var parentType = _ref7.parentType
return parentType.name
}
}
/***/
}),
/* 12 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.default = keyMap
/**
* Copyright (c) 2015, 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.
*/
/**
* Creates a keyed JS object from an array, given a function to produce the keys
* for each value in the array.
*
* This provides a convenient lookup for the array items if the key function
* produces unique results.
*
* const phoneBook = [
* { name: 'Jon', num: '555-1234' },
* { name: 'Jenny', num: '867-5309' }
* ]
*
* // { Jon: { name: 'Jon', num: '555-1234' },
* // Jenny: { name: 'Jenny', num: '867-5309' } }
* const entriesByName = keyMap(
* phoneBook,
* entry => entry.name
* )
*
* // { name: 'Jenny', num: '857-6309' }
* const jennyEntry = entriesByName['Jenny']
*
*/
function keyMap(list, keyFn) {
return list.reduce(function(map, item) {
return map[keyFn(item)] = item, map
}, {})
}
/***/
}),
/* 13 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.GraphQLError = GraphQLError
var _location = __webpack_require__(25)
/**
* A GraphQLError describes an Error found during the parse, validate, or
* execute phases of performing a GraphQL operation. In addition to a message
* and stack trace, it also includes information about the locations in a
* GraphQL document and/or execution result that correspond to the Error.
*/
function GraphQLError( // eslint-disable-line no-redeclare
message, nodes, source, positions, path, originalError) {
// Include (non-enumerable) stack trace.
if (originalError && originalError.stack) {
Object.defineProperty(this, 'stack', {
value: originalError.stack,
writable: true,
configurable: true
})
} else if (Error.captureStackTrace) {
Error.captureStackTrace(this, GraphQLError)
} else {
Object.defineProperty(this, 'stack', {
value: Error().stack,
writable: true,
configurable: true
})
}
// Compute locations in the source for the given nodes/positions.
var _source = source
if (!_source && nodes && nodes.length > 0) {
var node = nodes[0]
_source = node && node.loc && node.loc.source
}
var _positions = positions
if (!_positions && nodes) {
_positions = nodes.filter(function(node) {
return Boolean(node.loc)
}).map(function(node) {
return node.loc.start
})
}
if (_positions && _positions.length === 0) {
_positions = undefined
}
var _locations = void 0
var _source2 = _source // seems here Flow need a const to resolve type.
if (_source2 && _positions) {
_locations = _positions.map(function(pos) {
return (0, _location.getLocation)(_source2, pos)
})
}
Object.defineProperties(this, {
message: {
value: message,
// By being enumerable, JSON.stringify will include `message` in the
// resulting output. This ensures that the simplist possible GraphQL
// service adheres to the spec.
enumerable: true,
writable: true
},
locations: {
// Coercing falsey values to undefined ensures they will not be included
// in JSON.stringify() when not provided.
value: _locations || undefined,
// By being enumerable, JSON.stringify will include `locations` in the
// resulting output. This ensures that the simplist possible GraphQL
// service adheres to the spec.
enumerable: true
},
path: {
// Coercing falsey values to undefined ensures they will not be included
// in JSON.stringify() when not provided.
value: path || undefined,
// By being enumerable, JSON.stringify will include `path` in the
// resulting output. This ensures that the simplist possible GraphQL
// service adheres to the spec.
enumerable: true
},
nodes: {
value: nodes || undefined
},
source: {
value: _source || undefined
},
positions: {
value: _positions || undefined
},
originalError: {
value: originalError
}
})
}
/**
* Copyright (c) 2015, 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.
*/
GraphQLError.prototype = Object.create(Error.prototype, {
constructor: { value: GraphQLError },
name: { value: 'GraphQLError' }
})
/***/
}),
/* 14 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.default = isInvalid
/**
* Copyright (c) 2015, 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.
*/
/**
* Returns true if a value is undefined, or NaN.
*/
function isInvalid(value) {
return value === undefined || value !== value
}
/***/
}),
/* 15 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.visit = visit
exports.visitInParallel = visitInParallel
exports.visitWithTypeInfo = visitWithTypeInfo
/**
* Copyright (c) 2015, 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.
*/
var QueryDocumentKeys = exports.QueryDocumentKeys = {
Name: [],
Document: ['definitions'],
OperationDefinition: ['name', 'variableDefinitions', 'directives', 'selectionSet'],
VariableDefinition: ['variable', 'type', 'defaultValue'],
Variable: ['name'],
SelectionSet: ['selections'],
Field: ['alias', 'name', 'arguments', 'directives', 'selectionSet'],
Argument: ['name', 'value'],
FragmentSpread: ['name', 'directives'],
InlineFragment: ['typeCondition', 'directives', 'selectionSet'],
FragmentDefinition: ['name', 'typeCondition', 'directives', 'selectionSet'],
IntValue: [],
FloatValue: [],
StringValue: [],
BooleanValue: [],
NullValue: [],
EnumValue: [],
ListValue: ['values'],
ObjectValue: ['fields'],
ObjectField: ['name', 'value'],
Directive: ['name', 'arguments'],
NamedType: ['name'],
ListType: ['type'],
NonNullType: ['type'],
SchemaDefinition: ['directives', 'operationTypes'],
OperationTypeDefinition: ['type'],
ScalarTypeDefinition: ['name', 'directives'],
ObjectTypeDefinition: ['name', 'interfaces', 'directives', 'fields'],
FieldDefinition: ['name', 'arguments', 'type', 'directives'],
InputValueDefinition: ['name', 'type', 'defaultValue', 'directives'],
InterfaceTypeDefinition: ['name', 'directives', 'fields'],
UnionTypeDefinition: ['name', 'directives', 'types'],
EnumTypeDefinition: ['name', 'directives', 'values'],
EnumValueDefinition: ['name', 'directives'],
InputObjectTypeDefinition: ['name', 'directives', 'fields'],
TypeExtensionDefinition: ['definition'],
DirectiveDefinition: ['name', 'arguments', 'locations']
}
var BREAK = exports.BREAK = {}
/**
* visit() will walk through an AST using a depth first traversal, calling
* the visitor's enter function at each node in the traversal, and calling the
* leave function after visiting that node and all of its child nodes.
*
* By returning different values from the enter and leave functions, the
* behavior of the visitor can be altered, including skipping over a sub-tree of
* the AST (by returning false), editing the AST by returning a value or null
* to remove the value, or to stop the whole traversal by returning BREAK.
*
* When using visit() to edit an AST, the original AST will not be modified, and
* a new version of the AST with the changes applied will be returned from the
* visit function.
*
* const editedAST = visit(ast, {
* enter(node, key, parent, path, ancestors) {
* // @return
* // undefined: no action
* // false: skip visiting this node
* // visitor.BREAK: stop visiting altogether
* // null: delete this node
* // any value: replace this node with the returned value
* },
* leave(node, key, parent, path, ancestors) {
* // @return
* // undefined: no action
* // false: no action
* // visitor.BREAK: stop visiting altogether
* // null: delete this node
* // any value: replace this node with the returned value
* }
* });
*
* Alternatively to providing enter() and leave() functions, a visitor can
* instead provide functions named the same as the kinds of AST nodes, or
* enter/leave visitors at a named key, leading to four permutations of
* visitor API:
*
* 1) Named visitors triggered when entering a node a specific kind.
*
* visit(ast, {
* Kind(node) {
* // enter the "Kind" node
* }
* })
*
* 2) Named visitors that trigger upon entering and leaving a node of
* a specific kind.
*
* visit(ast, {
* Kind: {
* enter(node) {
* // enter the "Kind" node
* }
* leave(node) {
* // leave the "Kind" node
* }
* }
* })
*
* 3) Generic visitors that trigger upon entering and leaving any node.
*
* visit(ast, {
* enter(node) {
* // enter any node
* },
* leave(node) {
* // leave any node
* }
* })
*
* 4) Parallel visitors for entering and leaving nodes of a specific kind.
*
* visit(ast, {
* enter: {
* Kind(node) {
* // enter the "Kind" node
* }
* },
* leave: {
* Kind(node) {
* // leave the "Kind" node
* }
* }
* })
*/
function visit(root, visitor, keyMap) {
var visitorKeys = keyMap || QueryDocumentKeys
var stack = void 0
var inArray = Array.isArray(root)
var keys = [root]
var index = -1
var edits = []
var parent = void 0
var path = []
var ancestors = []
var newRoot = root
do {
index++
var isLeaving = index === keys.length
var key = void 0
var node = void 0
var isEdited = isLeaving && edits.length !== 0
if (isLeaving) {
key = ancestors.length === 0 ? undefined : path.pop()
node = parent
parent = ancestors.pop()
if (isEdited) {
if (inArray) {
node = node.slice()
} else {
var clone = {}
for (var k in node) {
if (node.hasOwnProperty(k)) {
clone[k] = node[k]
}
}
node = clone
}
var editOffset = 0
for (var ii = 0; ii < edits.length; ii++) {
var editKey = edits[ii][0]
var editValue = edits[ii][1]
if (inArray) {
editKey -= editOffset
}
if (inArray && editValue === null) {
node.splice(editKey, 1)
editOffset++
} else {
node[editKey] = editValue
}
}
}
index = stack.index
keys = stack.keys
edits = stack.edits
inArray = stack.inArray
stack = stack.prev
} else {
key = parent ? inArray ? index : keys[index] : undefined
node = parent ? parent[key] : newRoot
if (node === null || node === undefined) {
continue
}
if (parent) {
path.push(key)
}
}
var result = void 0
if (!Array.isArray(node)) {
if (!isNode(node)) {
throw new Error('Invalid AST Node: ' + JSON.stringify(node))
}
var visitFn = getVisitFn(visitor, node.kind, isLeaving)
if (visitFn) {
result = visitFn.call(visitor, node, key, parent, path, ancestors)
if (result === BREAK) {
break
}
if (result === false) {
if (!isLeaving) {
path.pop()
continue
}
} else if (result !== undefined) {
edits.push([key, result])
if (!isLeaving) {
if (isNode(result)) {
node = result
} else {
path.pop()
continue
}
}
}
}
}
if (result === undefined && isEdited) {
edits.push([key, node])
}
if (!isLeaving) {
stack = { inArray: inArray, index: index, keys: keys, edits: edits, prev: stack }
inArray = Array.isArray(node)
keys = inArray ? node : visitorKeys[node.kind] || []
index = -1
edits = []
if (parent) {
ancestors.push(parent)
}
parent = node
}
} while (stack !== undefined)
if (edits.length !== 0) {
newRoot = edits[edits.length - 1][1]
}
return newRoot
}
function isNode(maybeNode) {
return maybeNode && typeof maybeNode.kind === 'string'
}
/**
* Creates a new visitor instance which delegates to many visitors to run in
* parallel. Each visitor will be visited for each node before moving on.
*
* If a prior visitor edits a node, no following visitors will see that node.
*/
function visitInParallel(visitors) {
var skipping = new Array(visitors.length)
return {
enter: function enter(node) {
for (var i = 0; i < visitors.length; i++) {
if (!skipping[i]) {
var fn = getVisitFn(visitors[i], node.kind, /* isLeaving */false)
if (fn) {
var result = fn.apply(visitors[i], arguments)
if (result === false) {
skipping[i] = node
} else if (result === BREAK) {
skipping[i] = BREAK
} else if (result !== undefined) {
return result
}
}
}
}
},
leave: function leave(node) {
for (var i = 0; i < visitors.length; i++) {
if (!skipping[i]) {
var fn = getVisitFn(visitors[i], node.kind, /* isLeaving */true)
if (fn) {
var result = fn.apply(visitors[i], arguments)
if (result === BREAK) {
skipping[i] = BREAK
} else if (result !== undefined && result !== false) {
return result
}
}
} else if (skipping[i] === node) {
skipping[i] = null
}
}
}
}
}
/**
* Creates a new visitor instance which maintains a provided TypeInfo instance
* along with visiting visitor.
*/
function visitWithTypeInfo(typeInfo, visitor) {
return {
enter: function enter(node) {
typeInfo.enter(node)
var fn = getVisitFn(visitor, node.kind, /* isLeaving */false)
if (fn) {
var result = fn.apply(visitor, arguments)
if (result !== undefined) {
typeInfo.leave(node)
if (isNode(result)) {
typeInfo.enter(result)
}
}
return result
}
},
leave: function leave(node) {
var fn = getVisitFn(visitor, node.kind, /* isLeaving */true)
var result = void 0
if (fn) {
result = fn.apply(visitor, arguments)
}
typeInfo.leave(node)
return result
}
}
}
/**
* Given a visitor instance, if it is leaving or not, and a node kind, return
* the function the visitor runtime should call.
*/
function getVisitFn(visitor, kind, isLeaving) {
var kindVisitor = visitor[kind]
if (kindVisitor) {
if (!isLeaving && typeof kindVisitor === 'function') {
// { Kind() {} }
return kindVisitor
}
var kindSpecificVisitor = isLeaving ? kindVisitor.leave : kindVisitor.enter
if (typeof kindSpecificVisitor === 'function') {
// { Kind: { enter() {}, leave() {} } }
return kindSpecificVisitor
}
} else {
var specificVisitor = isLeaving ? visitor.leave : visitor.enter
if (specificVisitor) {
if (typeof specificVisitor === 'function') {
// { enter() {}, leave() {} }
return specificVisitor
}
var specificKindVisitor = specificVisitor[kind]
if (typeof specificKindVisitor === 'function') {
// { enter: { Kind() {} }, leave: { Kind() {} } }
return specificKindVisitor
}
}
}
}
/***/
}),
/* 16 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.valueFromAST = valueFromAST
var _keyMap = __webpack_require__(12)
var _keyMap2 = _interopRequireDefault(_keyMap)
var _invariant = __webpack_require__(3)
var _invariant2 = _interopRequireDefault(_invariant)
var _isNullish = __webpack_require__(6)
var _isNullish2 = _interopRequireDefault(_isNullish)
var _isInvalid = __webpack_require__(14)
var _isInvalid2 = _interopRequireDefault(_isInvalid)
var _kinds = __webpack_require__(2)
var Kind = _interopRequireWildcard(_kinds)
var _definition = __webpack_require__(1)
function _interopRequireWildcard(obj) {
if (obj && obj.__esModule) {
return obj
} else {
var newObj = {}
if (obj != null) {
for (var key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) {
newObj[key] = obj[key]
}
}
}
newObj.default = obj
return newObj
}
}
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
/**
* Produces a JavaScript value given a GraphQL Value AST.
*
* A GraphQL type must be provided, which will be used to interpret different
* GraphQL Value literals.
*
* Returns `undefined` when the value could not be validly coerced according to
* the provided type.
*
* | GraphQL Value | JSON Value |
* | -------------------- | ------------- |
* | Input Object | Object |
* | List | Array |
* | Boolean | Boolean |
* | String | String |
* | Int / Float | Number |
* | Enum Value | Mixed |
* | NullValue | null |
*
*/
/**
* Copyright (c) 2015, 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.
*/
function valueFromAST(valueNode, type, variables) {
if (!valueNode) {
// When there is no node, then there is also no value.
// Importantly, this is different from returning the value null.
return
}
if (type instanceof _definition.GraphQLNonNull) {
if (valueNode.kind === Kind.NULL) {
return // Invalid: intentionally return no value.
}
return valueFromAST(valueNode, type.ofType, variables)
}
if (valueNode.kind === Kind.NULL) {
// This is explicitly returning the value null.
return null
}
if (valueNode.kind === Kind.VARIABLE) {
var variableName = valueNode.name.value
if (!variables || (0, _isInvalid2.default)(variables[variableName])) {
// No valid return value.
return
}
// Note: we're not doing any checking that this variable is correct. We're
// assuming that this query has been validated and the variable usage here
// is of the correct type.
return variables[variableName]
}
if (type instanceof _definition.GraphQLList) {
var itemType = type.ofType
if (valueNode.kind === Kind.LIST) {
var coercedValues = []
var itemNodes = valueNode.values
for (var i = 0; i < itemNodes.length; i++) {
if (isMissingVariable(itemNodes[i], variables)) {
// If an array contains a missing variable, it is either coerced to
// null or if the item type is non-null, it considered invalid.
if (itemType instanceof _definition.GraphQLNonNull) {
return // Invalid: intentionally return no value.
}
coercedValues.push(null)
} else {
var itemValue = valueFromAST(itemNodes[i], itemType, variables)
if ((0, _isInvalid2.default)(itemValue)) {
return // Invalid: intentionally return no value.
}
coercedValues.push(itemValue)
}
}
return coercedValues
}
var coercedValue = valueFromAST(valueNode, itemType, variables)
if ((0, _isInvalid2.default)(coercedValue)) {
return // Invalid: intentionally return no value.
}
return [coercedValue]
}
if (type instanceof _definition.GraphQLInputObjectType) {
if (valueNode.kind !== Kind.OBJECT) {
return // Invalid: intentionally return no value.
}
var coercedObj = Object.create(null)
var fields = type.getFields()
var fieldNodes = (0, _keyMap2.default)(valueNode.fields, function(field) {
return field.name.value
})
var fieldNames = Object.keys(fields)
for (var _i = 0; _i < fieldNames.length; _i++) {
var fieldName = fieldNames[_i]
var field = fields[fieldName]
var fieldNode = fieldNodes[fieldName]
if (!fieldNode || isMissingVariable(fieldNode.value, variables)) {
if (!(0, _isInvalid2.default)(field.defaultValue)) {
coercedObj[fieldName] = field.defaultValue
} else if (field.type instanceof _definition.GraphQLNonNull) {
return // Invalid: intentionally return no value.
}
continue
}
var fieldValue = valueFromAST(fieldNode.value, field.type, variables)
if ((0, _isInvalid2.default)(fieldValue)) {
return // Invalid: intentionally return no value.
}
coercedObj[fieldName] = fieldValue
}
return coercedObj
}
(0, _invariant2.default)(
type instanceof _definition.GraphQLScalarType || type instanceof _definition.GraphQLEnumType,
'Must be input type')
var parsed = type.parseLiteral(valueNode)
if ((0, _isNullish2.default)(parsed)) {
// null or invalid values represent a failure to parse correctly,
// in which case no value is returned.
return
}
return parsed
}
// Returns true if the provided valueNode is a variable which is not defined
// in the set of variables.
function isMissingVariable(valueNode, variables) {
return valueNode.kind === Kind.VARIABLE && (!variables || (0, _isInvalid2.default)(
variables[valueNode.name.value]))
}
/***/
}),
/* 17 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.parse = parse
exports.parseValue = parseValue
exports.parseType = parseType
exports.parseConstValue = parseConstValue
exports.parseTypeReference = parseTypeReference
exports.parseNamedType = parseNamedType
var _source = __webpack_require__(26)
var _error = __webpack_require__(0)
var _lexer = __webpack_require__(24)
var _kinds = __webpack_require__(2)
/**
* Given a GraphQL source, parses it into a Document.
* Throws GraphQLError if a syntax error is encountered.
*/
/**
* Configuration options to control parser behavior
*/
/**
* Copyright (c) 2015, 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.
*/
function parse(source, options) {
var sourceObj = typeof source === 'string' ? new _source.Source(source) : source
var lexer = (0, _lexer.createLexer)(sourceObj, options || {})
return parseDocument(lexer)
}
/**
* Given a string containing a GraphQL value (ex. `[42]`), parse the AST for
* that value.
* Throws GraphQLError if a syntax error is encountered.
*
* This is useful within tools that operate upon GraphQL Values directly and
* in isolation of complete GraphQL documents.
*
* Consider providing the results to the utility function: valueFromAST().
*/
function parseValue(source, options) {
var sourceObj = typeof source === 'string' ? new _source.Source(source) : source
var lexer = (0, _lexer.createLexer)(sourceObj, options || {})
expect(lexer, _lexer.TokenKind.SOF)
var value = parseValueLiteral(lexer, false)
expect(lexer, _lexer.TokenKind.EOF)
return value
}
/**
* Given a string containing a GraphQL Type (ex. `[Int!]`), parse the AST for
* that type.
* Throws GraphQLError if a syntax error is encountered.
*
* This is useful within tools that operate upon GraphQL Types directly and
* in isolation of complete GraphQL documents.
*
* Consider providing the results to the utility function: typeFromAST().
*/
function parseType(source, options) {
var sourceObj = typeof source === 'string' ? new _source.Source(source) : source
var lexer = (0, _lexer.createLexer)(sourceObj, options || {})
expect(lexer, _lexer.TokenKind.SOF)
var type = parseTypeReference(lexer)
expect(lexer, _lexer.TokenKind.EOF)
return type
}
/**
* Converts a name lex token into a name parse node.
*/
function parseName(lexer) {
var token = expect(lexer, _lexer.TokenKind.NAME)
return {
kind: _kinds.NAME,
value: token.value,
loc: loc(lexer, token)
}
}
// Implements the parsing rules in the Document section.
/**
* Document : Definition+
*/
function parseDocument(lexer) {
var start = lexer.token
expect(lexer, _lexer.TokenKind.SOF)
var definitions = []
do {
definitions.push(parseDefinition(lexer))
} while (!skip(lexer, _lexer.TokenKind.EOF))
return {
kind: _kinds.DOCUMENT,
definitions: definitions,
loc: loc(lexer, start)
}
}
/**
* Definition :
* - OperationDefinition
* - FragmentDefinition
* - TypeSystemDefinition
*/
function parseDefinition(lexer) {
if (peek(lexer, _lexer.TokenKind.BRACE_L)) {
return parseOperationDefinition(lexer)
}
if (peek(lexer, _lexer.TokenKind.NAME)) {
switch (lexer.token.value) {
// Note: subscription is an experimental non-spec addition.
case 'query':
case 'mutation':
case 'subscription':
return parseOperationDefinition(lexer)
case 'fragment':
return parseFragmentDefinition(lexer)
// Note: the Type System IDL is an experimental non-spec addition.
case 'schema':
case 'scalar':
case 'type':
case 'interface':
case 'union':
case 'enum':
case 'input':
case 'extend':
case 'directive':
return parseTypeSystemDefinition(lexer)
}
}
throw unexpected(lexer)
}
// Implements the parsing rules in the Operations section.
/**
* OperationDefinition :
* - SelectionSet
* - OperationType Name? VariableDefinitions? Directives? SelectionSet
*/
function parseOperationDefinition(lexer) {
var start = lexer.token
if (peek(lexer, _lexer.TokenKind.BRACE_L)) {
return {
kind: _kinds.OPERATION_DEFINITION,
operation: 'query',
name: null,
variableDefinitions: null,
directives: [],
selectionSet: parseSelectionSet(lexer),
loc: loc(lexer, start)
}
}
var operation = parseOperationType(lexer)
var name = void 0
if (peek(lexer, _lexer.TokenKind.NAME)) {
name = parseName(lexer)
}
return {
kind: _kinds.OPERATION_DEFINITION,
operation: operation,
name: name,
variableDefinitions: parseVariableDefinitions(lexer),
directives: parseDirectives(lexer),
selectionSet: parseSelectionSet(lexer),
loc: loc(lexer, start)
}
}
/**
* OperationType : one of query mutation subscription
*/
function parseOperationType(lexer) {
var operationToken = expect(lexer, _lexer.TokenKind.NAME)
switch (operationToken.value) {
case 'query':
return 'query'
case 'mutation':
return 'mutation'
// Note: subscription is an experimental non-spec addition.
case 'subscription':
return 'subscription'
}
throw unexpected(lexer, operationToken)
}
/**
* VariableDefinitions : ( VariableDefinition+ )
*/
function parseVariableDefinitions(lexer) {
return peek(lexer, _lexer.TokenKind.PAREN_L) ? many(lexer, _lexer.TokenKind.PAREN_L, parseVariableDefinition,
_lexer.TokenKind.PAREN_R) : []
}
/**
* VariableDefinition : Variable : Type DefaultValue?
*/
function parseVariableDefinition(lexer) {
var start = lexer.token
return {
kind: _kinds.VARIABLE_DEFINITION,
variable: parseVariable(lexer),
type: (expect(lexer, _lexer.TokenKind.COLON), parseTypeReference(lexer)),
defaultValue: skip(lexer, _lexer.TokenKind.EQUALS) ? parseValueLiteral(lexer, true) : null,
loc: loc(lexer, start)
}
}
/**
* Variable : $ Name
*/
function parseVariable(lexer) {
var start = lexer.token
expect(lexer, _lexer.TokenKind.DOLLAR)
return {
kind: _kinds.VARIABLE,
name: parseName(lexer),
loc: loc(lexer, start)
}
}
/**
* SelectionSet : { Selection+ }
*/
function parseSelectionSet(lexer) {
var start = lexer.token
return {
kind: _kinds.SELECTION_SET,
selections: many(lexer, _lexer.TokenKind.BRACE_L, parseSelection, _lexer.TokenKind.BRACE_R),
loc: loc(lexer, start)
}
}
/**
* Selection :
* - Field
* - FragmentSpread
* - InlineFragment
*/
function parseSelection(lexer) {
return peek(lexer, _lexer.TokenKind.SPREAD) ? parseFragment(lexer) : parseField(lexer)
}
/**
* Field : Alias? Name Arguments? Directives? SelectionSet?
*
* Alias : Name :
*/
function parseField(lexer) {
var start = lexer.token
var nameOrAlias = parseName(lexer)
var alias = void 0
var name = void 0
if (skip(lexer, _lexer.TokenKind.COLON)) {
alias = nameOrAlias
name = parseName(lexer)
} else {
alias = null
name = nameOrAlias
}
return {
kind: _kinds.FIELD,
alias: alias,
name: name,
arguments: parseArguments(lexer),
directives: parseDirectives(lexer),
selectionSet: peek(lexer, _lexer.TokenKind.BRACE_L) ? parseSelectionSet(lexer) : null,
loc: loc(lexer, start)
}
}
/**
* Arguments : ( Argument+ )
*/
function parseArguments(lexer) {
return peek(lexer, _lexer.TokenKind.PAREN_L) ? many(lexer, _lexer.TokenKind.PAREN_L, parseArgument,
_lexer.TokenKind.PAREN_R) : []
}
/**
* Argument : Name : Value
*/
function parseArgument(lexer) {
var start = lexer.token
return {
kind: _kinds.ARGUMENT,
name: parseName(lexer),
value: (expect(lexer, _lexer.TokenKind.COLON), parseValueLiteral(lexer, false)),
loc: loc(lexer, start)
}
}
// Implements the parsing rules in the Fragments section.
/**
* Corresponds to both FragmentSpread and InlineFragment in the spec.
*
* FragmentSpread : ... FragmentName Directives?
*
* InlineFragment : ... TypeCondition? Directives? SelectionSet
*/
function parseFragment(lexer) {
var start = lexer.token
expect(lexer, _lexer.TokenKind.SPREAD)
if (peek(lexer, _lexer.TokenKind.NAME) && lexer.token.value !== 'on') {
return {
kind: _kinds.FRAGMENT_SPREAD,
name: parseFragmentName(lexer),
directives: parseDirectives(lexer),
loc: loc(lexer, start)
}
}
var typeCondition = null
if (lexer.token.value === 'on') {
lexer.advance()
typeCondition = parseNamedType(lexer)
}
return {
kind: _kinds.INLINE_FRAGMENT,
typeCondition: typeCondition,
directives: parseDirectives(lexer),
selectionSet: parseSelectionSet(lexer),
loc: loc(lexer, start)
}
}
/**
* FragmentDefinition :
* - fragment FragmentName on TypeCondition Directives? SelectionSet
*
* TypeCondition : NamedType
*/
function parseFragmentDefinition(lexer) {
var start = lexer.token
expectKeyword(lexer, 'fragment')
return {
kind: _kinds.FRAGMENT_DEFINITION,
name: parseFragmentName(lexer),
typeCondition: (expectKeyword(lexer, 'on'), parseNamedType(lexer)),
directives: parseDirectives(lexer),
selectionSet: parseSelectionSet(lexer),
loc: loc(lexer, start)
}
}
/**
* FragmentName : Name but not `on`
*/
function parseFragmentName(lexer) {
if (lexer.token.value === 'on') {
throw unexpected(lexer)
}
return parseName(lexer)
}
// Implements the parsing rules in the Values section.
/**
* Value[Const] :
* - [~Const] Variable
* - IntValue
* - FloatValue
* - StringValue
* - BooleanValue
* - NullValue
* - EnumValue
* - ListValue[?Const]
* - ObjectValue[?Const]
*
* BooleanValue : one of `true` `false`
*
* NullValue : `null`
*
* EnumValue : Name but not `true`, `false` or `null`
*/
function parseValueLiteral(lexer, isConst) {
var token = lexer.token
switch (token.kind) {
case _lexer.TokenKind.BRACKET_L:
return parseList(lexer, isConst)
case _lexer.TokenKind.BRACE_L:
return parseObject(lexer, isConst)
case _lexer.TokenKind.INT:
lexer.advance()
return {
kind: _kinds.INT,
value: token.value,
loc: loc(lexer, token)
}
case _lexer.TokenKind.FLOAT:
lexer.advance()
return {
kind: _kinds.FLOAT,
value: token.value,
loc: loc(lexer, token)
}
case _lexer.TokenKind.STRING:
lexer.advance()
return {
kind: _kinds.STRING,
value: token.value,
loc: loc(lexer, token)
}
case _lexer.TokenKind.NAME:
if (token.value === 'true' || token.value === 'false') {
lexer.advance()
return {
kind: _kinds.BOOLEAN,
value: token.value === 'true',
loc: loc(lexer, token)
}
} else if (token.value === 'null') {
lexer.advance()
return {
kind: _kinds.NULL,
loc: loc(lexer, token)
}
}
lexer.advance()
return {
kind: _kinds.ENUM,
value: token.value,
loc: loc(lexer, token)
}
case _lexer.TokenKind.DOLLAR:
if (!isConst) {
return parseVariable(lexer)
}
break
}
throw unexpected(lexer)
}
function parseConstValue(lexer) {
return parseValueLiteral(lexer, true)
}
function parseValueValue(lexer) {
return parseValueLiteral(lexer, false)
}
/**
* ListValue[Const] :
* - [ ]
* - [ Value[?Const]+ ]
*/
function parseList(lexer, isConst) {
var start = lexer.token
var item = isConst ? parseConstValue : parseValueValue
return {
kind: _kinds.LIST,
values: any(lexer, _lexer.TokenKind.BRACKET_L, item, _lexer.TokenKind.BRACKET_R),
loc: loc(lexer, start)
}
}
/**
* ObjectValue[Const] :
* - { }
* - { ObjectField[?Const]+ }
*/
function parseObject(lexer, isConst) {
var start = lexer.token
expect(lexer, _lexer.TokenKind.BRACE_L)
var fields = []
while (!skip(lexer, _lexer.TokenKind.BRACE_R)) {
fields.push(parseObjectField(lexer, isConst))
}
return {
kind: _kinds.OBJECT,
fields: fields,
loc: loc(lexer, start)
}
}
/**
* ObjectField[Const] : Name : Value[?Const]
*/
function parseObjectField(lexer, isConst) {
var start = lexer.token
return {
kind: _kinds.OBJECT_FIELD,
name: parseName(lexer),
value: (expect(lexer, _lexer.TokenKind.COLON), parseValueLiteral(lexer, isConst)),
loc: loc(lexer, start)
}
}
// Implements the parsing rules in the Directives section.
/**
* Directives : Directive+
*/
function parseDirectives(lexer) {
var directives = []
while (peek(lexer, _lexer.TokenKind.AT)) {
directives.push(parseDirective(lexer))
}
return directives
}
/**
* Directive : @ Name Arguments?
*/
function parseDirective(lexer) {
var start = lexer.token
expect(lexer, _lexer.TokenKind.AT)
return {
kind: _kinds.DIRECTIVE,
name: parseName(lexer),
arguments: parseArguments(lexer),
loc: loc(lexer, start)
}
}
// Implements the parsing rules in the Types section.
/**
* Type :
* - NamedType
* - ListType
* - NonNullType
*/
function parseTypeReference(lexer) {
var start = lexer.token
var type = void 0
if (skip(lexer, _lexer.TokenKind.BRACKET_L)) {
type = parseTypeReference(lexer)
expect(lexer, _lexer.TokenKind.BRACKET_R)
type = {
kind: _kinds.LIST_TYPE,
type: type,
loc: loc(lexer, start)
}
} else {
type = parseNamedType(lexer)
}
if (skip(lexer, _lexer.TokenKind.BANG)) {
return {
kind: _kinds.NON_NULL_TYPE,
type: type,
loc: loc(lexer, start)
}
}
return type
}
/**
* NamedType : Name
*/
function parseNamedType(lexer) {
var start = lexer.token
return {
kind: _kinds.NAMED_TYPE,
name: parseName(lexer),
loc: loc(lexer, start)
}
}
// Implements the parsing rules in the Type Definition section.
/**
* TypeSystemDefinition :
* - SchemaDefinition
* - TypeDefinition
* - TypeExtensionDefinition
* - DirectiveDefinition
*
* TypeDefinition :
* - ScalarTypeDefinition
* - ObjectTypeDefinition
* - InterfaceTypeDefinition
* - UnionTypeDefinition
* - EnumTypeDefinition
* - InputObjectTypeDefinition
*/
function parseTypeSystemDefinition(lexer) {
if (peek(lexer, _lexer.TokenKind.NAME)) {
switch (lexer.token.value) {
case 'schema':
return parseSchemaDefinition(lexer)
case 'scalar':
return parseScalarTypeDefinition(lexer)
case 'type':
return parseObjectTypeDefinition(lexer)
case 'interface':
return parseInterfaceTypeDefinition(lexer)
case 'union':
return parseUnionTypeDefinition(lexer)
case 'enum':
return parseEnumTypeDefinition(lexer)
case 'input':
return parseInputObjectTypeDefinition(lexer)
case 'extend':
return parseTypeExtensionDefinition(lexer)
case 'directive':
return parseDirectiveDefinition(lexer)
}
}
throw unexpected(lexer)
}
/**
* SchemaDefinition : schema Directives? { OperationTypeDefinition+ }
*
* OperationTypeDefinition : OperationType : NamedType
*/
function parseSchemaDefinition(lexer) {
var start = lexer.token
expectKeyword(lexer, 'schema')
var directives = parseDirectives(lexer)
var operationTypes = many(lexer, _lexer.TokenKind.BRACE_L, parseOperationTypeDefinition,
_lexer.TokenKind.BRACE_R)
return {
kind: _kinds.SCHEMA_DEFINITION,
directives: directives,
operationTypes: operationTypes,
loc: loc(lexer, start)
}
}
function parseOperationTypeDefinition(lexer) {
var start = lexer.token
var operation = parseOperationType(lexer)
expect(lexer, _lexer.TokenKind.COLON)
var type = parseNamedType(lexer)
return {
kind: _kinds.OPERATION_TYPE_DEFINITION,
operation: operation,
type: type,
loc: loc(lexer, start)
}
}
/**
* ScalarTypeDefinition : scalar Name Directives?
*/
function parseScalarTypeDefinition(lexer) {
var start = lexer.token
expectKeyword(lexer, 'scalar')
var name = parseName(lexer)
var directives = parseDirectives(lexer)
return {
kind: _kinds.SCALAR_TYPE_DEFINITION,
name: name,
directives: directives,
loc: loc(lexer, start)
}
}
/**
* ObjectTypeDefinition :
* - type Name ImplementsInterfaces? Directives? { FieldDefinition+ }
*/
function parseObjectTypeDefinition(lexer) {
var start = lexer.token
expectKeyword(lexer, 'type')
var name = parseName(lexer)
var interfaces = parseImplementsInterfaces(lexer)
var directives = parseDirectives(lexer)
var fields = any(lexer, _lexer.TokenKind.BRACE_L, parseFieldDefinition, _lexer.TokenKind.BRACE_R)
return {
kind: _kinds.OBJECT_TYPE_DEFINITION,
name: name,
interfaces: interfaces,
directives: directives,
fields: fields,
loc: loc(lexer, start)
}
}
/**
* ImplementsInterfaces : implements NamedType+
*/
function parseImplementsInterfaces(lexer) {
var types = []
if (lexer.token.value === 'implements') {
lexer.advance()
do {
types.push(parseNamedType(lexer))
} while (peek(lexer, _lexer.TokenKind.NAME))
}
return types
}
/**
* FieldDefinition : Name ArgumentsDefinition? : Type Directives?
*/
function parseFieldDefinition(lexer) {
var start = lexer.token
var name = parseName(lexer)
var args = parseArgumentDefs(lexer)
expect(lexer, _lexer.TokenKind.COLON)
var type = parseTypeReference(lexer)
var directives = parseDirectives(lexer)
return {
kind: _kinds.FIELD_DEFINITION,
name: name,
arguments: args,
type: type,
directives: directives,
loc: loc(lexer, start)
}
}
/**
* ArgumentsDefinition : ( InputValueDefinition+ )
*/
function parseArgumentDefs(lexer) {
if (!peek(lexer, _lexer.TokenKind.PAREN_L)) {
return []
}
return many(lexer, _lexer.TokenKind.PAREN_L, parseInputValueDef, _lexer.TokenKind.PAREN_R)
}
/**
* InputValueDefinition : Name : Type DefaultValue? Directives?
*/
function parseInputValueDef(lexer) {
var start = lexer.token
var name = parseName(lexer)
expect(lexer, _lexer.TokenKind.COLON)
var type = parseTypeReference(lexer)
var defaultValue = null
if (skip(lexer, _lexer.TokenKind.EQUALS)) {
defaultValue = parseConstValue(lexer)
}
var directives = parseDirectives(lexer)
return {
kind: _kinds.INPUT_VALUE_DEFINITION,
name: name,
type: type,
defaultValue: defaultValue,
directives: directives,
loc: loc(lexer, start)
}
}
/**
* InterfaceTypeDefinition : interface Name Directives? { FieldDefinition+ }
*/
function parseInterfaceTypeDefinition(lexer) {
var start = lexer.token
expectKeyword(lexer, 'interface')
var name = parseName(lexer)
var directives = parseDirectives(lexer)
var fields = any(lexer, _lexer.TokenKind.BRACE_L, parseFieldDefinition, _lexer.TokenKind.BRACE_R)
return {
kind: _kinds.INTERFACE_TYPE_DEFINITION,
name: name,
directives: directives,
fields: fields,
loc: loc(lexer, start)
}
}
/**
* UnionTypeDefinition : union Name Directives? = UnionMembers
*/
function parseUnionTypeDefinition(lexer) {
var start = lexer.token
expectKeyword(lexer, 'union')
var name = parseName(lexer)
var directives = parseDirectives(lexer)
expect(lexer, _lexer.TokenKind.EQUALS)
var types = parseUnionMembers(lexer)
return {
kind: _kinds.UNION_TYPE_DEFINITION,
name: name,
directives: directives,
types: types,
loc: loc(lexer, start)
}
}
/**
* UnionMembers :
* - NamedType
* - UnionMembers | NamedType
*/
function parseUnionMembers(lexer) {
var members = []
do {
members.push(parseNamedType(lexer))
} while (skip(lexer, _lexer.TokenKind.PIPE))
return members
}
/**
* EnumTypeDefinition : enum Name Directives? { EnumValueDefinition+ }
*/
function parseEnumTypeDefinition(lexer) {
var start = lexer.token
expectKeyword(lexer, 'enum')
var name = parseName(lexer)
var directives = parseDirectives(lexer)
var values = many(lexer, _lexer.TokenKind.BRACE_L, parseEnumValueDefinition, _lexer.TokenKind.BRACE_R)
return {
kind: _kinds.ENUM_TYPE_DEFINITION,
name: name,
directives: directives,
values: values,
loc: loc(lexer, start)
}
}
/**
* EnumValueDefinition : EnumValue Directives?
*
* EnumValue : Name
*/
function parseEnumValueDefinition(lexer) {
var start = lexer.token
var name = parseName(lexer)
var directives = parseDirectives(lexer)
return {
kind: _kinds.ENUM_VALUE_DEFINITION,
name: name,
directives: directives,
loc: loc(lexer, start)
}
}
/**
* InputObjectTypeDefinition : input Name Directives? { InputValueDefinition+ }
*/
function parseInputObjectTypeDefinition(lexer) {
var start = lexer.token
expectKeyword(lexer, 'input')
var name = parseName(lexer)
var directives = parseDirectives(lexer)
var fields = any(lexer, _lexer.TokenKind.BRACE_L, parseInputValueDef, _lexer.TokenKind.BRACE_R)
return {
kind: _kinds.INPUT_OBJECT_TYPE_DEFINITION,
name: name,
directives: directives,
fields: fields,
loc: loc(lexer, start)
}
}
/**
* TypeExtensionDefinition : extend ObjectTypeDefinition
*/
function parseTypeExtensionDefinition(lexer) {
var start = lexer.token
expectKeyword(lexer, 'extend')
var definition = parseObjectTypeDefinition(lexer)
return {
kind: _kinds.TYPE_EXTENSION_DEFINITION,
definition: definition,
loc: loc(lexer, start)
}
}
/**
* DirectiveDefinition :
* - directive @ Name ArgumentsDefinition? on DirectiveLocations
*/
function parseDirectiveDefinition(lexer) {
var start = lexer.token
expectKeyword(lexer, 'directive')
expect(lexer, _lexer.TokenKind.AT)
var name = parseName(lexer)
var args = parseArgumentDefs(lexer)
expectKeyword(lexer, 'on')
var locations = parseDirectiveLocations(lexer)
return {
kind: _kinds.DIRECTIVE_DEFINITION,
name: name,
arguments: args,
locations: locations,
loc: loc(lexer, start)
}
}
/**
* DirectiveLocations :
* - Name
* - DirectiveLocations | Name
*/
function parseDirectiveLocations(lexer) {
var locations = []
do {
locations.push(parseName(lexer))
} while (skip(lexer, _lexer.TokenKind.PIPE))
return locations
}
// Core parsing utility functions
/**
* Returns a location object, used to identify the place in
* the source that created a given parsed object.
*/
function loc(lexer, startToken) {
if (!lexer.options.noLocation) {
return new Loc(startToken, lexer.lastToken, lexer.source)
}
}
function Loc(startToken, endToken, source) {
this.start = startToken.start
this.end = endToken.end
this.startToken = startToken
this.endToken = endToken
this.source = source
}
// Print a simplified form when appearing in JSON/util.inspect.
Loc.prototype.toJSON = Loc.prototype.inspect = function toJSON() {
return { start: this.start, end: this.end }
}
/**
* Determines if the next token is of a given kind
*/
function peek(lexer, kind) {
return lexer.token.kind === kind
}
/**
* If the next token is of the given kind, return true after advancing
* the lexer. Otherwise, do not change the parser state and return false.
*/
function skip(lexer, kind) {
var match = lexer.token.kind === kind
if (match) {
lexer.advance()
}
return match
}
/**
* If the next token is of the given kind, return that token after advancing
* the lexer. Otherwise, do not change the parser state and throw an error.
*/
function expect(lexer, kind) {
var token = lexer.token
if (token.kind === kind) {
lexer.advance()
return token
}
throw (0, _error.syntaxError)(lexer.source, token.start,
'Expected ' + kind + ', found ' + (0, _lexer.getTokenDesc)(token))
}
/**
* If the next token is a keyword with the given value, return that token after
* advancing the lexer. Otherwise, do not change the parser state and return
* false.
*/
function expectKeyword(lexer, value) {
var token = lexer.token
if (token.kind === _lexer.TokenKind.NAME && token.value === value) {
lexer.advance()
return token
}
throw (0, _error.syntaxError)(lexer.source, token.start,
'Expected "' + value + '", found ' + (0, _lexer.getTokenDesc)(token))
}
/**
* Helper function for creating an error when an unexpected lexed token
* is encountered.
*/
function unexpected(lexer, atToken) {
var token = atToken || lexer.token
return (0, _error.syntaxError)(lexer.source, token.start, 'Unexpected ' + (0, _lexer.getTokenDesc)(token))
}
/**
* Returns a possibly empty list of parse nodes, determined by
* the parseFn. This list begins with a lex token of openKind
* and ends with a lex token of closeKind. Advances the parser
* to the next lex token after the closing token.
*/
function any(lexer, openKind, parseFn, closeKind) {
expect(lexer, openKind)
var nodes = []
while (!skip(lexer, closeKind)) {
nodes.push(parseFn(lexer))
}
return nodes
}
/**
* Returns a non-empty list of parse nodes, determined by
* the parseFn. This list begins with a lex token of openKind
* and ends with a lex token of closeKind. Advances the parser
* to the next lex token after the closing token.
*/
function many(lexer, openKind, parseFn, closeKind) {
expect(lexer, openKind)
var nodes = [parseFn(lexer)]
while (!skip(lexer, closeKind)) {
nodes.push(parseFn(lexer))
}
return nodes
}
/***/
}),
/* 18 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.isValidLiteralValue = isValidLiteralValue
var _printer = __webpack_require__(4)
var _kinds = __webpack_require__(2)
var _definition = __webpack_require__(1)
var _invariant = __webpack_require__(3)
var _invariant2 = _interopRequireDefault(_invariant)
var _keyMap = __webpack_require__(12)
var _keyMap2 = _interopRequireDefault(_keyMap)
var _isNullish = __webpack_require__(6)
var _isNullish2 = _interopRequireDefault(_isNullish)
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
/**
* Utility for validators which determines if a value literal node is valid
* given an input type.
*
* Note that this only validates literal values, variables are assumed to
* provide values of the correct type.
*/
/**
* Copyright (c) 2015, 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.
*/
function isValidLiteralValue(type, valueNode) {
// A value must be provided if the type is non-null.
if (type instanceof _definition.GraphQLNonNull) {
if (!valueNode || valueNode.kind === _kinds.NULL) {
return ['Expected "' + String(type) + '", found null.']
}
return isValidLiteralValue(type.ofType, valueNode)
}
if (!valueNode || valueNode.kind === _kinds.NULL) {
return []
}
// This function only tests literals, and assumes variables will provide
// values of the correct type.
if (valueNode.kind === _kinds.VARIABLE) {
return []
}
// Lists accept a non-list value as a list of one.
if (type instanceof _definition.GraphQLList) {
var _ret = function() {
var itemType = type.ofType
if (valueNode.kind === _kinds.LIST) {
return {
v: valueNode.values.reduce(function(acc, item, index) {
var errors = isValidLiteralValue(itemType, item)
return acc.concat(errors.map(function(error) {
return 'In element #' + index + ': ' + error
}))
}, [])
}
}
return {
v: isValidLiteralValue(itemType, valueNode)
}
}()
if (typeof _ret === "object") {
return _ret.v
}
}
// Input objects check each defined field and look for undefined fields.
if (type instanceof _definition.GraphQLInputObjectType) {
var _ret2 = function() {
if (valueNode.kind !== _kinds.OBJECT) {
return {
v: ['Expected "' + type.name + '", found not an object.']
}
}
var fields = type.getFields()
var errors = []
// Ensure every provided field is defined.
var fieldNodes = valueNode.fields
fieldNodes.forEach(function(providedFieldNode) {
if (!fields[providedFieldNode.name.value]) {
errors.push('In field "' + providedFieldNode.name.value + '": Unknown field.')
}
})
// Ensure every defined field is valid.
var fieldNodeMap = (0, _keyMap2.default)(fieldNodes, function(fieldNode) {
return fieldNode.name.value
})
Object.keys(fields).forEach(function(fieldName) {
var result = isValidLiteralValue(fields[fieldName].type,
fieldNodeMap[fieldName] && fieldNodeMap[fieldName].value)
errors.push.apply(errors, result.map(function(error) {
return 'In field "' + fieldName + '": ' + error
}))
})
return {
v: errors
}
}()
if (typeof _ret2 === "object") {
return _ret2.v
}
}
(0, _invariant2.default)(
type instanceof _definition.GraphQLScalarType || type instanceof _definition.GraphQLEnumType,
'Must be input type')
// Scalar/Enum input checks to ensure the type can parse the value to
// a non-null value.
var parseResult = type.parseLiteral(valueNode)
if ((0, _isNullish2.default)(parseResult)) {
return ['Expected type "' + type.name + '", found ' + (0, _printer.print)(valueNode) + '.']
}
return []
}
/***/
}),
/* 19 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.isEqualType = isEqualType
exports.isTypeSubTypeOf = isTypeSubTypeOf
exports.doTypesOverlap = doTypesOverlap
var _definition = __webpack_require__(1)
/**
* Provided two types, return true if the types are equal (invariant).
*/
function isEqualType(typeA, typeB) {
// Equivalent types are equal.
if (typeA === typeB) {
return true
}
// If either type is non-null, the other must also be non-null.
if (typeA instanceof _definition.GraphQLNonNull && typeB instanceof _definition.GraphQLNonNull) {
return isEqualType(typeA.ofType, typeB.ofType)
}
// If either type is a list, the other must also be a list.
if (typeA instanceof _definition.GraphQLList && typeB instanceof _definition.GraphQLList) {
return isEqualType(typeA.ofType, typeB.ofType)
}
// Otherwise the types are not equal.
return false
}
/**
* Provided a type and a super type, return true if the first type is either
* equal or a subset of the second super type (covariant).
*/
/**
* Copyright (c) 2015, 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.
*/
function isTypeSubTypeOf(schema, maybeSubType, superType) {
// 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 _definition.GraphQLNonNull) {
if (maybeSubType instanceof _definition.GraphQLNonNull) {
return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType)
}
return false
} else if (maybeSubType instanceof _definition.GraphQLNonNull) {
// If superType is nullable, maybeSubType may be non-null or nullable.
return isTypeSubTypeOf(schema, maybeSubType.ofType, superType)
}
// If superType type is a list, maybeSubType type must also be a list.
if (superType instanceof _definition.GraphQLList) {
if (maybeSubType instanceof _definition.GraphQLList) {
return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType)
}
return false
} else if (maybeSubType instanceof _definition.GraphQLList) {
// 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 ((0, _definition.isAbstractType)(superType) && maybeSubType instanceof _definition.GraphQLObjectType
&& schema.isPossibleType(superType, maybeSubType)) {
return true
}
// Otherwise, the child type is not a valid subtype of the parent type.
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.
*/
function doTypesOverlap(schema, typeA, typeB) {
// So flow is aware this is constant
var _typeB = typeB
// Equivalent types overlap
if (typeA === _typeB) {
return true
}
if (typeA instanceof _definition.GraphQLInterfaceType || typeA instanceof _definition.GraphQLUnionType) {
if (_typeB instanceof _definition.GraphQLInterfaceType || _typeB instanceof _definition.GraphQLUnionType) {
// If both types are abstract, then determine if there is any intersection
// between possible concrete types of each.
return schema.getPossibleTypes(typeA).some(function(type) {
return schema.isPossibleType(_typeB, type)
})
}
// Determine if the latter type is a possible concrete type of the former.
return schema.isPossibleType(typeA, _typeB)
}
if (_typeB instanceof _definition.GraphQLInterfaceType || _typeB instanceof _definition.GraphQLUnionType) {
// Determine if the former type is a possible concrete type of the latter.
return schema.isPossibleType(_typeB, typeA)
}
// Otherwise the types do not overlap.
return false
}
/***/
}),
/* 20 */
/***/ (function(module, exports) {
/**
* Copyright (c) 2016, Lee Byron
* All rights reserved.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @ignore
*/
/**
* [Iterator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterator)
* is a *protocol* which describes a standard way to produce a sequence of
* values, typically the values of the Iterable represented by this Iterator.
*
* While described by the [ES2015 version of JavaScript](http://www.ecma-international.org/ecma-262/6.0/#sec-iterator-interface)
* it can be utilized by any version of JavaScript.
*
* @typedef {Object} Iterator
* @template T The type of each iterated value
* @property {function (): { value: T, done: boolean }} next
* A method which produces either the next value in a sequence or a result
* where the `done` property is `true` indicating the end of the Iterator.
*/
/**
* [Iterable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterable)
* is a *protocol* which when implemented allows a JavaScript object to define
* their iteration behavior, such as what values are looped over in a `for..of`
* loop or `iterall`'s `forEach` function. Many [built-in types](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#Builtin_iterables)
* implement the Iterable protocol, including `Array` and `Map`.
*
* While described by the [ES2015 version of JavaScript](http://www.ecma-international.org/ecma-262/6.0/#sec-iterable-interface)
* it can be utilized by any version of JavaScript.
*
* @typedef {Object} Iterable
* @template T The type of each iterated value
* @property {function (): Iterator} Symbol.iterator
* A method which produces an Iterator for this Iterable.
*/
// In ES2015 (or a polyfilled) environment, this will be Symbol.iterator
var SYMBOL_ITERATOR = typeof Symbol === 'function' && Symbol.iterator
/**
* A property name to be used as the name of an Iterable's method responsible
* for producing an Iterator, referred to as `@@iterator`. Typically represents
* the value `Symbol.iterator` but falls back to the string `"@@iterator"` when
* `Symbol.iterator` is not defined.
*
* Use `$$iterator` for defining new Iterables instead of `Symbol.iterator`,
* but do not use it for accessing existing Iterables, instead use
* `getIterator()` or `isIterable()`.
*
* @example
*
* var $$iterator = require('iterall').$$iterator
*
* function Counter (to) {
* this.to = to
* }
*
* Counter.prototype[$$iterator] = function () {
* return {
* to: this.to,
* num: 0,
* next () {
* if (this.num >= this.to) {
* return { value: undefined, done: true }
* }
* return { value: this.num++, done: false }
* }
* }
* }
*
* var counter = new Counter(3)
* for (var number of counter) {
* console.log(number) // 0 ... 1 ... 2
* }
*
* @type {Symbol|string}
*/
var $$iterator = SYMBOL_ITERATOR || '@@iterator'
exports.$$iterator = $$iterator
/**
* Returns true if the provided object implements the Iterator protocol via
* either implementing a `Symbol.iterator` or `"@@iterator"` method.
*
* @example
*
* var isIterable = require('iterall').isIterable
* isIterable([ 1, 2, 3 ]) // true
* isIterable('ABC') // true
* isIterable({ length: 1, 0: 'Alpha' }) // false
* isIterable({ key: 'value' }) // false
* isIterable(new Map()) // true
*
* @param obj
* A value which might implement the Iterable protocol.
* @return {boolean} true if Iterable.
*/
function isIterable(obj) {
return !!getIteratorMethod(obj)
}
exports.isIterable = isIterable
/**
* Returns true if the provided object implements the Array-like protocol via
* defining a positive-integer `length` property.
*
* @example
*
* var isArrayLike = require('iterall').isArrayLike
* isArrayLike([ 1, 2, 3 ]) // true
* isArrayLike('ABC') // true
* isArrayLike({ length: 1, 0: 'Alpha' }) // true
* isArrayLike({ key: 'value' }) // false
* isArrayLike(new Map()) // false
*
* @param obj
* A value which might implement the Array-like protocol.
* @return {boolean} true if Array-like.
*/
function isArrayLike(obj) {
var length = obj != null && obj.length
return typeof length === 'number' && length >= 0 && length % 1 === 0
}
exports.isArrayLike = isArrayLike
/**
* Returns true if the provided object is an Object (i.e. not a string literal)
* and is either Iterable or Array-like.
*
* This may be used in place of [Array.isArray()][isArray] to determine if an
* object should be iterated-over. It always excludes string literals and
* includes Arrays (regardless of if it is Iterable). It also includes other
* Array-like objects such as NodeList, TypedArray, and Buffer.
*
* @example
*
* var isCollection = require('iterall').isCollection
* isCollection([ 1, 2, 3 ]) // true
* isCollection('ABC') // false
* isCollection({ length: 1, 0: 'Alpha' }) // true
* isCollection({ key: 'value' }) // false
* isCollection(new Map()) // true
*
* @example
*
* var forEach = require('iterall').forEach
* if (isCollection(obj)) {
* forEach(obj, function (value) {
* console.log(value)
* })
* }
*
* @param obj
* An Object value which might implement the Iterable or Array-like protocols.
* @return {boolean} true if Iterable or Array-like Object.
*/
function isCollection(obj) {
return Object(obj) === obj && (isArrayLike(obj) || isIterable(obj))
}
exports.isCollection = isCollection
/**
* If the provided object implements the Iterator protocol, its Iterator object
* is returned. Otherwise returns undefined.
*
* @example
*
* var getIterator = require('iterall').getIterator
* var iterator = getIterator([ 1, 2, 3 ])
* iterator.next() // { value: 1, done: false }
* iterator.next() // { value: 2, done: false }
* iterator.next() // { value: 3, done: false }
* iterator.next() // { value: undefined, done: true }
*
* @template T the type of each iterated value
* @param {Iterable} iterable
* An Iterable object which is the source of an Iterator.
* @return {Iterator} new Iterator instance.
*/
function getIterator(iterable) {
var method = getIteratorMethod(iterable)
if (method) {
return method.call(iterable)
}
}
exports.getIterator = getIterator
/**
* If the provided object implements the Iterator protocol, the method
* responsible for producing its Iterator object is returned.
*
* This is used in rare cases for performance tuning. This method must be called
* with obj as the contextual this-argument.
*
* @example
*
* var getIteratorMethod = require('iterall').getIteratorMethod
* var myArray = [ 1, 2, 3 ]
* var method = getIteratorMethod(myArray)
* if (method) {
* var iterator = method.call(myArray)
* }
*
* @template T the type of each iterated value
* @param {Iterable} iterable
* An Iterable object which defines an `@@iterator` method.
* @return {function(): Iterator} `@@iterator` method.
*/
function getIteratorMethod(iterable) {
if (iterable != null) {
var method = SYMBOL_ITERATOR && iterable[SYMBOL_ITERATOR] || iterable['@@iterator']
if (typeof method === 'function') {
return method
}
}
}
exports.getIteratorMethod = getIteratorMethod
/**
* Given an object which either implements the Iterable protocol or is
* Array-like, iterate over it, calling the `callback` at each iteration.
*
* Use `forEach` where you would expect to use a `for ... of` loop in ES6.
* However `forEach` adheres to the behavior of [Array#forEach][] described in
* the ECMAScript specification, skipping over "holes" in Array-likes. It will
* also delegate to a `forEach` method on `collection` if one is defined,
* ensuring native performance for `Arrays`.
*
* Similar to [Array#forEach][], the `callback` function accepts three
* arguments, and is provided with `thisArg` as the calling context.
*
* Note: providing an infinite Iterator to forEach will produce an error.
*
* [Array#forEach]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach
*
* @example
*
* var forEach = require('iterall').forEach
*
* forEach(myIterable, function (value, index, iterable) {
* console.log(value, index, iterable === myIterable)
* })
*
* @example
*
* // ES6:
* for (let value of myIterable) {
* console.log(value)
* }
*
* // Any JavaScript environment:
* forEach(myIterable, function (value) {
* console.log(value)
* })
*
* @template T the type of each iterated value
* @param {Iterable|{ length: number }} collection
* The Iterable or array to iterate over.
* @param {function(T, number, object)} callback
* Function to execute for each iteration, taking up to three arguments
* @param [thisArg]
* Optional. Value to use as `this` when executing `callback`.
*/
function forEach(collection, callback, thisArg) {
if (collection != null) {
if (typeof collection.forEach === 'function') {
return collection.forEach(callback, thisArg)
}
var i = 0
var iterator = getIterator(collection)
if (iterator) {
var step
while (!(step = iterator.next()).done) {
callback.call(thisArg, step.value, i++, collection)
// Infinite Iterators could cause forEach to run forever.
// After a very large number of iterations, produce an error.
/* istanbul ignore if */
if (i > 9999999) {
throw new TypeError('Near-infinite iteration.')
}
}
} else if (isArrayLike(collection)) {
for (; i < collection.length; i++) {
if (collection.hasOwnProperty(i)) {
callback.call(thisArg, collection[i], i, collection)
}
}
}
}
}
exports.forEach = forEach
/**
* Similar to `getIterator()`, this method returns a new Iterator given an
* Iterable. However it will also create an Iterator for a non-Iterable
* Array-like collection, such as Array in a non-ES2015 environment.
*
* `createIterator` is complimentary to `forEach`, but allows a "pull"-based
* iteration as opposed to `forEach`'s "push"-based iteration.
*
* `createIterator` produces an Iterator for Array-likes with the same behavior
* as ArrayIteratorPrototype described in the ECMAScript specification, and
* does *not* skip over "holes".
*
* @example
*
* var createIterator = require('iterall').createIterator
*
* var myArraylike = { length: 3, 0: 'Alpha', 1: 'Bravo', 2: 'Charlie' }
* var iterator = createIterator(myArraylike)
* iterator.next() // { value: 'Alpha', done: false }
* iterator.next() // { value: 'Bravo', done: false }
* iterator.next() // { value: 'Charlie', done: false }
* iterator.next() // { value: undefined, done: true }
*
* @template T the type of each iterated value
* @param {Iterable|{ length: number }} collection
* An Iterable or Array-like object to produce an Iterator.
* @return {Iterator} new Iterator instance.
*/
function createIterator(collection) {
if (collection != null) {
var iterator = getIterator(collection)
if (iterator) {
return iterator
}
if (isArrayLike(collection)) {
return new ArrayLikeIterator(collection)
}
}
}
exports.createIterator = createIterator
// When the object provided to `createIterator` is not Iterable but is
// Array-like, this simple Iterator is created.
function ArrayLikeIterator(obj) {
this._o = obj
this._i = 0
}
// Note: all Iterators are themselves Iterable.
ArrayLikeIterator.prototype[$$iterator] = function() {
return this
}
// A simple state-machine determines the IteratorResult returned, yielding
// each value in the Array-like object in order of their indicies.
ArrayLikeIterator.prototype.next = function() {
if (this._o === void 0 || this._i >= this._o.length) {
this._o = void 0
return { value: void 0, done: true }
}
return { value: this._o[this._i++], done: false }
}
/***/
}),
/* 21 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.default = keyValMap
/**
* Copyright (c) 2015, 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.
*/
/**
* Creates a keyed JS object from an array, given a function to produce the keys
* and a function to produce the values from each item in the array.
*
* const phoneBook = [
* { name: 'Jon', num: '555-1234' },
* { name: 'Jenny', num: '867-5309' }
* ]
*
* // { Jon: '555-1234', Jenny: '867-5309' }
* const phonesByName = keyValMap(
* phoneBook,
* entry => entry.name,
* entry => entry.num
* )
*
*/
function keyValMap(list, keyFn, valFn) {
return list.reduce(function(map, item) {
return map[keyFn(item)] = valFn(item), map
}, {})
}
/***/
}),
/* 22 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.default = quotedOrList
/**
* Copyright (c) 2015, 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.
*/
var MAX_LENGTH = 5
/**
* Given [ A, B, C ] return '"A", "B", or "C"'.
*/
function quotedOrList(items) {
var selected = items.slice(0, MAX_LENGTH)
return selected.map(function(item) {
return '"' + item + '"'
}).reduce(function(list, quoted, index) {
return list + (selected.length > 2 ? ', ' : ' ') + (index === selected.length - 1 ? 'or ' : '') + quoted
})
}
/***/
}),
/* 23 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.default = suggestionList
/**
* Copyright (c) 2015, 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.
*/
/**
* Given an invalid input string and a list of valid options, returns a filtered
* list of valid options sorted based on their similarity with the input.
*/
function suggestionList(input, options) {
var optionsByDistance = Object.create(null)
var oLength = options.length
var inputThreshold = input.length / 2
for (var i = 0; i < oLength; i++) {
var distance = lexicalDistance(input, options[i])
var threshold = Math.max(inputThreshold, options[i].length / 2, 1)
if (distance <= threshold) {
optionsByDistance[options[i]] = distance
}
}
return Object.keys(optionsByDistance).sort(function(a, b) {
return optionsByDistance[a] - optionsByDistance[b]
})
}
/**
* Computes the lexical distance between strings A and B.
*
* The "distance" between two strings is given by counting the minimum number
* of edits needed to transform string A into string B. An edit can be an
* insertion, deletion, or substitution of a single character, or a swap of two
* adjacent characters.
*
* This distance can be useful for detecting typos in input or sorting
*
* @param {string} a
* @param {string} b
* @return {int} distance in number of edits
*/
function lexicalDistance(a, b) {
var i = void 0
var j = void 0
var d = []
var aLength = a.length
var bLength = b.length
for (i = 0; i <= aLength; i++) {
d[i] = [i]
}
for (j = 1; j <= bLength; j++) {
d[0][j] = j
}
for (i = 1; i <= aLength; i++) {
for (j = 1; j <= bLength; j++) {
var cost = a[i - 1] === b[j - 1] ? 0 : 1
d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost)
if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + cost)
}
}
}
return d[aLength][bLength]
}
/***/
}),
/* 24 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.TokenKind = undefined
exports.createLexer = createLexer
exports.getTokenDesc = getTokenDesc
var _error = __webpack_require__(0)
/**
* Given a Source object, this returns a Lexer for that source.
* A Lexer is a stateful stream generator in that every time
* it is advanced, it returns the next token in the Source. Assuming the
* source lexes, the final Token emitted by the lexer will be of kind
* EOF, after which the lexer will repeatedly return the same EOF token
* whenever called.
*/
function createLexer(source, options) {
var startOfFileToken = new Tok(SOF, 0, 0, 0, 0, null)
var lexer = {
source: source,
options: options,
lastToken: startOfFileToken,
token: startOfFileToken,
line: 1,
lineStart: 0,
advance: advanceLexer
}
return lexer
} /* /
/**
* Copyright (c) 2015, 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.
*/
function advanceLexer() {
var token = this.lastToken = this.token
if (token.kind !== EOF) {
do {
token = token.next = readToken(this, token)
} while (token.kind === COMMENT)
this.token = token
}
return token
}
/**
* The return type of createLexer.
*/
// Each kind of token.
var SOF = ''
var EOF = ''
var BANG = '!'
var DOLLAR = '$'
var PAREN_L = '('
var PAREN_R = ')'
var SPREAD = '...'
var COLON = ':'
var EQUALS = '='
var AT = '@'
var BRACKET_L = '['
var BRACKET_R = ']'
var BRACE_L = '{'
var PIPE = '|'
var BRACE_R = '}'
var NAME = 'Name'
var INT = 'Int'
var FLOAT = 'Float'
var STRING = 'String'
var COMMENT = 'Comment'
/**
* An exported enum describing the different kinds of tokens that the
* lexer emits.
*/
var TokenKind = exports.TokenKind = {
SOF: SOF,
EOF: EOF,
BANG: BANG,
DOLLAR: DOLLAR,
PAREN_L: PAREN_L,
PAREN_R: PAREN_R,
SPREAD: SPREAD,
COLON: COLON,
EQUALS: EQUALS,
AT: AT,
BRACKET_L: BRACKET_L,
BRACKET_R: BRACKET_R,
BRACE_L: BRACE_L,
PIPE: PIPE,
BRACE_R: BRACE_R,
NAME: NAME,
INT: INT,
FLOAT: FLOAT,
STRING: STRING,
COMMENT: COMMENT
}
/**
* A helper function to describe a token as a string for debugging
*/
function getTokenDesc(token) {
var value = token.value
return value ? token.kind + ' "' + value + '"' : token.kind
}
var charCodeAt = String.prototype.charCodeAt
var slice = String.prototype.slice
/**
* Helper function for constructing the Token object.
*/
function Tok(kind, start, end, line, column, prev, value) {
this.kind = kind
this.start = start
this.end = end
this.line = line
this.column = column
this.value = value
this.prev = prev
this.next = null
}
// Print a simplified form when appearing in JSON/util.inspect.
Tok.prototype.toJSON = Tok.prototype.inspect = function toJSON() {
return {
kind: this.kind,
value: this.value,
line: this.line,
column: this.column
}
}
function printCharCode(code) {
return (
// NaN/undefined represents access beyond the end of the file.
isNaN(code) ? EOF :
// Trust JSON for ASCII.
code < 0x007F ? JSON.stringify(String.fromCharCode(code)) :
// Otherwise print the escaped form.
'"\\u' + ('00' + code.toString(16).toUpperCase()).slice(-4) + '"'
)
}
/**
* Gets the next token from the source starting at the given position.
*
* This skips over whitespace and comments until it finds the next lexable
* token, then lexes punctuators immediately or calls the appropriate helper
* function for more complicated tokens.
*/
function readToken(lexer, prev) {
var source = lexer.source
var body = source.body
var bodyLength = body.length
var position = positionAfterWhitespace(body, prev.end, lexer)
var line = lexer.line
var col = 1 + position - lexer.lineStart
if (position >= bodyLength) {
return new Tok(EOF, bodyLength, bodyLength, line, col, prev)
}
var code = charCodeAt.call(body, position)
// SourceCharacter
if (code < 0x0020 && code !== 0x0009 && code !== 0x000A && code !== 0x000D) {
throw (0, _error.syntaxError)(source, position,
'Cannot contain the invalid character ' + printCharCode(code) + '.')
}
switch (code) {
// !
case 33:
return new Tok(BANG, position, position + 1, line, col, prev)
// #
case 35:
return readComment(source, position, line, col, prev)
// $
case 36:
return new Tok(DOLLAR, position, position + 1, line, col, prev)
// (
case 40:
return new Tok(PAREN_L, position, position + 1, line, col, prev)
// )
case 41:
return new Tok(PAREN_R, position, position + 1, line, col, prev)
// .
case 46:
if (charCodeAt.call(body, position + 1) === 46 && charCodeAt.call(body, position + 2) === 46) {
return new Tok(SPREAD, position, position + 3, line, col, prev)
}
break
// :
case 58:
return new Tok(COLON, position, position + 1, line, col, prev)
// =
case 61:
return new Tok(EQUALS, position, position + 1, line, col, prev)
// @
case 64:
return new Tok(AT, position, position + 1, line, col, prev)
// [
case 91:
return new Tok(BRACKET_L, position, position + 1, line, col, prev)
// ]
case 93:
return new Tok(BRACKET_R, position, position + 1, line, col, prev)
// {
case 123:
return new Tok(BRACE_L, position, position + 1, line, col, prev)
// |
case 124:
return new Tok(PIPE, position, position + 1, line, col, prev)
// }
case 125:
return new Tok(BRACE_R, position, position + 1, line, col, prev)
// A-Z _ a-z
case 65:
case 66:
case 67:
case 68:
case 69:
case 70:
case 71:
case 72:
case 73:
case 74:
case 75:
case 76:
case 77:
case 78:
case 79:
case 80:
case 81:
case 82:
case 83:
case 84:
case 85:
case 86:
case 87:
case 88:
case 89:
case 90:
case 95:
case 97:
case 98:
case 99:
case 100:
case 101:
case 102:
case 103:
case 104:
case 105:
case 106:
case 107:
case 108:
case 109:
case 110:
case 111:
case 112:
case 113:
case 114:
case 115:
case 116:
case 117:
case 118:
case 119:
case 120:
case 121:
case 122:
return readName(source, position, line, col, prev)
// - 0-9
case 45:
case 48:
case 49:
case 50:
case 51:
case 52:
case 53:
case 54:
case 55:
case 56:
case 57:
return readNumber(source, position, code, line, col, prev)
// "
case 34:
return readString(source, position, line, col, prev)
}
throw (0, _error.syntaxError)(source, position, unexpectedCharacterMessage(code))
}
/**
* Report a message that an unexpected character was encountered.
*/
function unexpectedCharacterMessage(code) {
if (code === 39) {
// '
return 'Unexpected single quote character (\'), did you mean to use ' + 'a double quote (")?'
}
return 'Cannot parse the unexpected character ' + printCharCode(code) + '.'
}
/**
* Reads from body starting at startPosition until it finds a non-whitespace
* or commented character, then returns the position of that character for
* lexing.
*/
function positionAfterWhitespace(body, startPosition, lexer) {
var bodyLength = body.length
var position = startPosition
while (position < bodyLength) {
var code = charCodeAt.call(body, position)
// tab | space | comma | BOM
if (code === 9 || code === 32 || code === 44 || code === 0xFEFF) {
++position
} else if (code === 10) {
// new line
++position
++lexer.line
lexer.lineStart = position
} else if (code === 13) {
// carriage return
if (charCodeAt.call(body, position + 1) === 10) {
position += 2
} else {
++position
}
++lexer.line
lexer.lineStart = position
} else {
break
}
}
return position
}
/**
* Reads a comment token from the source file.
*
* #[\u0009\u0020-\uFFFF]*
*/
function readComment(source, start, line, col, prev) {
var body = source.body
var code = void 0
var position = start
do {
code = charCodeAt.call(body, ++position)
} while (code !== null && (
// SourceCharacter but not LineTerminator
code > 0x001F || code === 0x0009))
return new Tok(COMMENT, start, position, line, col, prev, slice.call(body, start + 1, position))
}
/**
* Reads a number token from the source file, either a float
* or an int depending on whether a decimal point appears.
*
* Int: -?(0|[1-9][0-9]*)
* Float: -?(0|[1-9][0-9]*)(\.[0-9]+)?((E|e)(+|-)?[0-9]+)?
*/
function readNumber(source, start, firstCode, line, col, prev) {
var body = source.body
var code = firstCode
var position = start
var isFloat = false
if (code === 45) {
// -
code = charCodeAt.call(body, ++position)
}
if (code === 48) {
// 0
code = charCodeAt.call(body, ++position)
if (code >= 48 && code <= 57) {
throw (0, _error.syntaxError)(source, position,
'Invalid number, unexpected digit after 0: ' + printCharCode(code) + '.')
}
} else {
position = readDigits(source, position, code)
code = charCodeAt.call(body, position)
}
if (code === 46) {
// .
isFloat = true
code = charCodeAt.call(body, ++position)
position = readDigits(source, position, code)
code = charCodeAt.call(body, position)
}
if (code === 69 || code === 101) {
// E e
isFloat = true
code = charCodeAt.call(body, ++position)
if (code === 43 || code === 45) {
// + -
code = charCodeAt.call(body, ++position)
}
position = readDigits(source, position, code)
}
return new Tok(isFloat ? FLOAT : INT, start, position, line, col, prev, slice.call(body, start, position))
}
/**
* Returns the new position in the source after reading digits.
*/
function readDigits(source, start, firstCode) {
var body = source.body
var position = start
var code = firstCode
if (code >= 48 && code <= 57) {
// 0 - 9
do {
code = charCodeAt.call(body, ++position)
} while (code >= 48 && code <= 57) // 0 - 9
return position
}
throw (0, _error.syntaxError)(source, position,
'Invalid number, expected digit but got: ' + printCharCode(code) + '.')
}
/**
* Reads a string token from the source file.
*
* "([^"\\\u000A\u000D]|(\\(u[0-9a-fA-F]{4}|["\\/bfnrt])))*"
*/
function readString(source, start, line, col, prev) {
var body = source.body
var position = start + 1
var chunkStart = position
var code = 0
var value = ''
while (position < body.length && (code = charCodeAt.call(body, position)) !== null &&
// not LineTerminator
code !== 0x000A && code !== 0x000D &&
// not Quote (")
code !== 34) {
// SourceCharacter
if (code < 0x0020 && code !== 0x0009) {
throw (0, _error.syntaxError)(source, position,
'Invalid character within String: ' + printCharCode(code) + '.')
}
++position
if (code === 92) {
// \
value += slice.call(body, chunkStart, position - 1)
code = charCodeAt.call(body, position)
switch (code) {
case 34:
value += '"'
break
case 47:
value += '/'
break
case 92:
value += '\\'
break
case 98:
value += '\b'
break
case 102:
value += '\f'
break
case 110:
value += '\n'
break
case 114:
value += '\r'
break
case 116:
value += '\t'
break
case 117:
// u
var charCode = uniCharCode(charCodeAt.call(body, position + 1), charCodeAt.call(body, position + 2),
charCodeAt.call(body, position + 3), charCodeAt.call(body, position + 4))
if (charCode < 0) {
throw (0, _error.syntaxError)(source, position,
'Invalid character escape sequence: ' + ('\\u' + body.slice(position + 1, position + 5) + '.'))
}
value += String.fromCharCode(charCode)
position += 4
break
default:
throw (0, _error.syntaxError)(source, position,
'Invalid character escape sequence: \\' + String.fromCharCode(code) + '.')
}
++position
chunkStart = position
}
}
if (code !== 34) {
// quote (")
throw (0, _error.syntaxError)(source, position, 'Unterminated string.')
}
value += slice.call(body, chunkStart, position)
return new Tok(STRING, start, position + 1, line, col, prev, value)
}
/**
* Converts four hexidecimal chars to the integer that the
* string represents. For example, uniCharCode('0','0','0','f')
* will return 15, and uniCharCode('0','0','f','f') returns 255.
*
* Returns a negative number on error, if a char was invalid.
*
* This is implemented by noting that char2hex() returns -1 on error,
* which means the result of ORing the char2hex() will also be negative.
*/
function uniCharCode(a, b, c, d) {
return char2hex(a) << 12 | char2hex(b) << 8 | char2hex(c) << 4 | char2hex(d)
}
/**
* Converts a hex character to its integer value.
* '0' becomes 0, '9' becomes 9
* 'A' becomes 10, 'F' becomes 15
* 'a' becomes 10, 'f' becomes 15
*
* Returns -1 on error.
*/
function char2hex(a) {
return a >= 48 && a <= 57 ? a - 48 : // 0-9
a >= 65 && a <= 70 ? a - 55 : // A-F
a >= 97 && a <= 102 ? a - 87 : // a-f
-1
}
/**
* Reads an alphanumeric + underscore name from the source.
*
* [_A-Za-z][_0-9A-Za-z]*
*/
function readName(source, position, line, col, prev) {
var body = source.body
var bodyLength = body.length
var end = position + 1
var code = 0
while (end !== bodyLength && (code = charCodeAt.call(body, end)) !== null && (code === 95 || // _
code >= 48 && code <= 57 || // 0-9
code >= 65 && code <= 90 || // A-Z
code >= 97 && code <= 122 // a-z
)) {
++end
}
return new Tok(NAME, position, end, line, col, prev, slice.call(body, position, end))
}
/***/
}),
/* 25 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.getLocation = getLocation
/**
* Takes a Source and a UTF-8 character offset, and returns the corresponding
* line and column as a SourceLocation.
*/
/**
* Copyright (c) 2015, 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.
*/
function getLocation(source, position) {
var lineRegexp = /\r\n|[\n\r]/g
var line = 1
var column = position + 1
var match = void 0
while ((match = lineRegexp.exec(source.body)) && match.index < position) {
line += 1
column = position + 1 - (match.index + match[0].length)
}
return { line: line, column: column }
}
/**
* Represents a location in a Source.
*/
/***/
}),
/* 26 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function")
}
}
/**
* Copyright (c) 2015, 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.
*/
/**
* A representation of source input to GraphQL. The name is optional,
* but is mostly useful for clients who store GraphQL documents in
* source files; for example, if the GraphQL input is in a file Foo.graphql,
* it might be useful for name to be "Foo.graphql".
*/
var Source = exports.Source = function Source(body, name) {
_classCallCheck(this, Source)
this.body = body
this.name = name || 'GraphQL'
}
/***/
}),
/* 27 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.TypeInfo = undefined
var _kinds = __webpack_require__(2)
var Kind = _interopRequireWildcard(_kinds)
var _definition = __webpack_require__(1)
var _introspection = __webpack_require__(11)
var _typeFromAST = __webpack_require__(9)
var _find = __webpack_require__(10)
var _find2 = _interopRequireDefault(_find)
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
function _interopRequireWildcard(obj) {
if (obj && obj.__esModule) {
return obj
} else {
var newObj = {}
if (obj != null) {
for (var key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) {
newObj[key] = obj[key]
}
}
}
newObj.default = obj
return newObj
}
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function")
}
}
/**
* Copyright (c) 2015, 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.
*/
/**
* TypeInfo is a utility class which, given a GraphQL schema, can keep track
* of the current field and type definitions at any point in a GraphQL document
* AST during a recursive descent by calling `enter(node)` and `leave(node)`.
*/
var TypeInfo = exports.TypeInfo = function() {
function TypeInfo(schema,
// NOTE: this experimental optional second parameter is only needed in order
// to support non-spec-compliant codebases. You should never need to use it.
getFieldDefFn) {
_classCallCheck(this, TypeInfo)
this._schema = schema
this._typeStack = []
this._parentTypeStack = []
this._inputTypeStack = []
this._fieldDefStack = []
this._directive = null
this._argument = null
this._enumValue = null
this._getFieldDef = getFieldDefFn || getFieldDef
}
TypeInfo.prototype.getType = function getType() {
if (this._typeStack.length > 0) {
return this._typeStack[this._typeStack.length - 1]
}
}
TypeInfo.prototype.getParentType = function getParentType() {
if (this._parentTypeStack.length > 0) {
return this._parentTypeStack[this._parentTypeStack.length - 1]
}
}
TypeInfo.prototype.getInputType = function getInputType() {
if (this._inputTypeStack.length > 0) {
return this._inputTypeStack[this._inputTypeStack.length - 1]
}
}
TypeInfo.prototype.getFieldDef = function getFieldDef() {
if (this._fieldDefStack.length > 0) {
return this._fieldDefStack[this._fieldDefStack.length - 1]
}
}
TypeInfo.prototype.getDirective = function getDirective() {
return this._directive
}
TypeInfo.prototype.getArgument = function getArgument() {
return this._argument
}
TypeInfo.prototype.getEnumValue = function getEnumValue() {
return this._enumValue
}
// Flow does not yet handle this case.
TypeInfo.prototype.enter = function enter(node /* ASTNode */) {
var schema = this._schema
switch (node.kind) {
case Kind.SELECTION_SET:
var namedType = (0, _definition.getNamedType)(this.getType())
var compositeType = void 0
if ((0, _definition.isCompositeType)(namedType)) {
// isCompositeType is a type refining predicate, so this is safe.
compositeType = namedType
}
this._parentTypeStack.push(compositeType)
break
case Kind.FIELD:
var parentType = this.getParentType()
var fieldDef = void 0
if (parentType) {
fieldDef = this._getFieldDef(schema, parentType, node)
}
this._fieldDefStack.push(fieldDef)
this._typeStack.push(fieldDef && fieldDef.type)
break
case Kind.DIRECTIVE:
this._directive = schema.getDirective(node.name.value)
break
case Kind.OPERATION_DEFINITION:
var type = void 0
if (node.operation === 'query') {
type = schema.getQueryType()
} else if (node.operation === 'mutation') {
type = schema.getMutationType()
} else if (node.operation === 'subscription') {
type = schema.getSubscriptionType()
}
this._typeStack.push(type)
break
case Kind.INLINE_FRAGMENT:
case Kind.FRAGMENT_DEFINITION:
var typeConditionAST = node.typeCondition
var outputType = typeConditionAST ? (0, _typeFromAST.typeFromAST)(schema, typeConditionAST)
: this.getType()
this._typeStack.push(outputType)
break
case Kind.VARIABLE_DEFINITION:
var inputType = (0, _typeFromAST.typeFromAST)(schema, node.type)
this._inputTypeStack.push(inputType)
break
case Kind.ARGUMENT:
var argDef = void 0
var argType = void 0
var fieldOrDirective = this.getDirective() || this.getFieldDef()
if (fieldOrDirective) {
argDef = (0, _find2.default)(fieldOrDirective.args, function(arg) {
return arg.name === node.name.value
})
if (argDef) {
argType = argDef.type
}
}
this._argument = argDef
this._inputTypeStack.push(argType)
break
case Kind.LIST:
var listType = (0, _definition.getNullableType)(this.getInputType())
this._inputTypeStack.push(listType instanceof _definition.GraphQLList ? listType.ofType : undefined)
break
case Kind.OBJECT_FIELD:
var objectType = (0, _definition.getNamedType)(this.getInputType())
var fieldType = void 0
if (objectType instanceof _definition.GraphQLInputObjectType) {
var inputField = objectType.getFields()[node.name.value]
fieldType = inputField ? inputField.type : undefined
}
this._inputTypeStack.push(fieldType)
break
case Kind.ENUM:
var enumType = (0, _definition.getNamedType)(this.getInputType())
var enumValue = void 0
if (enumType instanceof _definition.GraphQLEnumType) {
enumValue = enumType.getValue(node.value)
}
this._enumValue = enumValue
break
}
}
TypeInfo.prototype.leave = function leave(node) {
switch (node.kind) {
case Kind.SELECTION_SET:
this._parentTypeStack.pop()
break
case Kind.FIELD:
this._fieldDefStack.pop()
this._typeStack.pop()
break
case Kind.DIRECTIVE:
this._directive = null
break
case Kind.OPERATION_DEFINITION:
case Kind.INLINE_FRAGMENT:
case Kind.FRAGMENT_DEFINITION:
this._typeStack.pop()
break
case Kind.VARIABLE_DEFINITION:
this._inputTypeStack.pop()
break
case Kind.ARGUMENT:
this._argument = null
this._inputTypeStack.pop()
break
case Kind.LIST:
case Kind.OBJECT_FIELD:
this._inputTypeStack.pop()
break
case Kind.ENUM:
this._enumValue = null
break
}
}
return TypeInfo
}()
/**
* Not exactly the same as the executor's definition of getFieldDef, in this
* statically evaluated environment we do not always have an Object type,
* and need to handle Interface and Union types.
*/
function getFieldDef(schema, parentType, fieldNode) {
var name = fieldNode.name.value
if (name === _introspection.SchemaMetaFieldDef.name && schema.getQueryType() === parentType) {
return _introspection.SchemaMetaFieldDef
}
if (name === _introspection.TypeMetaFieldDef.name && schema.getQueryType() === parentType) {
return _introspection.TypeMetaFieldDef
}
if (name === _introspection.TypeNameMetaFieldDef.name && (parentType instanceof _definition.GraphQLObjectType
|| parentType instanceof _definition.GraphQLInterfaceType || parentType
instanceof _definition.GraphQLUnionType)) {
return _introspection.TypeNameMetaFieldDef
}
if (parentType instanceof _definition.GraphQLObjectType || parentType
instanceof _definition.GraphQLInterfaceType) {
return parentType.getFields()[name]
}
}
/***/
}),
/* 28 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.assertValidName = assertValidName
/**
* Copyright (c) 2015, 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.
*/
var NAME_RX = /^[_a-zA-Z][_a-zA-Z0-9]*$/
// Ensures console warnings are only issued once.
var hasWarnedAboutDunder = false
/**
* Upholds the spec rules about naming.
*/
function assertValidName(name, isIntrospection) {
if (!name || typeof name !== 'string') {
throw new Error('Must be named. Unexpected name: ' + name + '.')
}
if (!isIntrospection && name.slice(0, 2) === '__' && !hasWarnedAboutDunder) {
hasWarnedAboutDunder = true
/* eslint-disable no-console */
if (console && console.error) {
var error = new Error(
'Name "' + name + '" must not begin with "__", which is reserved by ' + 'GraphQL introspection.')
console.error(error.stack || String(error))
}
/* eslint-enable no-console */
}
if (!NAME_RX.test(name)) {
throw new Error('Names must match /^[_a-zA-Z][_a-zA-Z0-9]*$/ but "' + name + '" does not.')
}
}
/***/
}),
/* 29 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.astFromValue = astFromValue
var _iterall = __webpack_require__(20)
var _invariant = __webpack_require__(3)
var _invariant2 = _interopRequireDefault(_invariant)
var _isNullish = __webpack_require__(6)
var _isNullish2 = _interopRequireDefault(_isNullish)
var _isInvalid = __webpack_require__(14)
var _isInvalid2 = _interopRequireDefault(_isInvalid)
var _kinds = __webpack_require__(2)
var _definition = __webpack_require__(1)
var _scalars = __webpack_require__(7)
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
/**
* Produces a GraphQL Value AST given a JavaScript value.
*
* A GraphQL type must be provided, which will be used to interpret different
* JavaScript values.
*
* | JSON Value | GraphQL Value |
* | ------------- | -------------------- |
* | Object | Input Object |
* | Array | List |
* | Boolean | Boolean |
* | String | String / Enum Value |
* | Number | Int / Float |
* | Mixed | Enum Value |
* | null | NullValue |
*
*/
function astFromValue(value, type) {
// Ensure flow knows that we treat function params as const.
var _value = value
if (type instanceof _definition.GraphQLNonNull) {
var astValue = astFromValue(_value, type.ofType)
if (astValue && astValue.kind === _kinds.NULL) {
return null
}
return astValue
}
// only explicit null, not undefined, NaN
if (_value === null) {
return { kind: _kinds.NULL }
}
// undefined, NaN
if ((0, _isInvalid2.default)(_value)) {
return null
}
// Convert JavaScript array to GraphQL list. If the GraphQLType is a list, but
// the value is not an array, convert the value using the list's item type.
if (type instanceof _definition.GraphQLList) {
var _ret = function() {
var itemType = type.ofType
if ((0, _iterall.isCollection)(_value)) {
var _ret2 = function() {
var valuesNodes = [];
(0, _iterall.forEach)(_value, function(item) {
var itemNode = astFromValue(item, itemType)
if (itemNode) {
valuesNodes.push(itemNode)
}
})
return {
v: {
v: { kind: _kinds.LIST, values: valuesNodes }
}
}
}()
if (typeof _ret2 === "object") {
return _ret2.v
}
}
return {
v: astFromValue(_value, itemType)
}
}()
if (typeof _ret === "object") {
return _ret.v
}
}
// Populate the fields of the input object by creating ASTs from each value
// in the JavaScript object according to the fields in the input type.
if (type instanceof _definition.GraphQLInputObjectType) {
var _ret3 = function() {
if (_value === null || typeof _value !== 'object') {
return {
v: null
}
}
var fields = type.getFields()
var fieldNodes = []
Object.keys(fields).forEach(function(fieldName) {
var fieldType = fields[fieldName].type
var fieldValue = astFromValue(_value[fieldName], fieldType)
if (fieldValue) {
fieldNodes.push({
kind: _kinds.OBJECT_FIELD,
name: { kind: _kinds.NAME, value: fieldName },
value: fieldValue
})
}
})
return {
v: { kind: _kinds.OBJECT, fields: fieldNodes }
}
}()
if (typeof _ret3 === "object") {
return _ret3.v
}
}
(0, _invariant2.default)(
type instanceof _definition.GraphQLScalarType || type instanceof _definition.GraphQLEnumType,
'Must provide Input Type, cannot use: ' + String(type))
// Since value is an internally represented value, it must be serialized
// to an externally represented value before converting into an AST.
var serialized = type.serialize(_value)
if ((0, _isNullish2.default)(serialized)) {
return null
}
// Others serialize based on their corresponding JavaScript scalar types.
if (typeof serialized === 'boolean') {
return { kind: _kinds.BOOLEAN, value: serialized }
}
// JavaScript numbers can be Int or Float values.
if (typeof serialized === 'number') {
var stringNum = String(serialized)
return (/^[0-9]+$/.test(stringNum) ? { kind: _kinds.INT, value: stringNum } : {
kind: _kinds.FLOAT,
value: stringNum
}
)
}
if (typeof serialized === 'string') {
// Enum types use Enum literals.
if (type instanceof _definition.GraphQLEnumType) {
return { kind: _kinds.ENUM, value: serialized }
}
// ID types can use Int literals.
if (type === _scalars.GraphQLID && /^[0-9]+$/.test(serialized)) {
return { kind: _kinds.INT, value: serialized }
}
// Use JSON stringify, which uses the same string encoding as GraphQL,
// then remove the quotes.
return {
kind: _kinds.STRING,
value: JSON.stringify(serialized).slice(1, -1)
}
}
throw new TypeError('Cannot convert value to AST: ' + String(serialized))
}
/**
* Copyright (c) 2015, 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.
*/
/***/
}),
/* 30 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.defaultFieldResolver = undefined
exports.execute = execute
exports.responsePathAsArray = responsePathAsArray
var _iterall = __webpack_require__(20)
var _error = __webpack_require__(0)
var _find = __webpack_require__(10)
var _find2 = _interopRequireDefault(_find)
var _invariant = __webpack_require__(3)
var _invariant2 = _interopRequireDefault(_invariant)
var _isNullish = __webpack_require__(6)
var _isNullish2 = _interopRequireDefault(_isNullish)
var _typeFromAST = __webpack_require__(9)
var _kinds = __webpack_require__(2)
var Kind = _interopRequireWildcard(_kinds)
var _values = __webpack_require__(31)
var _definition = __webpack_require__(1)
var _schema = __webpack_require__(8)
var _introspection = __webpack_require__(11)
var _directives = __webpack_require__(5)
function _interopRequireWildcard(obj) {
if (obj && obj.__esModule) {
return obj
} else {
var newObj = {}
if (obj != null) {
for (var key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) {
newObj[key] = obj[key]
}
}
}
newObj.default = obj
return newObj
}
}
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
/**
* Implements the "Evaluating requests" section of the GraphQL specification.
*
* Returns a Promise that will eventually be resolved and never rejected.
*
* If the arguments to this function do not result in a legal execution context,
* a GraphQLError will be thrown immediately explaining the invalid input.
*/
/**
* Terminology
*
* "Definitions" are the generic name for top-level statements in the document.
* Examples of this include:
* 1) Operations (such as a query)
* 2) Fragments
*
* "Operations" are a generic name for requests in the document.
* Examples of this include:
* 1) query,
* 2) mutation
*
* "Selections" are the definitions that can appear legally and at
* single level of the query. These include:
* 1) field references e.g "a"
* 2) fragment "spreads" e.g. "...c"
* 3) inline fragment "spreads" e.g. "...on Type { a }"
*/
/**
* Data that must be available at all points during query execution.
*
* Namely, schema of the type system that is currently executing,
* and the fragments defined in the query document
*/
/**
* The result of GraphQL execution.
*
* - `data` is the result of a successful execution of the query.
* - `errors` is included when any errors occurred as a non-empty array.
*/
/**
* Copyright (c) 2015, 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.
*/
function execute(schema, document, rootValue, contextValue, variableValues, operationName) {
(0, _invariant2.default)(schema, 'Must provide schema');
(0, _invariant2.default)(document, 'Must provide document');
(0, _invariant2.default)(schema instanceof _schema.GraphQLSchema,
'Schema must be an instance of GraphQLSchema. Also ensure that there are '
+ 'not multiple versions of GraphQL installed in your node_modules directory.');
// Variables, if provided, must be an object.
(0, _invariant2.default)(!variableValues || typeof variableValues === 'object',
'Variables must be provided as an Object where each property is a '
+ 'variable value. Perhaps look to see if an unparsed JSON string ' + 'was provided.')
// If a valid context cannot be created due to incorrect arguments,
// this will throw an error.
var context = buildExecutionContext(schema, document, rootValue, contextValue, variableValues, operationName)
// Return a Promise that will eventually resolve to the data described by
// The "Response" section of the GraphQL specification.
//
// If errors are encountered while executing a GraphQL field, only that
// field and its descendants will be omitted, and sibling fields will still
// be executed. An execution which encounters errors will still result in a
// resolved Promise.
return new Promise(function(resolve) {
resolve(executeOperation(context, context.operation, rootValue))
}).then(undefined, function(error) {
// Errors from sub-fields of a NonNull type may propagate to the top level,
// at which point we still log the error and null the parent field, which
// in this case is the entire response.
context.errors.push(error)
return null
}).then(function(data) {
if (!context.errors.length) {
return { data: data }
}
return { data: data, errors: context.errors }
})
}
/**
* Given a ResponsePath (found in the `path` entry in the information provided
* as the last argument to a field resolver), return an Array of the path keys.
*/
function responsePathAsArray(path) {
var flattened = []
var curr = path
while (curr) {
flattened.push(curr.key)
curr = curr.prev
}
return flattened.reverse()
}
function addPath(prev, key) {
return { prev: prev, key: key }
}
/**
* Constructs a ExecutionContext object from the arguments passed to
* execute, which we will pass throughout the other execution methods.
*
* Throws a GraphQLError if a valid execution context cannot be created.
*/
function buildExecutionContext(schema, document, rootValue, contextValue, rawVariableValues, operationName) {
var errors = []
var operation = void 0
var fragments = Object.create(null)
document.definitions.forEach(function(definition) {
switch (definition.kind) {
case Kind.OPERATION_DEFINITION:
if (!operationName && operation) {
throw new _error.GraphQLError('Must provide operation name if query contains multiple operations.')
}
if (!operationName || definition.name && definition.name.value === operationName) {
operation = definition
}
break
case Kind.FRAGMENT_DEFINITION:
fragments[definition.name.value] = definition
break
default:
throw new _error.GraphQLError('GraphQL cannot execute a request containing a ' + definition.kind + '.',
[definition])
}
})
if (!operation) {
if (operationName) {
throw new _error.GraphQLError('Unknown operation named "' + operationName + '".')
} else {
throw new _error.GraphQLError('Must provide an operation.')
}
}
var variableValues = (0, _values.getVariableValues)(schema, operation.variableDefinitions || [],
rawVariableValues || {})
return {
schema: schema,
fragments: fragments,
rootValue: rootValue,
contextValue: contextValue,
operation: operation,
variableValues: variableValues,
errors: errors
}
}
/**
* Implements the "Evaluating operations" section of the spec.
*/
function executeOperation(exeContext, operation, rootValue) {
var type = getOperationRootType(exeContext.schema, operation)
var fields = collectFields(exeContext, type, operation.selectionSet, Object.create(null),
Object.create(null))
var path = undefined
if (operation.operation === 'mutation') {
return executeFieldsSerially(exeContext, type, rootValue, path, fields)
}
return executeFields(exeContext, type, rootValue, path, fields)
}
/**
* Extracts the root type of the operation from the schema.
*/
function getOperationRootType(schema, operation) {
switch (operation.operation) {
case 'query':
return schema.getQueryType()
case 'mutation':
var mutationType = schema.getMutationType()
if (!mutationType) {
throw new _error.GraphQLError('Schema is not configured for mutations', [operation])
}
return mutationType
case 'subscription':
var subscriptionType = schema.getSubscriptionType()
if (!subscriptionType) {
throw new _error.GraphQLError('Schema is not configured for subscriptions', [operation])
}
return subscriptionType
default:
throw new _error.GraphQLError('Can only execute queries, mutations and subscriptions', [operation])
}
}
/**
* Implements the "Evaluating selection sets" section of the spec
* for "write" mode.
*/
function executeFieldsSerially(exeContext, parentType, sourceValue, path, fields) {
return Object.keys(fields).reduce(function(prevPromise, responseName) {
return prevPromise.then(function(results) {
var fieldNodes = fields[responseName]
var fieldPath = addPath(path, responseName)
var result = resolveField(exeContext, parentType, sourceValue, fieldNodes, fieldPath)
if (result === undefined) {
return results
}
if (isThenable(result)) {
return result.then(function(resolvedResult) {
results[responseName] = resolvedResult
return results
})
}
results[responseName] = result
return results
})
}, Promise.resolve({}))
}
/**
* Implements the "Evaluating selection sets" section of the spec
* for "read" mode.
*/
function executeFields(exeContext, parentType, sourceValue, path, fields) {
var containsPromise = false
var finalResults = Object.keys(fields).reduce(function(results, responseName) {
var fieldNodes = fields[responseName]
var fieldPath = addPath(path, responseName)
var result = resolveField(exeContext, parentType, sourceValue, fieldNodes, fieldPath)
if (result === undefined) {
return results
}
results[responseName] = result
if (isThenable(result)) {
containsPromise = true
}
return results
}, Object.create(null))
// If there are no promises, we can just return the object
if (!containsPromise) {
return finalResults
}
// Otherwise, results is a map from field name to the result
// of resolving that field, which is possibly a promise. Return
// a promise that will return this same map, but with any
// promises replaced with the values they resolved to.
return promiseForObject(finalResults)
}
/**
* Given a selectionSet, adds all of the fields in that selection to
* the passed in map of fields, and returns it at the end.
*
* CollectFields requires the "runtime type" of an object. For a field which
* returns and Interface or Union type, the "runtime type" will be the actual
* Object type returned by that field.
*/
function collectFields(exeContext, runtimeType, selectionSet, fields, visitedFragmentNames) {
for (var i = 0; i < selectionSet.selections.length; i++) {
var selection = selectionSet.selections[i]
switch (selection.kind) {
case Kind.FIELD:
if (!shouldIncludeNode(exeContext, selection.directives)) {
continue
}
var _name = getFieldEntryKey(selection)
if (!fields[_name]) {
fields[_name] = []
}
fields[_name].push(selection)
break
case Kind.INLINE_FRAGMENT:
if (!shouldIncludeNode(exeContext, selection.directives) || !doesFragmentConditionMatch(exeContext,
selection, runtimeType)) {
continue
}
collectFields(exeContext, runtimeType, selection.selectionSet, fields, visitedFragmentNames)
break
case Kind.FRAGMENT_SPREAD:
var fragName = selection.name.value
if (visitedFragmentNames[fragName] || !shouldIncludeNode(exeContext, selection.directives)) {
continue
}
visitedFragmentNames[fragName] = true
var fragment = exeContext.fragments[fragName]
if (!fragment || !doesFragmentConditionMatch(exeContext, fragment, runtimeType)) {
continue
}
collectFields(exeContext, runtimeType, fragment.selectionSet, fields, visitedFragmentNames)
break
}
}
return fields
}
/**
* Determines if a field should be included based on the @include and @skip
* directives, where @skip has higher precidence than @include.
*/
function shouldIncludeNode(exeContext, directives) {
var skipNode = directives && (0, _find2.default)(directives, function(directive) {
return directive.name.value === _directives.GraphQLSkipDirective.name
})
if (skipNode) {
var _getArgumentValues = (0, _values.getArgumentValues)(_directives.GraphQLSkipDirective, skipNode,
exeContext.variableValues),
skipIf = _getArgumentValues.if
if (skipIf === true) {
return false
}
}
var includeNode = directives && (0, _find2.default)(directives, function(directive) {
return directive.name.value === _directives.GraphQLIncludeDirective.name
})
if (includeNode) {
var _getArgumentValues2 = (0, _values.getArgumentValues)(_directives.GraphQLIncludeDirective, includeNode,
exeContext.variableValues),
includeIf = _getArgumentValues2.if
if (includeIf === false) {
return false
}
}
return true
}
/**
* Determines if a fragment is applicable to the given type.
*/
function doesFragmentConditionMatch(exeContext, fragment, type) {
var typeConditionNode = fragment.typeCondition
if (!typeConditionNode) {
return true
}
var conditionalType = (0, _typeFromAST.typeFromAST)(exeContext.schema, typeConditionNode)
if (conditionalType === type) {
return true
}
if ((0, _definition.isAbstractType)(conditionalType)) {
var abstractType = conditionalType
return exeContext.schema.isPossibleType(abstractType, type)
}
return false
}
/**
* This function transforms a JS object `{[key: string]: Promise}` into
* a `Promise<{[key: string]: T}>`
*
* This is akin to bluebird's `Promise.props`, but implemented only using
* `Promise.all` so it will work with any implementation of ES6 promises.
*/
function promiseForObject(object) {
var keys = Object.keys(object)
var valuesAndPromises = keys.map(function(name) {
return object[name]
})
return Promise.all(valuesAndPromises).then(function(values) {
return values.reduce(function(resolvedObject, value, i) {
resolvedObject[keys[i]] = value
return resolvedObject
}, Object.create(null))
})
}
/**
* Implements the logic to compute the key of a given field's entry
*/
function getFieldEntryKey(node) {
return node.alias ? node.alias.value : node.name.value
}
/**
* Resolves the field on the given source object. In particular, this
* figures out the value that the field returns by calling its resolve function,
* then calls completeValue to complete promises, serialize scalars, or execute
* the sub-selection-set for objects.
*/
function resolveField(exeContext, parentType, source, fieldNodes, path) {
var fieldNode = fieldNodes[0]
var fieldName = fieldNode.name.value
var fieldDef = getFieldDef(exeContext.schema, parentType, fieldName)
if (!fieldDef) {
return
}
var returnType = fieldDef.type
var resolveFn = fieldDef.resolve || defaultFieldResolver
// The resolve function's optional third argument is a context value that
// is provided to every resolve function within an execution. It is commonly
// used to represent an authenticated user, or request-specific caches.
var context = exeContext.contextValue
// The resolve function's optional fourth argument is a collection of
// information about the current execution state.
var info = {
fieldName: fieldName,
fieldNodes: fieldNodes,
returnType: returnType,
parentType: parentType,
path: path,
schema: exeContext.schema,
fragments: exeContext.fragments,
rootValue: exeContext.rootValue,
operation: exeContext.operation,
variableValues: exeContext.variableValues
}
// Get the resolve function, regardless of if its result is normal
// or abrupt (error).
var result = resolveOrError(exeContext, fieldDef, fieldNode, resolveFn, source, context, info)
return completeValueCatchingError(exeContext, returnType, fieldNodes, info, path, result)
}
// Isolates the "ReturnOrAbrupt" behavior to not de-opt the `resolveField`
// function. Returns the result of resolveFn or the abrupt-return Error object.
function resolveOrError(exeContext, fieldDef, fieldNode, resolveFn, source, context, info) {
try {
// Build a JS object of arguments from the field.arguments AST, using the
// variables scope to fulfill any variable references.
// TODO: find a way to memoize, in case this field is within a List type.
var args = (0, _values.getArgumentValues)(fieldDef, fieldNode, exeContext.variableValues)
return resolveFn(source, args, context, info)
} catch (error) {
// Sometimes a non-error is thrown, wrap it as an Error for a
// consistent interface.
return error instanceof Error ? error : new Error(error)
}
}
// This is a small wrapper around completeValue which detects and logs errors
// in the execution context.
function completeValueCatchingError(exeContext, returnType, fieldNodes, info, path, result) {
// If the field type is non-nullable, then it is resolved without any
// protection from errors, however it still properly locates the error.
if (returnType instanceof _definition.GraphQLNonNull) {
return completeValueWithLocatedError(exeContext, returnType, fieldNodes, info, path, result)
}
// Otherwise, error protection is applied, logging the error and resolving
// a null value for this field if one is encountered.
try {
var completed = completeValueWithLocatedError(exeContext, returnType, fieldNodes, info, path, result)
if (isThenable(completed)) {
// If `completeValueWithLocatedError` returned a rejected promise, log
// the rejection error and resolve to null.
// Note: we don't rely on a `catch` method, but we do expect "thenable"
// to take a second callback for the error case.
return completed.then(undefined, function(error) {
exeContext.errors.push(error)
return Promise.resolve(null)
})
}
return completed
} catch (error) {
// If `completeValueWithLocatedError` returned abruptly (threw an error),
// log the error and return null.
exeContext.errors.push(error)
return null
}
}
// This is a small wrapper around completeValue which annotates errors with
// location information.
function completeValueWithLocatedError(exeContext, returnType, fieldNodes, info, path, result) {
try {
var completed = completeValue(exeContext, returnType, fieldNodes, info, path, result)
if (isThenable(completed)) {
return completed.then(undefined, function(error) {
return Promise.reject((0, _error.locatedError)(error, fieldNodes, responsePathAsArray(path)))
})
}
return completed
} catch (error) {
throw (0, _error.locatedError)(error, fieldNodes, responsePathAsArray(path))
}
}
/**
* Implements the instructions for completeValue as defined in the
* "Field entries" section of the spec.
*
* If the field type is Non-Null, then this recursively completes the value
* for the inner type. It throws a field error if that completion returns null,
* as per the "Nullability" section of the spec.
*
* If the field type is a List, then this recursively completes the value
* for the inner type on each item in the list.
*
* If the field type is a Scalar or Enum, ensures the completed value is a legal
* value of the type by calling the `serialize` method of GraphQL type
* definition.
*
* If the field is an abstract type, determine the runtime type of the value
* and then complete based on that type
*
* Otherwise, the field type expects a sub-selection set, and will complete the
* value by evaluating all sub-selections.
*/
function completeValue(exeContext, returnType, fieldNodes, info, path, result) {
// If result is a Promise, apply-lift over completeValue.
if (isThenable(result)) {
return result.then(function(resolved) {
return completeValue(exeContext, returnType, fieldNodes, info, path, resolved)
})
}
// If result is an Error, throw a located error.
if (result instanceof Error) {
throw result
}
// If field type is NonNull, complete for inner type, and throw field error
// if result is null.
if (returnType instanceof _definition.GraphQLNonNull) {
var completed = completeValue(exeContext, returnType.ofType, fieldNodes, info, path, result)
if (completed === null) {
throw new Error(
'Cannot return null for non-nullable field ' + info.parentType.name + '.' + info.fieldName + '.')
}
return completed
}
// If result value is null-ish (null, undefined, or NaN) then return null.
if ((0, _isNullish2.default)(result)) {
return null
}
// If field type is List, complete each item in the list with the inner type
if (returnType instanceof _definition.GraphQLList) {
return completeListValue(exeContext, returnType, fieldNodes, info, path, result)
}
// If field type is a leaf type, Scalar or Enum, serialize to a valid value,
// returning null if serialization is not possible.
if (returnType instanceof _definition.GraphQLScalarType || returnType
instanceof _definition.GraphQLEnumType) {
return completeLeafValue(returnType, result)
}
// If field type is an abstract type, Interface or Union, determine the
// runtime Object type and complete for that type.
if (returnType instanceof _definition.GraphQLInterfaceType || returnType
instanceof _definition.GraphQLUnionType) {
return completeAbstractValue(exeContext, returnType, fieldNodes, info, path, result)
}
// If field type is Object, execute and complete all sub-selections.
if (returnType instanceof _definition.GraphQLObjectType) {
return completeObjectValue(exeContext, returnType, fieldNodes, info, path, result)
}
// Not reachable. All possible output types have been considered.
throw new Error('Cannot complete value of unexpected type "' + String(returnType) + '".')
}
/**
* Complete a list value by completing each item in the list with the
* inner type
*/
function completeListValue(exeContext, returnType, fieldNodes, info, path, result) {
(0, _invariant2.default)((0, _iterall.isCollection)(result),
'Expected Iterable, but did not find one for field ' + info.parentType.name + '.' + info.fieldName + '.')
// This is specified as a simple map, however we're optimizing the path
// where the list contains no Promises by avoiding creating another Promise.
var itemType = returnType.ofType
var containsPromise = false
var completedResults = [];
(0, _iterall.forEach)(result, function(item, index) {
// No need to modify the info object containing the path,
// since from here on it is not ever accessed by resolver functions.
var fieldPath = addPath(path, index)
var completedItem = completeValueCatchingError(exeContext, itemType, fieldNodes, info, fieldPath, item)
if (!containsPromise && isThenable(completedItem)) {
containsPromise = true
}
completedResults.push(completedItem)
})
return containsPromise ? Promise.all(completedResults) : completedResults
}
/**
* Complete a Scalar or Enum by serializing to a valid value, returning
* null if serialization is not possible.
*/
function completeLeafValue(returnType, result) {
(0, _invariant2.default)(returnType.serialize, 'Missing serialize method on type')
var serializedResult = returnType.serialize(result)
if ((0, _isNullish2.default)(serializedResult)) {
throw new Error(
'Expected a value of type "' + String(returnType) + '" but ' + ('received: ' + String(result)))
}
return serializedResult
}
/**
* Complete a value of an abstract type by determining the runtime object type
* of that value, then complete the value for that type.
*/
function completeAbstractValue(exeContext, returnType, fieldNodes, info, path, result) {
var runtimeType = returnType.resolveType ? returnType.resolveType(result, exeContext.contextValue, info)
: defaultResolveTypeFn(result, exeContext.contextValue, info, returnType)
if (isThenable(runtimeType)) {
// Cast to Promise
var runtimeTypePromise = runtimeType
return runtimeTypePromise.then(function(resolvedRuntimeType) {
return completeObjectValue(exeContext,
ensureValidRuntimeType(resolvedRuntimeType, exeContext, returnType, fieldNodes, info, result),
fieldNodes, info, path, result)
})
}
return completeObjectValue(exeContext,
ensureValidRuntimeType(runtimeType, exeContext, returnType, fieldNodes, info, result), fieldNodes, info,
path, result)
}
function ensureValidRuntimeType(runtimeTypeOrName, exeContext, returnType, fieldNodes, info, result) {
var runtimeType = typeof runtimeTypeOrName === 'string' ? exeContext.schema.getType(runtimeTypeOrName)
: runtimeTypeOrName
if (!(runtimeType instanceof _definition.GraphQLObjectType)) {
throw new _error.GraphQLError(
'Abstract type ' + returnType.name + ' must resolve to an Object type at ' + ('runtime for field '
+ info.parentType.name + '.' + info.fieldName + ' with ') + ('value "' + String(result)
+ '", received "' + String(runtimeType) + '".'), fieldNodes)
}
if (!exeContext.schema.isPossibleType(returnType, runtimeType)) {
throw new _error.GraphQLError(
'Runtime Object type "' + runtimeType.name + '" is not a possible type ' + ('for "' + returnType.name
+ '".'), fieldNodes)
}
return runtimeType
}
/**
* Complete an Object value by executing all sub-selections.
*/
function completeObjectValue(exeContext, returnType, fieldNodes, info, path, result) {
// If there is an isTypeOf predicate function, call it with the
// current result. If isTypeOf returns false, then raise an error rather
// than continuing execution.
if (returnType.isTypeOf) {
var isTypeOf = returnType.isTypeOf(result, exeContext.contextValue, info)
if (isThenable(isTypeOf)) {
return isTypeOf.then(function(isTypeOfResult) {
if (!isTypeOfResult) {
throw invalidReturnTypeError(returnType, result, fieldNodes)
}
return collectAndExecuteSubfields(exeContext, returnType, fieldNodes, info, path, result)
})
}
if (!isTypeOf) {
throw invalidReturnTypeError(returnType, result, fieldNodes)
}
}
return collectAndExecuteSubfields(exeContext, returnType, fieldNodes, info, path, result)
}
function invalidReturnTypeError(returnType, result, fieldNodes) {
return new _error.GraphQLError(
'Expected value of type "' + returnType.name + '" but got: ' + String(result) + '.', fieldNodes)
}
function collectAndExecuteSubfields(exeContext, returnType, fieldNodes, info, path, result) {
// Collect sub-fields to execute to complete this value.
var subFieldNodes = Object.create(null)
var visitedFragmentNames = Object.create(null)
for (var i = 0; i < fieldNodes.length; i++) {
var selectionSet = fieldNodes[i].selectionSet
if (selectionSet) {
subFieldNodes = collectFields(exeContext, returnType, selectionSet, subFieldNodes, visitedFragmentNames)
}
}
return executeFields(exeContext, returnType, result, path, subFieldNodes)
}
/**
* If a resolveType function is not given, then a default resolve behavior is
* used which tests each possible type for the abstract type by calling
* isTypeOf for the object being coerced, returning the first type that matches.
*/
function defaultResolveTypeFn(value, context, info, abstractType) {
var possibleTypes = info.schema.getPossibleTypes(abstractType)
var promisedIsTypeOfResults = []
for (var i = 0; i < possibleTypes.length; i++) {
var type = possibleTypes[i]
if (type.isTypeOf) {
var isTypeOfResult = type.isTypeOf(value, context, info)
if (isThenable(isTypeOfResult)) {
promisedIsTypeOfResults[i] = isTypeOfResult
} else if (isTypeOfResult) {
return type
}
}
}
if (promisedIsTypeOfResults.length) {
return Promise.all(promisedIsTypeOfResults).then(function(isTypeOfResults) {
for (var _i = 0; _i < isTypeOfResults.length; _i++) {
if (isTypeOfResults[_i]) {
return possibleTypes[_i]
}
}
})
}
}
/**
* If a resolve function is not given, then a default resolve behavior is used
* which takes the property of the source object of the same name as the field
* and returns it as the result, or if it's a function, returns the result
* of calling that function while passing along args and context.
*/
var defaultFieldResolver = exports.defaultFieldResolver = function defaultFieldResolver(source, args, context,
info) {
// ensure source is a value for which property access is acceptable.
if (typeof source === 'object' || typeof source === 'function') {
var property = source[info.fieldName]
if (typeof property === 'function') {
return source[info.fieldName](args, context, info)
}
return property
}
}
/**
* Checks to see if this object acts like a Promise, i.e. has a "then"
* function.
*/
function isThenable(value) {
return typeof value === 'object' && value !== null && typeof value.then === 'function'
}
/**
* This method looks up the field on the given type defintion.
* It has special casing for the two introspection fields, __schema
* and __typename. __typename is special because it can always be
* queried as a field, even in situations where no other fields
* are allowed, like on a Union. __schema could get automatically
* added to the query type, but that would require mutating type
* definitions, which would cause issues.
*/
function getFieldDef(schema, parentType, fieldName) {
if (fieldName === _introspection.SchemaMetaFieldDef.name && schema.getQueryType() === parentType) {
return _introspection.SchemaMetaFieldDef
} else if (fieldName === _introspection.TypeMetaFieldDef.name && schema.getQueryType() === parentType) {
return _introspection.TypeMetaFieldDef
} else if (fieldName === _introspection.TypeNameMetaFieldDef.name) {
return _introspection.TypeNameMetaFieldDef
}
return parentType.getFields()[fieldName]
}
/***/
}),
/* 31 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.getVariableValues = getVariableValues
exports.getArgumentValues = getArgumentValues
var _iterall = __webpack_require__(20)
var _error = __webpack_require__(0)
var _invariant = __webpack_require__(3)
var _invariant2 = _interopRequireDefault(_invariant)
var _isNullish = __webpack_require__(6)
var _isNullish2 = _interopRequireDefault(_isNullish)
var _isInvalid = __webpack_require__(14)
var _isInvalid2 = _interopRequireDefault(_isInvalid)
var _keyMap = __webpack_require__(12)
var _keyMap2 = _interopRequireDefault(_keyMap)
var _typeFromAST = __webpack_require__(9)
var _valueFromAST = __webpack_require__(16)
var _isValidJSValue = __webpack_require__(33)
var _isValidLiteralValue = __webpack_require__(18)
var _kinds = __webpack_require__(2)
var Kind = _interopRequireWildcard(_kinds)
var _printer = __webpack_require__(4)
var _definition = __webpack_require__(1)
function _interopRequireWildcard(obj) {
if (obj && obj.__esModule) {
return obj
} else {
var newObj = {}
if (obj != null) {
for (var key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) {
newObj[key] = obj[key]
}
}
}
newObj.default = obj
return newObj
}
}
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
/**
* Prepares an object map of variableValues of the correct type based on the
* provided variable definitions and arbitrary input. If the input cannot be
* parsed to match the variable definitions, a GraphQLError will be thrown.
*/
function getVariableValues(schema, varDefNodes, inputs) {
var coercedValues = Object.create(null)
for (var i = 0; i < varDefNodes.length; i++) {
var varDefNode = varDefNodes[i]
var varName = varDefNode.variable.name.value
var varType = (0, _typeFromAST.typeFromAST)(schema, varDefNode.type)
if (!(0, _definition.isInputType)(varType)) {
throw new _error.GraphQLError(
'Variable "$' + varName + '" expected value of type ' + ('"' + (0, _printer.print)(varDefNode.type)
+ '" which cannot be used as an input type.'), [varDefNode.type])
}
varType = varType
var value = inputs[varName]
if ((0, _isInvalid2.default)(value)) {
var defaultValue = varDefNode.defaultValue
if (defaultValue) {
coercedValues[varName] = (0, _valueFromAST.valueFromAST)(defaultValue, varType)
}
if (varType instanceof _definition.GraphQLNonNull) {
throw new _error.GraphQLError(
'Variable "$' + varName + '" of required type ' + ('"' + String(varType) + '" was not provided.'),
[varDefNode])
}
} else {
var errors = (0, _isValidJSValue.isValidJSValue)(value, varType)
if (errors.length) {
var message = errors ? '\n' + errors.join('\n') : ''
throw new _error.GraphQLError(
'Variable "$' + varName + '" got invalid value ' + (JSON.stringify(value) + '.' + message),
[varDefNode])
}
var coercedValue = coerceValue(varType, value);
(0, _invariant2.default)(!(0, _isInvalid2.default)(coercedValue), 'Should have reported error.')
coercedValues[varName] = coercedValue
}
}
return coercedValues
}
/**
* Prepares an object map of argument values given a list of argument
* definitions and list of argument AST nodes.
*/
/**
* Copyright (c) 2015, 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.
*/
function getArgumentValues(def, node, variableValues) {
var argDefs = def.args
var argNodes = node.arguments
if (!argDefs || !argNodes) {
return {}
}
var coercedValues = Object.create(null)
var argNodeMap = (0, _keyMap2.default)(argNodes, function(arg) {
return arg.name.value
})
for (var i = 0; i < argDefs.length; i++) {
var argDef = argDefs[i]
var name = argDef.name
var argType = argDef.type
var argumentNode = argNodeMap[name]
var defaultValue = argDef.defaultValue
if (!argumentNode) {
if (!(0, _isInvalid2.default)(defaultValue)) {
coercedValues[name] = defaultValue
} else if (argType instanceof _definition.GraphQLNonNull) {
throw new _error.GraphQLError(
'Argument "' + name + '" of required type ' + ('"' + String(argType) + '" was not provided.'),
[node])
}
} else if (argumentNode.value.kind === Kind.VARIABLE) {
var variableName = argumentNode.value.name.value
if (variableValues && !(0, _isInvalid2.default)(variableValues[variableName])) {
// Note: this does not check that this variable value is correct.
// This assumes that this query has been validated and the variable
// usage here is of the correct type.
coercedValues[name] = variableValues[variableName]
} else if (!(0, _isInvalid2.default)(defaultValue)) {
coercedValues[name] = defaultValue
} else if (argType instanceof _definition.GraphQLNonNull) {
throw new _error.GraphQLError('Argument "' + name + '" of required type "' + String(argType) + '" was '
+ ('provided the variable "$' + variableName + '" which was not provided ') + 'a runtime value.',
[argumentNode.value])
}
} else {
var valueNode = argumentNode.value
var coercedValue = (0, _valueFromAST.valueFromAST)(valueNode, argType, variableValues)
if ((0, _isInvalid2.default)(coercedValue)) {
var errors = (0, _isValidLiteralValue.isValidLiteralValue)(argType, valueNode)
var message = errors ? '\n' + errors.join('\n') : ''
throw new _error.GraphQLError(
'Argument "' + name + '" got invalid value ' + (0, _printer.print)(valueNode) + '.' + message,
[argumentNode.value])
}
coercedValues[name] = coercedValue
}
}
return coercedValues
}
/**
* Given a type and any value, return a runtime value coerced to match the type.
*/
function coerceValue(type, value) {
// Ensure flow knows that we treat function params as const.
var _value = value
if ((0, _isInvalid2.default)(_value)) {
return // Intentionally return no value.
}
if (type instanceof _definition.GraphQLNonNull) {
if (_value === null) {
return // Intentionally return no value.
}
return coerceValue(type.ofType, _value)
}
if (_value === null) {
// Intentionally return the value null.
return null
}
if (type instanceof _definition.GraphQLList) {
var itemType = type.ofType
if ((0, _iterall.isCollection)(_value)) {
var coercedValues = []
var valueIter = (0, _iterall.createIterator)(_value)
if (!valueIter) {
return // Intentionally return no value.
}
var step = void 0
while (!(step = valueIter.next()).done) {
var itemValue = coerceValue(itemType, step.value)
if ((0, _isInvalid2.default)(itemValue)) {
return // Intentionally return no value.
}
coercedValues.push(itemValue)
}
return coercedValues
}
var coercedValue = coerceValue(itemType, _value)
if ((0, _isInvalid2.default)(coercedValue)) {
return // Intentionally return no value.
}
return [coerceValue(itemType, _value)]
}
if (type instanceof _definition.GraphQLInputObjectType) {
if (typeof _value !== 'object') {
return // Intentionally return no value.
}
var coercedObj = Object.create(null)
var fields = type.getFields()
var fieldNames = Object.keys(fields)
for (var i = 0; i < fieldNames.length; i++) {
var fieldName = fieldNames[i]
var field = fields[fieldName]
if ((0, _isInvalid2.default)(_value[fieldName])) {
if (!(0, _isInvalid2.default)(field.defaultValue)) {
coercedObj[fieldName] = field.defaultValue
} else if (field.type instanceof _definition.GraphQLNonNull) {
return // Intentionally return no value.
}
continue
}
var fieldValue = coerceValue(field.type, _value[fieldName])
if ((0, _isInvalid2.default)(fieldValue)) {
return // Intentionally return no value.
}
coercedObj[fieldName] = fieldValue
}
return coercedObj
}
(0, _invariant2.default)(
type instanceof _definition.GraphQLScalarType || type instanceof _definition.GraphQLEnumType,
'Must be input type')
var parsed = type.parseValue(_value)
if ((0, _isNullish2.default)(parsed)) {
// null or invalid values represent a failure to parse correctly,
// in which case no value is returned.
return
}
return parsed
}
/***/
}),
/* 32 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.buildASTSchema = buildASTSchema
exports.getDescription = getDescription
exports.buildSchema = buildSchema
var _find = __webpack_require__(10)
var _find2 = _interopRequireDefault(_find)
var _invariant = __webpack_require__(3)
var _invariant2 = _interopRequireDefault(_invariant)
var _keyValMap = __webpack_require__(21)
var _keyValMap2 = _interopRequireDefault(_keyValMap)
var _valueFromAST = __webpack_require__(16)
var _lexer = __webpack_require__(24)
var _parser = __webpack_require__(17)
var _values = __webpack_require__(31)
var _kinds = __webpack_require__(2)
var _schema = __webpack_require__(8)
var _scalars = __webpack_require__(7)
var _definition = __webpack_require__(1)
var _directives = __webpack_require__(5)
var _introspection = __webpack_require__(11)
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
function buildWrappedType(innerType, inputTypeNode) {
if (inputTypeNode.kind === _kinds.LIST_TYPE) {
return new _definition.GraphQLList(buildWrappedType(innerType, inputTypeNode.type))
}
if (inputTypeNode.kind === _kinds.NON_NULL_TYPE) {
var wrappedType = buildWrappedType(innerType, inputTypeNode.type);
(0, _invariant2.default)(!(wrappedType instanceof _definition.GraphQLNonNull), 'No nesting nonnull.')
return new _definition.GraphQLNonNull(wrappedType)
}
return innerType
}
/**
* Copyright (c) 2015, 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.
*/
function getNamedTypeNode(typeNode) {
var namedType = typeNode
while (namedType.kind === _kinds.LIST_TYPE || namedType.kind === _kinds.NON_NULL_TYPE) {
namedType = namedType.type
}
return namedType
}
/**
* This takes the ast of a schema document produced by the parse function in
* src/language/parser.js.
*
* If no schema definition is provided, then it will look for types named Query
* and Mutation.
*
* Given that AST it constructs a GraphQLSchema. The resulting schema
* has no resolve methods, so execution will use default resolvers.
*/
function buildASTSchema(ast) {
if (!ast || ast.kind !== _kinds.DOCUMENT) {
throw new Error('Must provide a document ast.')
}
var schemaDef = void 0
var typeDefs = []
var nodeMap = Object.create(null)
var directiveDefs = []
for (var i = 0; i < ast.definitions.length; i++) {
var d = ast.definitions[i]
switch (d.kind) {
case _kinds.SCHEMA_DEFINITION:
if (schemaDef) {
throw new Error('Must provide only one schema definition.')
}
schemaDef = d
break
case _kinds.SCALAR_TYPE_DEFINITION:
case _kinds.OBJECT_TYPE_DEFINITION:
case _kinds.INTERFACE_TYPE_DEFINITION:
case _kinds.ENUM_TYPE_DEFINITION:
case _kinds.UNION_TYPE_DEFINITION:
case _kinds.INPUT_OBJECT_TYPE_DEFINITION:
typeDefs.push(d)
nodeMap[d.name.value] = d
break
case _kinds.DIRECTIVE_DEFINITION:
directiveDefs.push(d)
break
}
}
var queryTypeName = void 0
var mutationTypeName = void 0
var subscriptionTypeName = void 0
if (schemaDef) {
schemaDef.operationTypes.forEach(function(operationType) {
var typeName = operationType.type.name.value
if (operationType.operation === 'query') {
if (queryTypeName) {
throw new Error('Must provide only one query type in schema.')
}
if (!nodeMap[typeName]) {
throw new Error('Specified query type "' + typeName + '" not found in document.')
}
queryTypeName = typeName
} else if (operationType.operation === 'mutation') {
if (mutationTypeName) {
throw new Error('Must provide only one mutation type in schema.')
}
if (!nodeMap[typeName]) {
throw new Error('Specified mutation type "' + typeName + '" not found in document.')
}
mutationTypeName = typeName
} else if (operationType.operation === 'subscription') {
if (subscriptionTypeName) {
throw new Error('Must provide only one subscription type in schema.')
}
if (!nodeMap[typeName]) {
throw new Error('Specified subscription type "' + typeName + '" not found in document.')
}
subscriptionTypeName = typeName
}
})
} else {
if (nodeMap.Query) {
queryTypeName = 'Query'
}
if (nodeMap.Mutation) {
mutationTypeName = 'Mutation'
}
if (nodeMap.Subscription) {
subscriptionTypeName = 'Subscription'
}
}
if (!queryTypeName) {
throw new Error('Must provide schema definition with query type or a type named Query.')
}
var innerTypeMap = {
String: _scalars.GraphQLString,
Int: _scalars.GraphQLInt,
Float: _scalars.GraphQLFloat,
Boolean: _scalars.GraphQLBoolean,
ID: _scalars.GraphQLID,
__Schema: _introspection.__Schema,
__Directive: _introspection.__Directive,
__DirectiveLocation: _introspection.__DirectiveLocation,
__Type: _introspection.__Type,
__Field: _introspection.__Field,
__InputValue: _introspection.__InputValue,
__EnumValue: _introspection.__EnumValue,
__TypeKind: _introspection.__TypeKind
}
var types = typeDefs.map(function(def) {
return typeDefNamed(def.name.value)
})
var directives = directiveDefs.map(getDirective)
// If specified directives were not explicitly declared, add them.
if (!directives.some(function(directive) {
return directive.name === 'skip'
})) {
directives.push(_directives.GraphQLSkipDirective)
}
if (!directives.some(function(directive) {
return directive.name === 'include'
})) {
directives.push(_directives.GraphQLIncludeDirective)
}
if (!directives.some(function(directive) {
return directive.name === 'deprecated'
})) {
directives.push(_directives.GraphQLDeprecatedDirective)
}
return new _schema.GraphQLSchema({
query: getObjectType(nodeMap[queryTypeName]),
mutation: mutationTypeName ? getObjectType(nodeMap[mutationTypeName]) : null,
subscription: subscriptionTypeName ? getObjectType(nodeMap[subscriptionTypeName]) : null,
types: types,
directives: directives
})
function getDirective(directiveNode) {
return new _directives.GraphQLDirective({
name: directiveNode.name.value,
description: getDescription(directiveNode),
locations: directiveNode.locations.map(function(node) {
return node.value
}),
args: directiveNode.arguments && makeInputValues(directiveNode.arguments)
})
}
function getObjectType(typeNode) {
var type = typeDefNamed(typeNode.name.value);
(0, _invariant2.default)(type instanceof _definition.GraphQLObjectType, 'AST must provide object type.')
return type
}
function produceType(typeNode) {
var typeName = getNamedTypeNode(typeNode).name.value
var typeDef = typeDefNamed(typeName)
return buildWrappedType(typeDef, typeNode)
}
function produceInputType(typeNode) {
var type = produceType(typeNode);
(0, _invariant2.default)((0, _definition.isInputType)(type), 'Expected Input type.')
return type
}
function produceOutputType(typeNode) {
var type = produceType(typeNode);
(0, _invariant2.default)((0, _definition.isOutputType)(type), 'Expected Output type.')
return type
}
function produceObjectType(typeNode) {
var type = produceType(typeNode);
(0, _invariant2.default)(type instanceof _definition.GraphQLObjectType, 'Expected Object type.')
return type
}
function produceInterfaceType(typeNode) {
var type = produceType(typeNode);
(0, _invariant2.default)(type instanceof _definition.GraphQLInterfaceType, 'Expected Interface type.')
return type
}
function typeDefNamed(typeName) {
if (innerTypeMap[typeName]) {
return innerTypeMap[typeName]
}
if (!nodeMap[typeName]) {
throw new Error('Type "' + typeName + '" not found in document.')
}
var innerTypeDef = makeSchemaDef(nodeMap[typeName])
if (!innerTypeDef) {
throw new Error('Nothing constructed for "' + typeName + '".')
}
innerTypeMap[typeName] = innerTypeDef
return innerTypeDef
}
function makeSchemaDef(def) {
if (!def) {
throw new Error('def must be defined')
}
switch (def.kind) {
case _kinds.OBJECT_TYPE_DEFINITION:
return makeTypeDef(def)
case _kinds.INTERFACE_TYPE_DEFINITION:
return makeInterfaceDef(def)
case _kinds.ENUM_TYPE_DEFINITION:
return makeEnumDef(def)
case _kinds.UNION_TYPE_DEFINITION:
return makeUnionDef(def)
case _kinds.SCALAR_TYPE_DEFINITION:
return makeScalarDef(def)
case _kinds.INPUT_OBJECT_TYPE_DEFINITION:
return makeInputObjectDef(def)
default:
throw new Error('Type kind "' + def.kind + '" not supported.')
}
}
function makeTypeDef(def) {
var typeName = def.name.value
return new _definition.GraphQLObjectType({
name: typeName,
description: getDescription(def),
fields: function fields() {
return makeFieldDefMap(def)
},
interfaces: function interfaces() {
return makeImplementedInterfaces(def)
}
})
}
function makeFieldDefMap(def) {
return (0, _keyValMap2.default)(def.fields, function(field) {
return field.name.value
}, function(field) {
return {
type: produceOutputType(field.type),
description: getDescription(field),
args: makeInputValues(field.arguments),
deprecationReason: getDeprecationReason(field.directives)
}
})
}
function makeImplementedInterfaces(def) {
return def.interfaces && def.interfaces.map(function(iface) {
return produceInterfaceType(iface)
})
}
function makeInputValues(values) {
return (0, _keyValMap2.default)(values, function(value) {
return value.name.value
}, function(value) {
var type = produceInputType(value.type)
return {
type: type,
description: getDescription(value),
defaultValue: (0, _valueFromAST.valueFromAST)(value.defaultValue, type)
}
})
}
function makeInterfaceDef(def) {
var typeName = def.name.value
return new _definition.GraphQLInterfaceType({
name: typeName,
description: getDescription(def),
fields: function fields() {
return makeFieldDefMap(def)
},
resolveType: cannotExecuteSchema
})
}
function makeEnumDef(def) {
var enumType = new _definition.GraphQLEnumType({
name: def.name.value,
description: getDescription(def),
values: (0, _keyValMap2.default)(def.values, function(enumValue) {
return enumValue.name.value
}, function(enumValue) {
return {
description: getDescription(enumValue),
deprecationReason: getDeprecationReason(enumValue.directives)
}
})
})
return enumType
}
function makeUnionDef(def) {
return new _definition.GraphQLUnionType({
name: def.name.value,
description: getDescription(def),
types: def.types.map(function(t) {
return produceObjectType(t)
}),
resolveType: cannotExecuteSchema
})
}
function makeScalarDef(def) {
return new _definition.GraphQLScalarType({
name: def.name.value,
description: getDescription(def),
serialize: function serialize() {
return null
},
// Note: validation calls the parse functions to determine if a
// literal value is correct. Returning null would cause use of custom
// scalars to always fail validation. Returning false causes them to
// always pass validation.
parseValue: function parseValue() {
return false
},
parseLiteral: function parseLiteral() {
return false
}
})
}
function makeInputObjectDef(def) {
return new _definition.GraphQLInputObjectType({
name: def.name.value,
description: getDescription(def),
fields: function fields() {
return makeInputValues(def.fields)
}
})
}
}
function getDeprecationReason(directives) {
var deprecatedAST = directives && (0, _find2.default)(directives, function(directive) {
return directive.name.value === _directives.GraphQLDeprecatedDirective.name
})
if (!deprecatedAST) {
return
}
var _getArgumentValues = (0, _values.getArgumentValues)(_directives.GraphQLDeprecatedDirective,
deprecatedAST),
reason = _getArgumentValues.reason
return reason
}
/**
* Given an ast node, returns its string description based on a contiguous
* block full-line of comments preceding it.
*/
function getDescription(node) {
var loc = node.loc
if (!loc) {
return
}
var comments = []
var minSpaces = void 0
var token = loc.startToken.prev
while (token && token.kind === _lexer.TokenKind.COMMENT && token.next && token.prev && token.line + 1
=== token.next.line && token.line !== token.prev.line) {
var value = String(token.value)
var spaces = leadingSpaces(value)
if (minSpaces === undefined || spaces < minSpaces) {
minSpaces = spaces
}
comments.push(value)
token = token.prev
}
return comments.reverse().map(function(comment) {
return comment.slice(minSpaces)
}).join('\n')
}
/**
* A helper function to build a GraphQLSchema directly from a source
* document.
*/
function buildSchema(source) {
return buildASTSchema((0, _parser.parse)(source))
}
// Count the number of spaces on the starting side of a string.
function leadingSpaces(str) {
var i = 0
for (; i < str.length; i++) {
if (str[i] !== ' ') {
break
}
}
return i
}
function cannotExecuteSchema() {
throw new Error('Generated Schema cannot use Interface or Union types for execution.')
}
/***/
}),
/* 33 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.isValidJSValue = isValidJSValue
var _iterall = __webpack_require__(20)
var _invariant = __webpack_require__(3)
var _invariant2 = _interopRequireDefault(_invariant)
var _isNullish = __webpack_require__(6)
var _isNullish2 = _interopRequireDefault(_isNullish)
var _definition = __webpack_require__(1)
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
/**
* Given a JavaScript value and a GraphQL type, determine if the value will be
* accepted for that type. This is primarily useful for validating the
* runtime values of query variables.
*/
/**
* Copyright (c) 2015, 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.
*/
function isValidJSValue(value, type) {
// A value must be provided if the type is non-null.
if (type instanceof _definition.GraphQLNonNull) {
if ((0, _isNullish2.default)(value)) {
return ['Expected "' + String(type) + '", found null.']
}
return isValidJSValue(value, type.ofType)
}
if ((0, _isNullish2.default)(value)) {
return []
}
// Lists accept a non-list value as a list of one.
if (type instanceof _definition.GraphQLList) {
var _ret = function() {
var itemType = type.ofType
if ((0, _iterall.isCollection)(value)) {
var _ret2 = function() {
var errors = [];
(0, _iterall.forEach)(value, function(item, index) {
errors.push.apply(errors, isValidJSValue(item, itemType).map(function(error) {
return 'In element #' + index + ': ' + error
}))
})
return {
v: {
v: errors
}
}
}()
if (typeof _ret2 === "object") {
return _ret2.v
}
}
return {
v: isValidJSValue(value, itemType)
}
}()
if (typeof _ret === "object") {
return _ret.v
}
}
// Input objects check each defined field.
if (type instanceof _definition.GraphQLInputObjectType) {
var _ret3 = function() {
if (typeof value !== 'object' || value === null) {
return {
v: ['Expected "' + type.name + '", found not an object.']
}
}
var fields = type.getFields()
var errors = []
// Ensure every provided field is defined.
Object.keys(value).forEach(function(providedField) {
if (!fields[providedField]) {
errors.push('In field "' + providedField + '": Unknown field.')
}
})
// Ensure every defined field is valid.
Object.keys(fields).forEach(function(fieldName) {
var newErrors = isValidJSValue(value[fieldName], fields[fieldName].type)
errors.push.apply(errors, newErrors.map(function(error) {
return 'In field "' + fieldName + '": ' + error
}))
})
return {
v: errors
}
}()
if (typeof _ret3 === "object") {
return _ret3.v
}
}
(0, _invariant2.default)(
type instanceof _definition.GraphQLScalarType || type instanceof _definition.GraphQLEnumType,
'Must be input type')
// Scalar/Enum input checks to ensure the type can parse the value to
// a non-null value.
try {
var parseResult = type.parseValue(value)
if ((0, _isNullish2.default)(parseResult)) {
return ['Expected type "' + type.name + '", found ' + JSON.stringify(value) + '.']
}
} catch (error) {
return ['Expected type "' + type.name + '", found ' + JSON.stringify(value) + ': ' + error.message]
}
return []
}
/***/
}),
/* 34 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.specifiedRules = undefined
var _UniqueOperationNames = __webpack_require__(77)
var _LoneAnonymousOperation = __webpack_require__(64)
var _KnownTypeNames = __webpack_require__(63)
var _FragmentsOnCompositeTypes = __webpack_require__(59)
var _VariablesAreInputTypes = __webpack_require__(79)
var _ScalarLeafs = __webpack_require__(72)
var _FieldsOnCorrectType = __webpack_require__(58)
var _UniqueFragmentNames = __webpack_require__(75)
var _KnownFragmentNames = __webpack_require__(62)
var _NoUnusedFragments = __webpack_require__(67)
var _PossibleFragmentSpreads = __webpack_require__(70)
var _NoFragmentCycles = __webpack_require__(65)
var _UniqueVariableNames = __webpack_require__(78)
var _NoUndefinedVariables = __webpack_require__(66)
var _NoUnusedVariables = __webpack_require__(68)
var _KnownDirectives = __webpack_require__(61)
var _UniqueDirectivesPerLocation = __webpack_require__(74)
var _KnownArgumentNames = __webpack_require__(60)
var _UniqueArgumentNames = __webpack_require__(73)
var _ArgumentsOfCorrectType = __webpack_require__(56)
var _ProvidedNonNullArguments = __webpack_require__(71)
var _DefaultValuesOfCorrectType = __webpack_require__(57)
var _VariablesInAllowedPosition = __webpack_require__(80)
var _OverlappingFieldsCanBeMerged = __webpack_require__(69)
var _UniqueInputFieldNames = __webpack_require__(76)
/**
* This set includes all validation rules defined by the GraphQL spec.
*/
// Spec Section: "Field Selection Merging"
// Spec Section: "Variable Default Values Are Correctly Typed"
// Spec Section: "Argument Values Type Correctness"
// Spec Section: "Argument Names"
// Spec Section: "Directives Are Defined"
// Spec Section: "All Variable Used Defined"
// Spec Section: "Fragments must not form cycles"
// Spec Section: "Fragments must be used"
// Spec Section: "Fragment Name Uniqueness"
// Spec Section: "Leaf Field Selections"
// Spec Section: "Fragments on Composite Types"
// Spec Section: "Lone Anonymous Operation"
var specifiedRules = exports.specifiedRules = [_UniqueOperationNames.UniqueOperationNames,
_LoneAnonymousOperation.LoneAnonymousOperation, _KnownTypeNames.KnownTypeNames,
_FragmentsOnCompositeTypes.FragmentsOnCompositeTypes, _VariablesAreInputTypes.VariablesAreInputTypes,
_ScalarLeafs.ScalarLeafs, _FieldsOnCorrectType.FieldsOnCorrectType, _UniqueFragmentNames.UniqueFragmentNames,
_KnownFragmentNames.KnownFragmentNames, _NoUnusedFragments.NoUnusedFragments,
_PossibleFragmentSpreads.PossibleFragmentSpreads, _NoFragmentCycles.NoFragmentCycles,
_UniqueVariableNames.UniqueVariableNames, _NoUndefinedVariables.NoUndefinedVariables,
_NoUnusedVariables.NoUnusedVariables, _KnownDirectives.KnownDirectives,
_UniqueDirectivesPerLocation.UniqueDirectivesPerLocation, _KnownArgumentNames.KnownArgumentNames,
_UniqueArgumentNames.UniqueArgumentNames, _ArgumentsOfCorrectType.ArgumentsOfCorrectType,
_ProvidedNonNullArguments.ProvidedNonNullArguments, _DefaultValuesOfCorrectType.DefaultValuesOfCorrectType,
_VariablesInAllowedPosition.VariablesInAllowedPosition,
_OverlappingFieldsCanBeMerged.OverlappingFieldsCanBeMerged, _UniqueInputFieldNames.UniqueInputFieldNames]
// Spec Section: "Input Object Field Uniqueness"
// Spec Section: "All Variable Usages Are Allowed"
// Spec Section: "Argument Optionality"
// Spec Section: "Argument Uniqueness"
// Spec Section: "Directives Are Unique Per Location"
// Spec Section: "All Variables Used"
// Spec Section: "Variable Uniqueness"
// Spec Section: "Fragment spread is possible"
// Spec Section: "Fragment spread target defined"
// Spec Section: "Field Selections on Objects, Interfaces, and Unions Types"
// Spec Section: "Variables are Input Types"
// Spec Section: "Fragment Spread Type Existence"
/**
* Copyright (c) 2015, 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.
*/
// Spec Section: "Operation Name Uniqueness"
/***/
}),
/* 35 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.ValidationContext = undefined
exports.validate = validate
exports.visitUsingRules = visitUsingRules
var _invariant = __webpack_require__(3)
var _invariant2 = _interopRequireDefault(_invariant)
var _error = __webpack_require__(0)
var _visitor = __webpack_require__(15)
var _kinds = __webpack_require__(2)
var Kind = _interopRequireWildcard(_kinds)
var _schema = __webpack_require__(8)
var _TypeInfo = __webpack_require__(27)
var _specifiedRules = __webpack_require__(34)
function _interopRequireWildcard(obj) {
if (obj && obj.__esModule) {
return obj
} else {
var newObj = {}
if (obj != null) {
for (var key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) {
newObj[key] = obj[key]
}
}
}
newObj.default = obj
return newObj
}
}
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function")
}
}
/**
* Copyright (c) 2015, 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.
*/
/**
* Implements the "Validation" section of the spec.
*
* Validation runs synchronously, returning an array of encountered errors, or
* an empty array if no errors were encountered and the document is valid.
*
* A list of specific validation rules may be provided. If not provided, the
* default list of rules defined by the GraphQL specification will be used.
*
* Each validation rules is a function which returns a visitor
* (see the language/visitor API). Visitor methods are expected to return
* GraphQLErrors, or Arrays of GraphQLErrors when invalid.
*/
function validate(schema, ast, rules) {
(0, _invariant2.default)(schema, 'Must provide schema');
(0, _invariant2.default)(ast, 'Must provide document');
(0, _invariant2.default)(schema instanceof _schema.GraphQLSchema,
'Schema must be an instance of GraphQLSchema. Also ensure that there are '
+ 'not multiple versions of GraphQL installed in your node_modules directory.')
var typeInfo = new _TypeInfo.TypeInfo(schema)
return visitUsingRules(schema, typeInfo, ast, rules || _specifiedRules.specifiedRules)
}
/**
* This uses a specialized visitor which runs multiple visitors in parallel,
* while maintaining the visitor skip and break API.
*
* @internal
*/
function visitUsingRules(schema, typeInfo, documentAST, rules) {
var context = new ValidationContext(schema, documentAST, typeInfo)
var visitors = rules.map(function(rule) {
return rule(context)
});
// Visit the whole document with each instance of all provided rules.
(0, _visitor.visit)(documentAST,
(0, _visitor.visitWithTypeInfo)(typeInfo, (0, _visitor.visitInParallel)(visitors)))
return context.getErrors()
}
/**
* An instance of this class is passed as the "this" context to all validators,
* allowing access to commonly useful contextual information from within a
* validation rule.
*/
var ValidationContext = exports.ValidationContext = function() {
function ValidationContext(schema, ast, typeInfo) {
_classCallCheck(this, ValidationContext)
this._schema = schema
this._ast = ast
this._typeInfo = typeInfo
this._errors = []
this._fragmentSpreads = new Map()
this._recursivelyReferencedFragments = new Map()
this._variableUsages = new Map()
this._recursiveVariableUsages = new Map()
}
ValidationContext.prototype.reportError = function reportError(error) {
this._errors.push(error)
}
ValidationContext.prototype.getErrors = function getErrors() {
return this._errors
}
ValidationContext.prototype.getSchema = function getSchema() {
return this._schema
}
ValidationContext.prototype.getDocument = function getDocument() {
return this._ast
}
ValidationContext.prototype.getFragment = function getFragment(name) {
var fragments = this._fragments
if (!fragments) {
this._fragments = fragments = this.getDocument().definitions.reduce(function(frags, statement) {
if (statement.kind === Kind.FRAGMENT_DEFINITION) {
frags[statement.name.value] = statement
}
return frags
}, {})
}
return fragments[name]
}
ValidationContext.prototype.getFragmentSpreads = function getFragmentSpreads(node) {
var spreads = this._fragmentSpreads.get(node)
if (!spreads) {
spreads = []
var setsToVisit = [node]
while (setsToVisit.length !== 0) {
var set = setsToVisit.pop()
for (var i = 0; i < set.selections.length; i++) {
var selection = set.selections[i]
if (selection.kind === Kind.FRAGMENT_SPREAD) {
spreads.push(selection)
} else if (selection.selectionSet) {
setsToVisit.push(selection.selectionSet)
}
}
}
this._fragmentSpreads.set(node, spreads)
}
return spreads
}
ValidationContext.prototype.getRecursivelyReferencedFragments = function getRecursivelyReferencedFragments(operation) {
var fragments = this._recursivelyReferencedFragments.get(operation)
if (!fragments) {
fragments = []
var collectedNames = Object.create(null)
var nodesToVisit = [operation.selectionSet]
while (nodesToVisit.length !== 0) {
var _node = nodesToVisit.pop()
var spreads = this.getFragmentSpreads(_node)
for (var i = 0; i < spreads.length; i++) {
var fragName = spreads[i].name.value
if (collectedNames[fragName] !== true) {
collectedNames[fragName] = true
var fragment = this.getFragment(fragName)
if (fragment) {
fragments.push(fragment)
nodesToVisit.push(fragment.selectionSet)
}
}
}
}
this._recursivelyReferencedFragments.set(operation, fragments)
}
return fragments
}
ValidationContext.prototype.getVariableUsages = function getVariableUsages(node) {
var _this = this
var usages = this._variableUsages.get(node)
if (!usages) {
(function() {
var newUsages = []
var typeInfo = new _TypeInfo.TypeInfo(_this._schema);
(0, _visitor.visit)(node, (0, _visitor.visitWithTypeInfo)(typeInfo, {
VariableDefinition: function VariableDefinition() {
return false
},
Variable: function Variable(variable) {
newUsages.push({ node: variable, type: typeInfo.getInputType() })
}
}))
usages = newUsages
_this._variableUsages.set(node, usages)
})()
}
return usages
}
ValidationContext.prototype.getRecursiveVariableUsages = function getRecursiveVariableUsages(operation) {
var usages = this._recursiveVariableUsages.get(operation)
if (!usages) {
usages = this.getVariableUsages(operation)
var fragments = this.getRecursivelyReferencedFragments(operation)
for (var i = 0; i < fragments.length; i++) {
Array.prototype.push.apply(usages, this.getVariableUsages(fragments[i]))
}
this._recursiveVariableUsages.set(operation, usages)
}
return usages
}
ValidationContext.prototype.getType = function getType() {
return this._typeInfo.getType()
}
ValidationContext.prototype.getParentType = function getParentType() {
return this._typeInfo.getParentType()
}
ValidationContext.prototype.getInputType = function getInputType() {
return this._typeInfo.getInputType()
}
ValidationContext.prototype.getFieldDef = function getFieldDef() {
return this._typeInfo.getFieldDef()
}
ValidationContext.prototype.getDirective = function getDirective() {
return this._typeInfo.getDirective()
}
ValidationContext.prototype.getArgument = function getArgument() {
return this._typeInfo.getArgument()
}
return ValidationContext
}()
/***/
}),
/* 36 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
var _graphql = __webpack_require__(42)
Object.defineProperty(exports, 'graphql', {
enumerable: true,
get: function get() {
return _graphql.graphql
}
})
var _type = __webpack_require__(44)
Object.defineProperty(exports, 'GraphQLSchema', {
enumerable: true,
get: function get() {
return _type.GraphQLSchema
}
})
Object.defineProperty(exports, 'GraphQLScalarType', {
enumerable: true,
get: function get() {
return _type.GraphQLScalarType
}
})
Object.defineProperty(exports, 'GraphQLObjectType', {
enumerable: true,
get: function get() {
return _type.GraphQLObjectType
}
})
Object.defineProperty(exports, 'GraphQLInterfaceType', {
enumerable: true,
get: function get() {
return _type.GraphQLInterfaceType
}
})
Object.defineProperty(exports, 'GraphQLUnionType', {
enumerable: true,
get: function get() {
return _type.GraphQLUnionType
}
})
Object.defineProperty(exports, 'GraphQLEnumType', {
enumerable: true,
get: function get() {
return _type.GraphQLEnumType
}
})
Object.defineProperty(exports, 'GraphQLInputObjectType', {
enumerable: true,
get: function get() {
return _type.GraphQLInputObjectType
}
})
Object.defineProperty(exports, 'GraphQLList', {
enumerable: true,
get: function get() {
return _type.GraphQLList
}
})
Object.defineProperty(exports, 'GraphQLNonNull', {
enumerable: true,
get: function get() {
return _type.GraphQLNonNull
}
})
Object.defineProperty(exports, 'GraphQLDirective', {
enumerable: true,
get: function get() {
return _type.GraphQLDirective
}
})
Object.defineProperty(exports, 'TypeKind', {
enumerable: true,
get: function get() {
return _type.TypeKind
}
})
Object.defineProperty(exports, 'DirectiveLocation', {
enumerable: true,
get: function get() {
return _type.DirectiveLocation
}
})
Object.defineProperty(exports, 'GraphQLInt', {
enumerable: true,
get: function get() {
return _type.GraphQLInt
}
})
Object.defineProperty(exports, 'GraphQLFloat', {
enumerable: true,
get: function get() {
return _type.GraphQLFloat
}
})
Object.defineProperty(exports, 'GraphQLString', {
enumerable: true,
get: function get() {
return _type.GraphQLString
}
})
Object.defineProperty(exports, 'GraphQLBoolean', {
enumerable: true,
get: function get() {
return _type.GraphQLBoolean
}
})
Object.defineProperty(exports, 'GraphQLID', {
enumerable: true,
get: function get() {
return _type.GraphQLID
}
})
Object.defineProperty(exports, 'specifiedDirectives', {
enumerable: true,
get: function get() {
return _type.specifiedDirectives
}
})
Object.defineProperty(exports, 'GraphQLIncludeDirective', {
enumerable: true,
get: function get() {
return _type.GraphQLIncludeDirective
}
})
Object.defineProperty(exports, 'GraphQLSkipDirective', {
enumerable: true,
get: function get() {
return _type.GraphQLSkipDirective
}
})
Object.defineProperty(exports, 'GraphQLDeprecatedDirective', {
enumerable: true,
get: function get() {
return _type.GraphQLDeprecatedDirective
}
})
Object.defineProperty(exports, 'DEFAULT_DEPRECATION_REASON', {
enumerable: true,
get: function get() {
return _type.DEFAULT_DEPRECATION_REASON
}
})
Object.defineProperty(exports, 'SchemaMetaFieldDef', {
enumerable: true,
get: function get() {
return _type.SchemaMetaFieldDef
}
})
Object.defineProperty(exports, 'TypeMetaFieldDef', {
enumerable: true,
get: function get() {
return _type.TypeMetaFieldDef
}
})
Object.defineProperty(exports, 'TypeNameMetaFieldDef', {
enumerable: true,
get: function get() {
return _type.TypeNameMetaFieldDef
}
})
Object.defineProperty(exports, '__Schema', {
enumerable: true,
get: function get() {
return _type.__Schema
}
})
Object.defineProperty(exports, '__Directive', {
enumerable: true,
get: function get() {
return _type.__Directive
}
})
Object.defineProperty(exports, '__DirectiveLocation', {
enumerable: true,
get: function get() {
return _type.__DirectiveLocation
}
})
Object.defineProperty(exports, '__Type', {
enumerable: true,
get: function get() {
return _type.__Type
}
})
Object.defineProperty(exports, '__Field', {
enumerable: true,
get: function get() {
return _type.__Field
}
})
Object.defineProperty(exports, '__InputValue', {
enumerable: true,
get: function get() {
return _type.__InputValue
}
})
Object.defineProperty(exports, '__EnumValue', {
enumerable: true,
get: function get() {
return _type.__EnumValue
}
})
Object.defineProperty(exports, '__TypeKind', {
enumerable: true,
get: function get() {
return _type.__TypeKind
}
})
Object.defineProperty(exports, 'isType', {
enumerable: true,
get: function get() {
return _type.isType
}
})
Object.defineProperty(exports, 'isInputType', {
enumerable: true,
get: function get() {
return _type.isInputType
}
})
Object.defineProperty(exports, 'isOutputType', {
enumerable: true,
get: function get() {
return _type.isOutputType
}
})
Object.defineProperty(exports, 'isLeafType', {
enumerable: true,
get: function get() {
return _type.isLeafType
}
})
Object.defineProperty(exports, 'isCompositeType', {
enumerable: true,
get: function get() {
return _type.isCompositeType
}
})
Object.defineProperty(exports, 'isAbstractType', {
enumerable: true,
get: function get() {
return _type.isAbstractType
}
})
Object.defineProperty(exports, 'isNamedType', {
enumerable: true,
get: function get() {
return _type.isNamedType
}
})
Object.defineProperty(exports, 'assertType', {
enumerable: true,
get: function get() {
return _type.assertType
}
})
Object.defineProperty(exports, 'assertInputType', {
enumerable: true,
get: function get() {
return _type.assertInputType
}
})
Object.defineProperty(exports, 'assertOutputType', {
enumerable: true,
get: function get() {
return _type.assertOutputType
}
})
Object.defineProperty(exports, 'assertLeafType', {
enumerable: true,
get: function get() {
return _type.assertLeafType
}
})
Object.defineProperty(exports, 'assertCompositeType', {
enumerable: true,
get: function get() {
return _type.assertCompositeType
}
})
Object.defineProperty(exports, 'assertAbstractType', {
enumerable: true,
get: function get() {
return _type.assertAbstractType
}
})
Object.defineProperty(exports, 'assertNamedType', {
enumerable: true,
get: function get() {
return _type.assertNamedType
}
})
Object.defineProperty(exports, 'getNullableType', {
enumerable: true,
get: function get() {
return _type.getNullableType
}
})
Object.defineProperty(exports, 'getNamedType', {
enumerable: true,
get: function get() {
return _type.getNamedType
}
})
var _language = __webpack_require__(43)
Object.defineProperty(exports, 'Source', {
enumerable: true,
get: function get() {
return _language.Source
}
})
Object.defineProperty(exports, 'getLocation', {
enumerable: true,
get: function get() {
return _language.getLocation
}
})
Object.defineProperty(exports, 'parse', {
enumerable: true,
get: function get() {
return _language.parse
}
})
Object.defineProperty(exports, 'parseValue', {
enumerable: true,
get: function get() {
return _language.parseValue
}
})
Object.defineProperty(exports, 'parseType', {
enumerable: true,
get: function get() {
return _language.parseType
}
})
Object.defineProperty(exports, 'print', {
enumerable: true,
get: function get() {
return _language.print
}
})
Object.defineProperty(exports, 'visit', {
enumerable: true,
get: function get() {
return _language.visit
}
})
Object.defineProperty(exports, 'visitInParallel', {
enumerable: true,
get: function get() {
return _language.visitInParallel
}
})
Object.defineProperty(exports, 'visitWithTypeInfo', {
enumerable: true,
get: function get() {
return _language.visitWithTypeInfo
}
})
Object.defineProperty(exports, 'Kind', {
enumerable: true,
get: function get() {
return _language.Kind
}
})
Object.defineProperty(exports, 'TokenKind', {
enumerable: true,
get: function get() {
return _language.TokenKind
}
})
Object.defineProperty(exports, 'BREAK', {
enumerable: true,
get: function get() {
return _language.BREAK
}
})
var _execution = __webpack_require__(41)
Object.defineProperty(exports, 'execute', {
enumerable: true,
get: function get() {
return _execution.execute
}
})
Object.defineProperty(exports, 'defaultFieldResolver', {
enumerable: true,
get: function get() {
return _execution.defaultFieldResolver
}
})
Object.defineProperty(exports, 'responsePathAsArray', {
enumerable: true,
get: function get() {
return _execution.responsePathAsArray
}
})
var _validation = __webpack_require__(55)
Object.defineProperty(exports, 'validate', {
enumerable: true,
get: function get() {
return _validation.validate
}
})
Object.defineProperty(exports, 'ValidationContext', {
enumerable: true,
get: function get() {
return _validation.ValidationContext
}
})
Object.defineProperty(exports, 'specifiedRules', {
enumerable: true,
get: function get() {
return _validation.specifiedRules
}
})
var _error = __webpack_require__(0)
Object.defineProperty(exports, 'GraphQLError', {
enumerable: true,
get: function get() {
return _error.GraphQLError
}
})
Object.defineProperty(exports, 'formatError', {
enumerable: true,
get: function get() {
return _error.formatError
}
})
var _utilities = __webpack_require__(51)
Object.defineProperty(exports, 'introspectionQuery', {
enumerable: true,
get: function get() {
return _utilities.introspectionQuery
}
})
Object.defineProperty(exports, 'getOperationAST', {
enumerable: true,
get: function get() {
return _utilities.getOperationAST
}
})
Object.defineProperty(exports, 'buildClientSchema', {
enumerable: true,
get: function get() {
return _utilities.buildClientSchema
}
})
Object.defineProperty(exports, 'buildASTSchema', {
enumerable: true,
get: function get() {
return _utilities.buildASTSchema
}
})
Object.defineProperty(exports, 'buildSchema', {
enumerable: true,
get: function get() {
return _utilities.buildSchema
}
})
Object.defineProperty(exports, 'extendSchema', {
enumerable: true,
get: function get() {
return _utilities.extendSchema
}
})
Object.defineProperty(exports, 'printSchema', {
enumerable: true,
get: function get() {
return _utilities.printSchema
}
})
Object.defineProperty(exports, 'printType', {
enumerable: true,
get: function get() {
return _utilities.printType
}
})
Object.defineProperty(exports, 'typeFromAST', {
enumerable: true,
get: function get() {
return _utilities.typeFromAST
}
})
Object.defineProperty(exports, 'valueFromAST', {
enumerable: true,
get: function get() {
return _utilities.valueFromAST
}
})
Object.defineProperty(exports, 'astFromValue', {
enumerable: true,
get: function get() {
return _utilities.astFromValue
}
})
Object.defineProperty(exports, 'TypeInfo', {
enumerable: true,
get: function get() {
return _utilities.TypeInfo
}
})
Object.defineProperty(exports, 'isValidJSValue', {
enumerable: true,
get: function get() {
return _utilities.isValidJSValue
}
})
Object.defineProperty(exports, 'isValidLiteralValue', {
enumerable: true,
get: function get() {
return _utilities.isValidLiteralValue
}
})
Object.defineProperty(exports, 'concatAST', {
enumerable: true,
get: function get() {
return _utilities.concatAST
}
})
Object.defineProperty(exports, 'separateOperations', {
enumerable: true,
get: function get() {
return _utilities.separateOperations
}
})
Object.defineProperty(exports, 'isEqualType', {
enumerable: true,
get: function get() {
return _utilities.isEqualType
}
})
Object.defineProperty(exports, 'isTypeSubTypeOf', {
enumerable: true,
get: function get() {
return _utilities.isTypeSubTypeOf
}
})
Object.defineProperty(exports, 'doTypesOverlap', {
enumerable: true,
get: function get() {
return _utilities.doTypesOverlap
}
})
Object.defineProperty(exports, 'assertValidName', {
enumerable: true,
get: function get() {
return _utilities.assertValidName
}
})
Object.defineProperty(exports, 'findBreakingChanges', {
enumerable: true,
get: function get() {
return _utilities.findBreakingChanges
}
})
Object.defineProperty(exports, 'findDeprecatedUsages', {
enumerable: true,
get: function get() {
return _utilities.findDeprecatedUsages
}
})
/***/
}),
/* 37 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", { value: true })
var graphql_1 = __webpack_require__(36)
var hasSubscriptionOperation = function(graphQlParams) {
var queryDoc = graphql_1.parse(graphQlParams.query)
for (var _i = 0, _a = queryDoc.definitions; _i < _a.length; _i++) {
var definition = _a[_i]
if (definition.kind === 'OperationDefinition') {
var operation = definition.operation
if (operation === 'subscription') {
return true
}
}
}
return false
}
exports.graphQLFetcher = function(subscriptionsClient, fallbackFetcher) {
var activeSubscriptionId = null
return function(graphQLParams) {
if (subscriptionsClient && activeSubscriptionId !== null) {
subscriptionsClient.unsubscribe(activeSubscriptionId)
}
if (subscriptionsClient && hasSubscriptionOperation(graphQLParams)) {
return {
subscribe: function(observer) {
observer.next('Your subscription data will appear here after server publication!')
activeSubscriptionId = subscriptionsClient.subscribe({
query: graphQLParams.query,
variables: graphQLParams.variables,
}, function(error, result) {
if (error) {
observer.error(error)
} else {
observer.next(result)
}
})
},
}
} else {
return fallbackFetcher(graphQLParams)
}
}
}
//# sourceMappingURL=fetcher.js.map
/***/
}),
/* 38 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.formatError = formatError
var _invariant = __webpack_require__(3)
var _invariant2 = _interopRequireDefault(_invariant)
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
/**
* Given a GraphQLError, format it according to the rules described by the
* Response Format, Errors section of the GraphQL Specification.
*/
function formatError(error) {
(0, _invariant2.default)(error, 'Received null or undefined error.')
return {
message: error.message,
locations: error.locations,
path: error.path
}
}
/**
* Copyright (c) 2015, 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.
*/
/***/
}),
/* 39 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.locatedError = locatedError
var _GraphQLError = __webpack_require__(13)
/**
* Given an arbitrary Error, presumably thrown while attempting to execute a
* GraphQL operation, produce a new GraphQLError aware of the location in the
* document responsible for the original Error.
*/
function locatedError(originalError, nodes, path) {
// Note: this uses a brand-check to support GraphQL errors originating from
// other contexts.
if (originalError && originalError.path) {
return originalError
}
var message = originalError ? originalError.message || String(originalError) : 'An unknown error occurred.'
return new _GraphQLError.GraphQLError(message, originalError && originalError.nodes || nodes,
originalError && originalError.source, originalError && originalError.positions, path, originalError)
}
/**
* Copyright (c) 2015, 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.
*/
/***/
}),
/* 40 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.syntaxError = syntaxError
var _location = __webpack_require__(25)
var _GraphQLError = __webpack_require__(13)
/**
* Produces a GraphQLError representing a syntax error, containing useful
* descriptive information about the syntax error's position in the source.
*/
/**
* Copyright (c) 2015, 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.
*/
function syntaxError(source, position, description) {
var location = (0, _location.getLocation)(source, position)
var error = new _GraphQLError.GraphQLError(
'Syntax Error ' + source.name + ' (' + location.line + ':' + location.column + ') ' + description + '\n\n'
+ highlightSourceAtLocation(source, location), undefined, source, [position])
return error
}
/**
* Render a helpful description of the location of the error in the GraphQL
* Source document.
*/
function highlightSourceAtLocation(source, location) {
var line = location.line
var prevLineNum = (line - 1).toString()
var lineNum = line.toString()
var nextLineNum = (line + 1).toString()
var padLen = nextLineNum.length
var lines = source.body.split(/\r\n|[\n\r]/g)
return (line >= 2 ? lpad(padLen, prevLineNum) + ': ' + lines[line - 2] + '\n' : '') + lpad(padLen, lineNum)
+ ': ' + lines[line - 1] + '\n' + Array(2 + padLen + location.column).join(' ') + '^\n' + (line
< lines.length ? lpad(padLen, nextLineNum) + ': ' + lines[line] + '\n' : '')
}
function lpad(len, str) {
return Array(len - str.length + 1).join(' ') + str
}
/***/
}),
/* 41 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
var _execute = __webpack_require__(30)
Object.defineProperty(exports, 'execute', {
enumerable: true,
get: function get() {
return _execute.execute
}
})
Object.defineProperty(exports, 'defaultFieldResolver', {
enumerable: true,
get: function get() {
return _execute.defaultFieldResolver
}
})
Object.defineProperty(exports, 'responsePathAsArray', {
enumerable: true,
get: function get() {
return _execute.responsePathAsArray
}
})
/***/
}),
/* 42 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.graphql = graphql
var _source = __webpack_require__(26)
var _parser = __webpack_require__(17)
var _validate = __webpack_require__(35)
var _execute = __webpack_require__(30)
/**
* This is the primary entry point function for fulfilling GraphQL operations
* by parsing, validating, and executing a GraphQL document along side a
* GraphQL schema.
*
* More sophisticated GraphQL servers, such as those which persist queries,
* may wish to separate the validation and execution phases to a static time
* tooling step, and a server runtime step.
*
* schema:
* The GraphQL type system to use when validating and executing a query.
* requestString:
* A GraphQL language formatted string representing the requested operation.
* rootValue:
* The value provided as the first argument to resolver functions on the top
* level type (e.g. the query object type).
* variableValues:
* A mapping of variable name to runtime value to use for all variables
* defined in the requestString.
* operationName:
* The name of the operation to use if requestString contains multiple
* possible operations. Can be omitted if requestString contains only
* one operation.
*/
/**
* Copyright (c) 2015, 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.
*/
function graphql(schema, requestString, rootValue, contextValue, variableValues, operationName) {
return new Promise(function(resolve) {
var source = new _source.Source(requestString || '', 'GraphQL request')
var documentAST = (0, _parser.parse)(source)
var validationErrors = (0, _validate.validate)(schema, documentAST)
if (validationErrors.length > 0) {
resolve({ errors: validationErrors })
} else {
resolve(
(0, _execute.execute)(schema, documentAST, rootValue, contextValue, variableValues, operationName))
}
}).then(undefined, function(error) {
return { errors: [error] }
})
}
/***/
}),
/* 43 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.BREAK = exports.visitWithTypeInfo = exports.visitInParallel = exports.visit = exports.Source = exports.print = exports.parseType = exports.parseValue = exports.parse = exports.TokenKind = exports.createLexer = exports.Kind = exports.getLocation = undefined
var _location = __webpack_require__(25)
Object.defineProperty(exports, 'getLocation', {
enumerable: true,
get: function get() {
return _location.getLocation
}
})
var _lexer = __webpack_require__(24)
Object.defineProperty(exports, 'createLexer', {
enumerable: true,
get: function get() {
return _lexer.createLexer
}
})
Object.defineProperty(exports, 'TokenKind', {
enumerable: true,
get: function get() {
return _lexer.TokenKind
}
})
var _parser = __webpack_require__(17)
Object.defineProperty(exports, 'parse', {
enumerable: true,
get: function get() {
return _parser.parse
}
})
Object.defineProperty(exports, 'parseValue', {
enumerable: true,
get: function get() {
return _parser.parseValue
}
})
Object.defineProperty(exports, 'parseType', {
enumerable: true,
get: function get() {
return _parser.parseType
}
})
var _printer = __webpack_require__(4)
Object.defineProperty(exports, 'print', {
enumerable: true,
get: function get() {
return _printer.print
}
})
var _source = __webpack_require__(26)
Object.defineProperty(exports, 'Source', {
enumerable: true,
get: function get() {
return _source.Source
}
})
var _visitor = __webpack_require__(15)
Object.defineProperty(exports, 'visit', {
enumerable: true,
get: function get() {
return _visitor.visit
}
})
Object.defineProperty(exports, 'visitInParallel', {
enumerable: true,
get: function get() {
return _visitor.visitInParallel
}
})
Object.defineProperty(exports, 'visitWithTypeInfo', {
enumerable: true,
get: function get() {
return _visitor.visitWithTypeInfo
}
})
Object.defineProperty(exports, 'BREAK', {
enumerable: true,
get: function get() {
return _visitor.BREAK
}
})
var _kinds = __webpack_require__(2)
var Kind = _interopRequireWildcard(_kinds)
function _interopRequireWildcard(obj) {
if (obj && obj.__esModule) {
return obj
} else {
var newObj = {}
if (obj != null) {
for (var key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) {
newObj[key] = obj[key]
}
}
}
newObj.default = obj
return newObj
}
}
exports.Kind = Kind
/***/
}),
/* 44 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
var _schema = __webpack_require__(8)
Object.defineProperty(exports, 'GraphQLSchema', {
enumerable: true,
get: function get() {
return _schema.GraphQLSchema
}
})
var _definition = __webpack_require__(1)
Object.defineProperty(exports, 'isType', {
enumerable: true,
get: function get() {
return _definition.isType
}
})
Object.defineProperty(exports, 'isInputType', {
enumerable: true,
get: function get() {
return _definition.isInputType
}
})
Object.defineProperty(exports, 'isOutputType', {
enumerable: true,
get: function get() {
return _definition.isOutputType
}
})
Object.defineProperty(exports, 'isLeafType', {
enumerable: true,
get: function get() {
return _definition.isLeafType
}
})
Object.defineProperty(exports, 'isCompositeType', {
enumerable: true,
get: function get() {
return _definition.isCompositeType
}
})
Object.defineProperty(exports, 'isAbstractType', {
enumerable: true,
get: function get() {
return _definition.isAbstractType
}
})
Object.defineProperty(exports, 'isNamedType', {
enumerable: true,
get: function get() {
return _definition.isNamedType
}
})
Object.defineProperty(exports, 'assertType', {
enumerable: true,
get: function get() {
return _definition.assertType
}
})
Object.defineProperty(exports, 'assertInputType', {
enumerable: true,
get: function get() {
return _definition.assertInputType
}
})
Object.defineProperty(exports, 'assertOutputType', {
enumerable: true,
get: function get() {
return _definition.assertOutputType
}
})
Object.defineProperty(exports, 'assertLeafType', {
enumerable: true,
get: function get() {
return _definition.assertLeafType
}
})
Object.defineProperty(exports, 'assertCompositeType', {
enumerable: true,
get: function get() {
return _definition.assertCompositeType
}
})
Object.defineProperty(exports, 'assertAbstractType', {
enumerable: true,
get: function get() {
return _definition.assertAbstractType
}
})
Object.defineProperty(exports, 'assertNamedType', {
enumerable: true,
get: function get() {
return _definition.assertNamedType
}
})
Object.defineProperty(exports, 'getNullableType', {
enumerable: true,
get: function get() {
return _definition.getNullableType
}
})
Object.defineProperty(exports, 'getNamedType', {
enumerable: true,
get: function get() {
return _definition.getNamedType
}
})
Object.defineProperty(exports, 'GraphQLScalarType', {
enumerable: true,
get: function get() {
return _definition.GraphQLScalarType
}
})
Object.defineProperty(exports, 'GraphQLObjectType', {
enumerable: true,
get: function get() {
return _definition.GraphQLObjectType
}
})
Object.defineProperty(exports, 'GraphQLInterfaceType', {
enumerable: true,
get: function get() {
return _definition.GraphQLInterfaceType
}
})
Object.defineProperty(exports, 'GraphQLUnionType', {
enumerable: true,
get: function get() {
return _definition.GraphQLUnionType
}
})
Object.defineProperty(exports, 'GraphQLEnumType', {
enumerable: true,
get: function get() {
return _definition.GraphQLEnumType
}
})
Object.defineProperty(exports, 'GraphQLInputObjectType', {
enumerable: true,
get: function get() {
return _definition.GraphQLInputObjectType
}
})
Object.defineProperty(exports, 'GraphQLList', {
enumerable: true,
get: function get() {
return _definition.GraphQLList
}
})
Object.defineProperty(exports, 'GraphQLNonNull', {
enumerable: true,
get: function get() {
return _definition.GraphQLNonNull
}
})
var _directives = __webpack_require__(5)
Object.defineProperty(exports, 'DirectiveLocation', {
enumerable: true,
get: function get() {
return _directives.DirectiveLocation
}
})
Object.defineProperty(exports, 'GraphQLDirective', {
enumerable: true,
get: function get() {
return _directives.GraphQLDirective
}
})
Object.defineProperty(exports, 'specifiedDirectives', {
enumerable: true,
get: function get() {
return _directives.specifiedDirectives
}
})
Object.defineProperty(exports, 'GraphQLIncludeDirective', {
enumerable: true,
get: function get() {
return _directives.GraphQLIncludeDirective
}
})
Object.defineProperty(exports, 'GraphQLSkipDirective', {
enumerable: true,
get: function get() {
return _directives.GraphQLSkipDirective
}
})
Object.defineProperty(exports, 'GraphQLDeprecatedDirective', {
enumerable: true,
get: function get() {
return _directives.GraphQLDeprecatedDirective
}
})
Object.defineProperty(exports, 'DEFAULT_DEPRECATION_REASON', {
enumerable: true,
get: function get() {
return _directives.DEFAULT_DEPRECATION_REASON
}
})
var _scalars = __webpack_require__(7)
Object.defineProperty(exports, 'GraphQLInt', {
enumerable: true,
get: function get() {
return _scalars.GraphQLInt
}
})
Object.defineProperty(exports, 'GraphQLFloat', {
enumerable: true,
get: function get() {
return _scalars.GraphQLFloat
}
})
Object.defineProperty(exports, 'GraphQLString', {
enumerable: true,
get: function get() {
return _scalars.GraphQLString
}
})
Object.defineProperty(exports, 'GraphQLBoolean', {
enumerable: true,
get: function get() {
return _scalars.GraphQLBoolean
}
})
Object.defineProperty(exports, 'GraphQLID', {
enumerable: true,
get: function get() {
return _scalars.GraphQLID
}
})
var _introspection = __webpack_require__(11)
Object.defineProperty(exports, 'TypeKind', {
enumerable: true,
get: function get() {
return _introspection.TypeKind
}
})
Object.defineProperty(exports, '__Schema', {
enumerable: true,
get: function get() {
return _introspection.__Schema
}
})
Object.defineProperty(exports, '__Directive', {
enumerable: true,
get: function get() {
return _introspection.__Directive
}
})
Object.defineProperty(exports, '__DirectiveLocation', {
enumerable: true,
get: function get() {
return _introspection.__DirectiveLocation
}
})
Object.defineProperty(exports, '__Type', {
enumerable: true,
get: function get() {
return _introspection.__Type
}
})
Object.defineProperty(exports, '__Field', {
enumerable: true,
get: function get() {
return _introspection.__Field
}
})
Object.defineProperty(exports, '__InputValue', {
enumerable: true,
get: function get() {
return _introspection.__InputValue
}
})
Object.defineProperty(exports, '__EnumValue', {
enumerable: true,
get: function get() {
return _introspection.__EnumValue
}
})
Object.defineProperty(exports, '__TypeKind', {
enumerable: true,
get: function get() {
return _introspection.__TypeKind
}
})
Object.defineProperty(exports, 'SchemaMetaFieldDef', {
enumerable: true,
get: function get() {
return _introspection.SchemaMetaFieldDef
}
})
Object.defineProperty(exports, 'TypeMetaFieldDef', {
enumerable: true,
get: function get() {
return _introspection.TypeMetaFieldDef
}
})
Object.defineProperty(exports, 'TypeNameMetaFieldDef', {
enumerable: true,
get: function get() {
return _introspection.TypeNameMetaFieldDef
}
})
/***/
}),
/* 45 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.buildClientSchema = buildClientSchema
var _invariant = __webpack_require__(3)
var _invariant2 = _interopRequireDefault(_invariant)
var _keyMap = __webpack_require__(12)
var _keyMap2 = _interopRequireDefault(_keyMap)
var _keyValMap = __webpack_require__(21)
var _keyValMap2 = _interopRequireDefault(_keyValMap)
var _valueFromAST = __webpack_require__(16)
var _parser = __webpack_require__(17)
var _schema = __webpack_require__(8)
var _definition = __webpack_require__(1)
var _introspection = __webpack_require__(11)
var _scalars = __webpack_require__(7)
var _directives = __webpack_require__(5)
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
/**
* Build a GraphQLSchema for use by client tools.
*
* Given the result of a client running the introspection query, creates and
* returns a GraphQLSchema instance which can be then used with all graphql-js
* tools, but cannot be used to execute a query, as introspection does not
* represent the "resolver", "parse" or "serialize" functions or any other
* server-internal mechanisms.
*/
function buildClientSchema(introspection) {
// Get the schema from the introspection result.
var schemaIntrospection = introspection.__schema
// Converts the list of types into a keyMap based on the type names.
var typeIntrospectionMap = (0, _keyMap2.default)(schemaIntrospection.types, function(type) {
return type.name
})
// A cache to use to store the actual GraphQLType definition objects by name.
// Initialize to the GraphQL built in scalars. All functions below are inline
// so that this type def cache is within the scope of the closure.
var typeDefCache = {
String: _scalars.GraphQLString,
Int: _scalars.GraphQLInt,
Float: _scalars.GraphQLFloat,
Boolean: _scalars.GraphQLBoolean,
ID: _scalars.GraphQLID,
__Schema: _introspection.__Schema,
__Directive: _introspection.__Directive,
__DirectiveLocation: _introspection.__DirectiveLocation,
__Type: _introspection.__Type,
__Field: _introspection.__Field,
__InputValue: _introspection.__InputValue,
__EnumValue: _introspection.__EnumValue,
__TypeKind: _introspection.__TypeKind
}
// Given a type reference in introspection, return the GraphQLType instance.
// preferring cached instances before building new instances.
function getType(typeRef) {
if (typeRef.kind === _introspection.TypeKind.LIST) {
var itemRef = typeRef.ofType
if (!itemRef) {
throw new Error('Decorated type deeper than introspection query.')
}
return new _definition.GraphQLList(getType(itemRef))
}
if (typeRef.kind === _introspection.TypeKind.NON_NULL) {
var nullableRef = typeRef.ofType
if (!nullableRef) {
throw new Error('Decorated type deeper than introspection query.')
}
var nullableType = getType(nullableRef);
(0, _invariant2.default)(!(nullableType instanceof _definition.GraphQLNonNull), 'No nesting nonnull.')
return new _definition.GraphQLNonNull(nullableType)
}
return getNamedType(typeRef.name)
}
function getNamedType(typeName) {
if (typeDefCache[typeName]) {
return typeDefCache[typeName]
}
var typeIntrospection = typeIntrospectionMap[typeName]
if (!typeIntrospection) {
throw new Error('Invalid or incomplete schema, unknown type: ' + typeName + '. Ensure '
+ 'that a full introspection query is used in order to build a ' + 'client schema.')
}
var typeDef = buildType(typeIntrospection)
typeDefCache[typeName] = typeDef
return typeDef
}
function getInputType(typeRef) {
var type = getType(typeRef);
(0, _invariant2.default)((0, _definition.isInputType)(type),
'Introspection must provide input type for arguments.')
return type
}
function getOutputType(typeRef) {
var type = getType(typeRef);
(0, _invariant2.default)((0, _definition.isOutputType)(type),
'Introspection must provide output type for fields.')
return type
}
function getObjectType(typeRef) {
var type = getType(typeRef);
(0, _invariant2.default)(type instanceof _definition.GraphQLObjectType,
'Introspection must provide object type for possibleTypes.')
return type
}
function getInterfaceType(typeRef) {
var type = getType(typeRef);
(0, _invariant2.default)(type instanceof _definition.GraphQLInterfaceType,
'Introspection must provide interface type for interfaces.')
return type
}
// Given a type's introspection result, construct the correct
// GraphQLType instance.
function buildType(type) {
switch (type.kind) {
case _introspection.TypeKind.SCALAR:
return buildScalarDef(type)
case _introspection.TypeKind.OBJECT:
return buildObjectDef(type)
case _introspection.TypeKind.INTERFACE:
return buildInterfaceDef(type)
case _introspection.TypeKind.UNION:
return buildUnionDef(type)
case _introspection.TypeKind.ENUM:
return buildEnumDef(type)
case _introspection.TypeKind.INPUT_OBJECT:
return buildInputObjectDef(type)
default:
throw new Error('Invalid or incomplete schema, unknown kind: ' + type.kind + '. Ensure '
+ 'that a full introspection query is used in order to build a ' + 'client schema.')
}
}
function buildScalarDef(scalarIntrospection) {
return new _definition.GraphQLScalarType({
name: scalarIntrospection.name,
description: scalarIntrospection.description,
serialize: function serialize(id) {
return id
},
// Note: validation calls the parse functions to determine if a
// literal value is correct. Returning null would cause use of custom
// scalars to always fail validation. Returning false causes them to
// always pass validation.
parseValue: function parseValue() {
return false
},
parseLiteral: function parseLiteral() {
return false
}
})
}
function buildObjectDef(objectIntrospection) {
return new _definition.GraphQLObjectType({
name: objectIntrospection.name,
description: objectIntrospection.description,
interfaces: objectIntrospection.interfaces.map(getInterfaceType),
fields: function fields() {
return buildFieldDefMap(objectIntrospection)
}
})
}
function buildInterfaceDef(interfaceIntrospection) {
return new _definition.GraphQLInterfaceType({
name: interfaceIntrospection.name,
description: interfaceIntrospection.description,
fields: function fields() {
return buildFieldDefMap(interfaceIntrospection)
},
resolveType: cannotExecuteClientSchema
})
}
function buildUnionDef(unionIntrospection) {
return new _definition.GraphQLUnionType({
name: unionIntrospection.name,
description: unionIntrospection.description,
types: unionIntrospection.possibleTypes.map(getObjectType),
resolveType: cannotExecuteClientSchema
})
}
function buildEnumDef(enumIntrospection) {
return new _definition.GraphQLEnumType({
name: enumIntrospection.name,
description: enumIntrospection.description,
values: (0, _keyValMap2.default)(enumIntrospection.enumValues, function(valueIntrospection) {
return valueIntrospection.name
}, function(valueIntrospection) {
return {
description: valueIntrospection.description,
deprecationReason: valueIntrospection.deprecationReason
}
})
})
}
function buildInputObjectDef(inputObjectIntrospection) {
return new _definition.GraphQLInputObjectType({
name: inputObjectIntrospection.name,
description: inputObjectIntrospection.description,
fields: function fields() {
return buildInputValueDefMap(inputObjectIntrospection.inputFields)
}
})
}
function buildFieldDefMap(typeIntrospection) {
return (0, _keyValMap2.default)(typeIntrospection.fields, function(fieldIntrospection) {
return fieldIntrospection.name
}, function(fieldIntrospection) {
return {
description: fieldIntrospection.description,
deprecationReason: fieldIntrospection.deprecationReason,
type: getOutputType(fieldIntrospection.type),
args: buildInputValueDefMap(fieldIntrospection.args)
}
})
}
function buildInputValueDefMap(inputValueIntrospections) {
return (0, _keyValMap2.default)(inputValueIntrospections, function(inputValue) {
return inputValue.name
}, buildInputValue)
}
function buildInputValue(inputValueIntrospection) {
var type = getInputType(inputValueIntrospection.type)
var defaultValue = inputValueIntrospection.defaultValue ? (0, _valueFromAST.valueFromAST)(
(0, _parser.parseValue)(inputValueIntrospection.defaultValue), type) : undefined
return {
name: inputValueIntrospection.name,
description: inputValueIntrospection.description,
type: type,
defaultValue: defaultValue
}
}
function buildDirective(directiveIntrospection) {
// Support deprecated `on****` fields for building `locations`, as this
// is used by GraphiQL which may need to support outdated servers.
var locations = directiveIntrospection.locations ? directiveIntrospection.locations.slice() : [].concat(
!directiveIntrospection.onField ? [] : [_directives.DirectiveLocation.FIELD],
!directiveIntrospection.onOperation ? [] : [_directives.DirectiveLocation.QUERY,
_directives.DirectiveLocation.MUTATION, _directives.DirectiveLocation.SUBSCRIPTION],
!directiveIntrospection.onFragment ? [] : [_directives.DirectiveLocation.FRAGMENT_DEFINITION,
_directives.DirectiveLocation.FRAGMENT_SPREAD, _directives.DirectiveLocation.INLINE_FRAGMENT])
return new _directives.GraphQLDirective({
name: directiveIntrospection.name,
description: directiveIntrospection.description,
locations: locations,
args: buildInputValueDefMap(directiveIntrospection.args)
})
}
// Iterate through all types, getting the type definition for each, ensuring
// that any type not directly referenced by a field will get created.
var types = schemaIntrospection.types.map(function(typeIntrospection) {
return getNamedType(typeIntrospection.name)
})
// Get the root Query, Mutation, and Subscription types.
var queryType = getObjectType(schemaIntrospection.queryType)
var mutationType = schemaIntrospection.mutationType ? getObjectType(schemaIntrospection.mutationType) : null
var subscriptionType = schemaIntrospection.subscriptionType ? getObjectType(
schemaIntrospection.subscriptionType) : null
// Get the directives supported by Introspection, assuming empty-set if
// directives were not queried for.
var directives = schemaIntrospection.directives ? schemaIntrospection.directives.map(buildDirective) : []
// Then produce and return a Schema with these types.
return new _schema.GraphQLSchema({
query: queryType,
mutation: mutationType,
subscription: subscriptionType,
types: types,
directives: directives
})
}
/**
* Copyright (c) 2015, 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.
*/
function cannotExecuteClientSchema() {
throw new Error('Client Schema cannot use Interface or Union types for execution.')
}
/***/
}),
/* 46 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.concatAST = concatAST
/**
* Provided a collection of ASTs, presumably each from different files,
* concatenate the ASTs together into batched AST, useful for validating many
* GraphQL source files which together represent one conceptual application.
*/
function concatAST(asts) {
var batchDefinitions = []
for (var i = 0; i < asts.length; i++) {
var definitions = asts[i].definitions
for (var j = 0; j < definitions.length; j++) {
batchDefinitions.push(definitions[j])
}
}
return {
kind: 'Document',
definitions: batchDefinitions
}
}
/**
* Copyright (c) 2015, 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.
*/
/***/
}),
/* 47 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.extendSchema = extendSchema
var _invariant = __webpack_require__(3)
var _invariant2 = _interopRequireDefault(_invariant)
var _keyMap = __webpack_require__(12)
var _keyMap2 = _interopRequireDefault(_keyMap)
var _keyValMap = __webpack_require__(21)
var _keyValMap2 = _interopRequireDefault(_keyValMap)
var _buildASTSchema = __webpack_require__(32)
var _valueFromAST = __webpack_require__(16)
var _GraphQLError = __webpack_require__(13)
var _schema = __webpack_require__(8)
var _definition = __webpack_require__(1)
var _directives = __webpack_require__(5)
var _introspection = __webpack_require__(11)
var _scalars = __webpack_require__(7)
var _kinds = __webpack_require__(2)
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
/**
* Produces a new schema given an existing schema and a document which may
* contain GraphQL type extensions and definitions. The original schema will
* remain unaltered.
*
* Because a schema represents a graph of references, a schema cannot be
* extended without effectively making an entire copy. We do not know until it's
* too late if subgraphs remain unchanged.
*
* This algorithm copies the provided schema, applying extensions while
* producing the copy. The original schema remains unaltered.
*/
/**
* Copyright (c) 2015, 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.
*/
function extendSchema(schema, documentAST) {
(0, _invariant2.default)(schema instanceof _schema.GraphQLSchema, 'Must provide valid GraphQLSchema');
(0, _invariant2.default)(documentAST && documentAST.kind === _kinds.DOCUMENT,
'Must provide valid Document AST')
// Collect the type definitions and extensions found in the document.
var typeDefinitionMap = {}
var typeExtensionsMap = {}
// New directives and types are separate because a directives and types can
// have the same name. For example, a type named "skip".
var directiveDefinitions = []
for (var i = 0; i < documentAST.definitions.length; i++) {
var def = documentAST.definitions[i]
switch (def.kind) {
case _kinds.OBJECT_TYPE_DEFINITION:
case _kinds.INTERFACE_TYPE_DEFINITION:
case _kinds.ENUM_TYPE_DEFINITION:
case _kinds.UNION_TYPE_DEFINITION:
case _kinds.SCALAR_TYPE_DEFINITION:
case _kinds.INPUT_OBJECT_TYPE_DEFINITION:
// Sanity check that none of the defined types conflict with the
// schema's existing types.
var typeName = def.name.value
if (schema.getType(typeName)) {
throw new _GraphQLError.GraphQLError(
'Type "' + typeName + '" already exists in the schema. It cannot also '
+ 'be defined in this type definition.', [def])
}
typeDefinitionMap[typeName] = def
break
case _kinds.TYPE_EXTENSION_DEFINITION:
// Sanity check that this type extension exists within the
// schema's existing types.
var extendedTypeName = def.definition.name.value
var existingType = schema.getType(extendedTypeName)
if (!existingType) {
throw new _GraphQLError.GraphQLError(
'Cannot extend type "' + extendedTypeName + '" because it does not '
+ 'exist in the existing schema.', [def.definition])
}
if (!(existingType instanceof _definition.GraphQLObjectType)) {
throw new _GraphQLError.GraphQLError('Cannot extend non-object type "' + extendedTypeName + '".',
[def.definition])
}
var extensions = typeExtensionsMap[extendedTypeName]
if (extensions) {
extensions.push(def)
} else {
extensions = [def]
}
typeExtensionsMap[extendedTypeName] = extensions
break
case _kinds.DIRECTIVE_DEFINITION:
var directiveName = def.name.value
var existingDirective = schema.getDirective(directiveName)
if (existingDirective) {
throw new _GraphQLError.GraphQLError(
'Directive "' + directiveName + '" already exists in the schema. It ' + 'cannot be redefined.',
[def])
}
directiveDefinitions.push(def)
break
}
}
// If this document contains no new types, extensions, or directives then
// return the same unmodified GraphQLSchema instance.
if (Object.keys(typeExtensionsMap).length === 0 && Object.keys(typeDefinitionMap).length === 0
&& directiveDefinitions.length === 0) {
return schema
}
// A cache to use to store the actual GraphQLType definition objects by name.
// Initialize to the GraphQL built in scalars and introspection types. All
// functions below are inline so that this type def cache is within the scope
// of the closure.
var typeDefCache = {
String: _scalars.GraphQLString,
Int: _scalars.GraphQLInt,
Float: _scalars.GraphQLFloat,
Boolean: _scalars.GraphQLBoolean,
ID: _scalars.GraphQLID,
__Schema: _introspection.__Schema,
__Directive: _introspection.__Directive,
__DirectiveLocation: _introspection.__DirectiveLocation,
__Type: _introspection.__Type,
__Field: _introspection.__Field,
__InputValue: _introspection.__InputValue,
__EnumValue: _introspection.__EnumValue,
__TypeKind: _introspection.__TypeKind
}
// Get the root Query, Mutation, and Subscription object types.
var queryType = getTypeFromDef(schema.getQueryType())
var existingMutationType = schema.getMutationType()
var mutationType = existingMutationType ? getTypeFromDef(existingMutationType) : null
var existingSubscriptionType = schema.getSubscriptionType()
var subscriptionType = existingSubscriptionType ? getTypeFromDef(existingSubscriptionType) : null
// Iterate through all types, getting the type definition for each, ensuring
// that any type not directly referenced by a field will get created.
var typeMap = schema.getTypeMap()
var types = Object.keys(typeMap).map(function(typeName) {
return getTypeFromDef(typeMap[typeName])
})
// Do the same with new types, appending to the list of defined types.
Object.keys(typeDefinitionMap).forEach(function(typeName) {
types.push(getTypeFromAST(typeDefinitionMap[typeName]))
})
// Then produce and return a Schema with these types.
return new _schema.GraphQLSchema({
query: queryType,
mutation: mutationType,
subscription: subscriptionType,
types: types,
directives: getMergedDirectives()
})
// Below are functions used for producing this schema that have closed over
// this scope and have access to the schema, cache, and newly defined types.
function getMergedDirectives() {
var existingDirectives = schema.getDirectives();
(0, _invariant2.default)(existingDirectives, 'schema must have default directives')
var newDirectives = directiveDefinitions.map(function(directiveNode) {
return getDirective(directiveNode)
})
return existingDirectives.concat(newDirectives)
}
function getTypeFromDef(typeDef) {
var type = _getNamedType(typeDef.name);
(0, _invariant2.default)(type, 'Missing type from schema')
return type
}
function getTypeFromAST(node) {
var type = _getNamedType(node.name.value)
if (!type) {
throw new _GraphQLError.GraphQLError(
'Unknown type: "' + node.name.value + '". Ensure that this type exists '
+ 'either in the original schema, or is added in a type definition.', [node])
}
return type
}
function getObjectTypeFromAST(node) {
var type = getTypeFromAST(node);
(0, _invariant2.default)(type instanceof _definition.GraphQLObjectType, 'Must be Object type.')
return type
}
function getInterfaceTypeFromAST(node) {
var type = getTypeFromAST(node);
(0, _invariant2.default)(type instanceof _definition.GraphQLInterfaceType, 'Must be Interface type.')
return type
}
function getInputTypeFromAST(node) {
var type = getTypeFromAST(node);
(0, _invariant2.default)((0, _definition.isInputType)(type), 'Must be Input type.')
return type
}
function getOutputTypeFromAST(node) {
var type = getTypeFromAST(node);
(0, _invariant2.default)((0, _definition.isOutputType)(type), 'Must be Output type.')
return type
}
// Given a name, returns a type from either the existing schema or an
// added type.
function _getNamedType(typeName) {
var cachedTypeDef = typeDefCache[typeName]
if (cachedTypeDef) {
return cachedTypeDef
}
var existingType = schema.getType(typeName)
if (existingType) {
var typeDef = extendType(existingType)
typeDefCache[typeName] = typeDef
return typeDef
}
var typeNode = typeDefinitionMap[typeName]
if (typeNode) {
var _typeDef = buildType(typeNode)
typeDefCache[typeName] = _typeDef
return _typeDef
}
}
// Given a type's introspection result, construct the correct
// GraphQLType instance.
function extendType(type) {
if (type instanceof _definition.GraphQLObjectType) {
return extendObjectType(type)
}
if (type instanceof _definition.GraphQLInterfaceType) {
return extendInterfaceType(type)
}
if (type instanceof _definition.GraphQLUnionType) {
return extendUnionType(type)
}
return type
}
function extendObjectType(type) {
return new _definition.GraphQLObjectType({
name: type.name,
description: type.description,
interfaces: function interfaces() {
return extendImplementedInterfaces(type)
},
fields: function fields() {
return extendFieldMap(type)
},
isTypeOf: type.isTypeOf
})
}
function extendInterfaceType(type) {
return new _definition.GraphQLInterfaceType({
name: type.name,
description: type.description,
fields: function fields() {
return extendFieldMap(type)
},
resolveType: type.resolveType
})
}
function extendUnionType(type) {
return new _definition.GraphQLUnionType({
name: type.name,
description: type.description,
types: type.getTypes().map(getTypeFromDef),
resolveType: type.resolveType
})
}
function extendImplementedInterfaces(type) {
var interfaces = type.getInterfaces().map(getTypeFromDef)
// If there are any extensions to the interfaces, apply those here.
var extensions = typeExtensionsMap[type.name]
if (extensions) {
extensions.forEach(function(extension) {
extension.definition.interfaces.forEach(function(namedType) {
var interfaceName = namedType.name.value
if (interfaces.some(function(def) {
return def.name === interfaceName
})) {
throw new _GraphQLError.GraphQLError(
'Type "' + type.name + '" already implements "' + interfaceName + '". '
+ 'It cannot also be implemented in this type extension.', [namedType])
}
interfaces.push(getInterfaceTypeFromAST(namedType))
})
})
}
return interfaces
}
function extendFieldMap(type) {
var newFieldMap = {}
var oldFieldMap = type.getFields()
Object.keys(oldFieldMap).forEach(function(fieldName) {
var field = oldFieldMap[fieldName]
newFieldMap[fieldName] = {
description: field.description,
deprecationReason: field.deprecationReason,
type: extendFieldType(field.type),
args: (0, _keyMap2.default)(field.args, function(arg) {
return arg.name
}),
resolve: field.resolve
}
})
// If there are any extensions to the fields, apply those here.
var extensions = typeExtensionsMap[type.name]
if (extensions) {
extensions.forEach(function(extension) {
extension.definition.fields.forEach(function(field) {
var fieldName = field.name.value
if (oldFieldMap[fieldName]) {
throw new _GraphQLError.GraphQLError(
'Field "' + type.name + '.' + fieldName + '" already exists in the '
+ 'schema. It cannot also be defined in this type extension.', [field])
}
newFieldMap[fieldName] = {
description: (0, _buildASTSchema.getDescription)(field),
type: buildOutputFieldType(field.type),
args: buildInputValues(field.arguments)
}
})
})
}
return newFieldMap
}
function extendFieldType(typeDef) {
if (typeDef instanceof _definition.GraphQLList) {
return new _definition.GraphQLList(extendFieldType(typeDef.ofType))
}
if (typeDef instanceof _definition.GraphQLNonNull) {
return new _definition.GraphQLNonNull(extendFieldType(typeDef.ofType))
}
return getTypeFromDef(typeDef)
}
function buildType(typeNode) {
switch (typeNode.kind) {
case _kinds.OBJECT_TYPE_DEFINITION:
return buildObjectType(typeNode)
case _kinds.INTERFACE_TYPE_DEFINITION:
return buildInterfaceType(typeNode)
case _kinds.UNION_TYPE_DEFINITION:
return buildUnionType(typeNode)
case _kinds.SCALAR_TYPE_DEFINITION:
return buildScalarType(typeNode)
case _kinds.ENUM_TYPE_DEFINITION:
return buildEnumType(typeNode)
case _kinds.INPUT_OBJECT_TYPE_DEFINITION:
return buildInputObjectType(typeNode)
}
throw new TypeError('Unknown type kind ' + typeNode.kind)
}
function buildObjectType(typeNode) {
return new _definition.GraphQLObjectType({
name: typeNode.name.value,
description: (0, _buildASTSchema.getDescription)(typeNode),
interfaces: function interfaces() {
return buildImplementedInterfaces(typeNode)
},
fields: function fields() {
return buildFieldMap(typeNode)
}
})
}
function buildInterfaceType(typeNode) {
return new _definition.GraphQLInterfaceType({
name: typeNode.name.value,
description: (0, _buildASTSchema.getDescription)(typeNode),
fields: function fields() {
return buildFieldMap(typeNode)
},
resolveType: cannotExecuteExtendedSchema
})
}
function buildUnionType(typeNode) {
return new _definition.GraphQLUnionType({
name: typeNode.name.value,
description: (0, _buildASTSchema.getDescription)(typeNode),
types: typeNode.types.map(getObjectTypeFromAST),
resolveType: cannotExecuteExtendedSchema
})
}
function buildScalarType(typeNode) {
return new _definition.GraphQLScalarType({
name: typeNode.name.value,
description: (0, _buildASTSchema.getDescription)(typeNode),
serialize: function serialize(id) {
return id
},
// Note: validation calls the parse functions to determine if a
// literal value is correct. Returning null would cause use of custom
// scalars to always fail validation. Returning false causes them to
// always pass validation.
parseValue: function parseValue() {
return false
},
parseLiteral: function parseLiteral() {
return false
}
})
}
function buildEnumType(typeNode) {
return new _definition.GraphQLEnumType({
name: typeNode.name.value,
description: (0, _buildASTSchema.getDescription)(typeNode),
values: (0, _keyValMap2.default)(typeNode.values, function(v) {
return v.name.value
}, function() {
return {}
})
})
}
function buildInputObjectType(typeNode) {
return new _definition.GraphQLInputObjectType({
name: typeNode.name.value,
description: (0, _buildASTSchema.getDescription)(typeNode),
fields: function fields() {
return buildInputValues(typeNode.fields)
}
})
}
function getDirective(directiveNode) {
return new _directives.GraphQLDirective({
name: directiveNode.name.value,
locations: directiveNode.locations.map(function(node) {
return node.value
}),
args: directiveNode.arguments && buildInputValues(directiveNode.arguments)
})
}
function buildImplementedInterfaces(typeNode) {
return typeNode.interfaces && typeNode.interfaces.map(getInterfaceTypeFromAST)
}
function buildFieldMap(typeNode) {
return (0, _keyValMap2.default)(typeNode.fields, function(field) {
return field.name.value
}, function(field) {
return {
type: buildOutputFieldType(field.type),
description: (0, _buildASTSchema.getDescription)(field),
args: buildInputValues(field.arguments)
}
})
}
function buildInputValues(values) {
return (0, _keyValMap2.default)(values, function(value) {
return value.name.value
}, function(value) {
var type = buildInputFieldType(value.type)
return {
type: type,
description: (0, _buildASTSchema.getDescription)(value),
defaultValue: (0, _valueFromAST.valueFromAST)(value.defaultValue, type)
}
})
}
function buildInputFieldType(typeNode) {
if (typeNode.kind === _kinds.LIST_TYPE) {
return new _definition.GraphQLList(buildInputFieldType(typeNode.type))
}
if (typeNode.kind === _kinds.NON_NULL_TYPE) {
var nullableType = buildInputFieldType(typeNode.type);
(0, _invariant2.default)(!(nullableType instanceof _definition.GraphQLNonNull), 'Must be nullable')
return new _definition.GraphQLNonNull(nullableType)
}
return getInputTypeFromAST(typeNode)
}
function buildOutputFieldType(typeNode) {
if (typeNode.kind === _kinds.LIST_TYPE) {
return new _definition.GraphQLList(buildOutputFieldType(typeNode.type))
}
if (typeNode.kind === _kinds.NON_NULL_TYPE) {
var nullableType = buildOutputFieldType(typeNode.type);
(0, _invariant2.default)(!(nullableType instanceof _definition.GraphQLNonNull), 'Must be nullable')
return new _definition.GraphQLNonNull(nullableType)
}
return getOutputTypeFromAST(typeNode)
}
}
function cannotExecuteExtendedSchema() {
throw new Error('Extended Schema cannot use Interface or Union types for execution.')
}
/***/
}),
/* 48 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.BreakingChangeType = undefined
exports.findBreakingChanges = findBreakingChanges
exports.findRemovedTypes = findRemovedTypes
exports.findTypesThatChangedKind = findTypesThatChangedKind
exports.findFieldsThatChangedType = findFieldsThatChangedType
exports.findTypesRemovedFromUnions = findTypesRemovedFromUnions
exports.findValuesRemovedFromEnums = findValuesRemovedFromEnums
var _definition = __webpack_require__(1)
var _schema = __webpack_require__(8)
/**
* Copyright (c) 2016, 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.
*/
var BreakingChangeType = exports.BreakingChangeType = {
FIELD_CHANGED_KIND: 'FIELD_CHANGED_KIND',
FIELD_REMOVED: 'FIELD_REMOVED',
TYPE_CHANGED_KIND: 'TYPE_CHANGED_KIND',
TYPE_REMOVED: 'TYPE_REMOVED',
TYPE_REMOVED_FROM_UNION: 'TYPE_REMOVED_FROM_UNION',
VALUE_REMOVED_FROM_ENUM: 'VALUE_REMOVED_FROM_ENUM'
}
/**
* Given two schemas, returns an Array containing descriptions of all the types
* of breaking changes covered by the other functions down below.
*/
function findBreakingChanges(oldSchema, newSchema) {
return [].concat(findRemovedTypes(oldSchema, newSchema), findTypesThatChangedKind(oldSchema, newSchema),
findFieldsThatChangedType(oldSchema, newSchema), findTypesRemovedFromUnions(oldSchema, newSchema),
findValuesRemovedFromEnums(oldSchema, newSchema))
}
/**
* Given two schemas, returns an Array containing descriptions of any breaking
* changes in the newSchema related to removing an entire type.
*/
function findRemovedTypes(oldSchema, newSchema) {
var oldTypeMap = oldSchema.getTypeMap()
var newTypeMap = newSchema.getTypeMap()
var breakingChanges = []
Object.keys(oldTypeMap).forEach(function(typeName) {
if (!newTypeMap[typeName]) {
breakingChanges.push({
type: BreakingChangeType.TYPE_REMOVED,
description: typeName + ' was removed.'
})
}
})
return breakingChanges
}
/**
* Given two schemas, returns an Array containing descriptions of any breaking
* changes in the newSchema related to changing the type of a type.
*/
function findTypesThatChangedKind(oldSchema, newSchema) {
var oldTypeMap = oldSchema.getTypeMap()
var newTypeMap = newSchema.getTypeMap()
var breakingChanges = []
Object.keys(oldTypeMap).forEach(function(typeName) {
if (!newTypeMap[typeName]) {
return
}
var oldType = oldTypeMap[typeName]
var newType = newTypeMap[typeName]
if (!(oldType instanceof newType.constructor)) {
breakingChanges.push({
type: BreakingChangeType.TYPE_CHANGED_KIND,
description: typeName + ' changed from ' + (typeKindName(oldType) + ' to ' + typeKindName(newType)
+ '.')
})
}
})
return breakingChanges
}
function typeKindName(type) {
if (type instanceof _definition.GraphQLScalarType) {
return 'a Scalar type'
}
if (type instanceof _definition.GraphQLObjectType) {
return 'an Object type'
}
if (type instanceof _definition.GraphQLInterfaceType) {
return 'an Interface type'
}
if (type instanceof _definition.GraphQLUnionType) {
return 'a Union type'
}
if (type instanceof _definition.GraphQLEnumType) {
return 'an Enum type'
}
if (type instanceof _definition.GraphQLInputObjectType) {
return 'an Input type'
}
throw new TypeError('Unknown type ' + type.constructor.name)
}
/**
* Given two schemas, returns an Array containing descriptions of any breaking
* changes in the newSchema related to the fields on a type. This includes if
* a field has been removed from a type or if a field has changed type.
*/
function findFieldsThatChangedType(oldSchema, newSchema) {
var oldTypeMap = oldSchema.getTypeMap()
var newTypeMap = newSchema.getTypeMap()
var breakingFieldChanges = []
Object.keys(oldTypeMap).forEach(function(typeName) {
var oldType = oldTypeMap[typeName]
var newType = newTypeMap[typeName]
if (!(oldType instanceof _definition.GraphQLObjectType || oldType
instanceof _definition.GraphQLInterfaceType || oldType instanceof _definition.GraphQLInputObjectType)
|| !(newType instanceof oldType.constructor)) {
return
}
var oldTypeFieldsDef = oldType.getFields()
var newTypeFieldsDef = newType.getFields()
Object.keys(oldTypeFieldsDef).forEach(function(fieldName) {
// Check if the field is missing on the type in the new schema.
if (!(fieldName in newTypeFieldsDef)) {
breakingFieldChanges.push({
type: BreakingChangeType.FIELD_REMOVED,
description: typeName + '.' + fieldName + ' was removed.'
})
} else {
// Check if the field's type has changed in the new schema.
var oldFieldType = (0, _definition.getNamedType)(oldTypeFieldsDef[fieldName].type)
var newFieldType = (0, _definition.getNamedType)(newTypeFieldsDef[fieldName].type)
if (oldFieldType && newFieldType && oldFieldType.name !== newFieldType.name) {
breakingFieldChanges.push({
type: BreakingChangeType.FIELD_CHANGED_KIND,
description: typeName + '.' + fieldName + ' changed type from ' + (oldFieldType.name + ' to '
+ newFieldType.name + '.')
})
}
}
})
})
return breakingFieldChanges
}
/**
* Given two schemas, returns an Array containing descriptions of any breaking
* changes in the newSchema related to removing types from a union type.
*/
function findTypesRemovedFromUnions(oldSchema, newSchema) {
var oldTypeMap = oldSchema.getTypeMap()
var newTypeMap = newSchema.getTypeMap()
var typesRemovedFromUnion = []
Object.keys(oldTypeMap).forEach(function(typeName) {
var oldType = oldTypeMap[typeName]
var newType = newTypeMap[typeName]
if (!(oldType instanceof _definition.GraphQLUnionType) || !(newType
instanceof _definition.GraphQLUnionType)) {
return
}
var typeNamesInNewUnion = Object.create(null)
newType.getTypes().forEach(function(type) {
typeNamesInNewUnion[type.name] = true
})
oldType.getTypes().forEach(function(type) {
if (!typeNamesInNewUnion[type.name]) {
typesRemovedFromUnion.push({
type: BreakingChangeType.TYPE_REMOVED_FROM_UNION,
description: type.name + ' was removed from union type ' + typeName + '.'
})
}
})
})
return typesRemovedFromUnion
}
/**
* Given two schemas, returns an Array containing descriptions of any breaking
* changes in the newSchema related to removing values from an enum type.
*/
function findValuesRemovedFromEnums(oldSchema, newSchema) {
var oldTypeMap = oldSchema.getTypeMap()
var newTypeMap = newSchema.getTypeMap()
var valuesRemovedFromEnums = []
Object.keys(oldTypeMap).forEach(function(typeName) {
var oldType = oldTypeMap[typeName]
var newType = newTypeMap[typeName]
if (!(oldType instanceof _definition.GraphQLEnumType) || !(newType
instanceof _definition.GraphQLEnumType)) {
return
}
var valuesInNewEnum = Object.create(null)
newType.getValues().forEach(function(value) {
valuesInNewEnum[value.name] = true
})
oldType.getValues().forEach(function(value) {
if (!valuesInNewEnum[value.name]) {
valuesRemovedFromEnums.push({
type: BreakingChangeType.VALUE_REMOVED_FROM_ENUM,
description: value.name + ' was removed from enum type ' + typeName + '.'
})
}
})
})
return valuesRemovedFromEnums
}
/***/
}),
/* 49 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.findDeprecatedUsages = findDeprecatedUsages
var _GraphQLError = __webpack_require__(13)
var _visitor = __webpack_require__(15)
var _definition = __webpack_require__(1)
var _schema = __webpack_require__(8)
var _TypeInfo = __webpack_require__(27)
/**
* A validation rule which reports deprecated usages.
*
* Returns a list of GraphQLError instances describing each deprecated use.
*/
function findDeprecatedUsages(schema, ast) {
var errors = []
var typeInfo = new _TypeInfo.TypeInfo(schema);
(0, _visitor.visit)(ast, (0, _visitor.visitWithTypeInfo)(typeInfo, {
Field: function Field(node) {
var fieldDef = typeInfo.getFieldDef()
if (fieldDef && fieldDef.isDeprecated) {
var parentType = typeInfo.getParentType()
if (parentType) {
var reason = fieldDef.deprecationReason
errors.push(new _GraphQLError.GraphQLError(
'The field ' + parentType.name + '.' + fieldDef.name + ' is deprecated.' + (reason ? ' ' + reason
: ''), [node]))
}
}
},
EnumValue: function EnumValue(node) {
var enumVal = typeInfo.getEnumValue()
if (enumVal && enumVal.isDeprecated) {
var type = (0, _definition.getNamedType)(typeInfo.getInputType())
if (type) {
var reason = enumVal.deprecationReason
errors.push(new _GraphQLError.GraphQLError(
'The enum value ' + type.name + '.' + enumVal.name + ' is deprecated.' + (reason ? ' ' + reason
: ''), [node]))
}
}
}
}))
return errors
}
/**
* Copyright (c) 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.
*/
/***/
}),
/* 50 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.getOperationAST = getOperationAST
var _kinds = __webpack_require__(2)
/**
* Returns an operation AST given a document AST and optionally an operation
* name. If a name is not provided, an operation is only returned if only one is
* provided in the document.
*/
function getOperationAST(documentAST, operationName) {
var operation = null
for (var i = 0; i < documentAST.definitions.length; i++) {
var definition = documentAST.definitions[i]
if (definition.kind === _kinds.OPERATION_DEFINITION) {
if (!operationName) {
// If no operation name was provided, only return an Operation if there
// is one defined in the document. Upon encountering the second, return
// null.
if (operation) {
return null
}
operation = definition
} else if (definition.name && definition.name.value === operationName) {
return definition
}
}
}
return operation
}
/**
* Copyright (c) 2015, 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.
*/
/***/
}),
/* 51 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
var _introspectionQuery = __webpack_require__(52)
Object.defineProperty(exports, 'introspectionQuery', {
enumerable: true,
get: function get() {
return _introspectionQuery.introspectionQuery
}
})
var _getOperationAST = __webpack_require__(50)
Object.defineProperty(exports, 'getOperationAST', {
enumerable: true,
get: function get() {
return _getOperationAST.getOperationAST
}
})
var _buildClientSchema = __webpack_require__(45)
Object.defineProperty(exports, 'buildClientSchema', {
enumerable: true,
get: function get() {
return _buildClientSchema.buildClientSchema
}
})
var _buildASTSchema = __webpack_require__(32)
Object.defineProperty(exports, 'buildASTSchema', {
enumerable: true,
get: function get() {
return _buildASTSchema.buildASTSchema
}
})
Object.defineProperty(exports, 'buildSchema', {
enumerable: true,
get: function get() {
return _buildASTSchema.buildSchema
}
})
var _extendSchema = __webpack_require__(47)
Object.defineProperty(exports, 'extendSchema', {
enumerable: true,
get: function get() {
return _extendSchema.extendSchema
}
})
var _schemaPrinter = __webpack_require__(53)
Object.defineProperty(exports, 'printSchema', {
enumerable: true,
get: function get() {
return _schemaPrinter.printSchema
}
})
Object.defineProperty(exports, 'printType', {
enumerable: true,
get: function get() {
return _schemaPrinter.printType
}
})
Object.defineProperty(exports, 'printIntrospectionSchema', {
enumerable: true,
get: function get() {
return _schemaPrinter.printIntrospectionSchema
}
})
var _typeFromAST = __webpack_require__(9)
Object.defineProperty(exports, 'typeFromAST', {
enumerable: true,
get: function get() {
return _typeFromAST.typeFromAST
}
})
var _valueFromAST = __webpack_require__(16)
Object.defineProperty(exports, 'valueFromAST', {
enumerable: true,
get: function get() {
return _valueFromAST.valueFromAST
}
})
var _astFromValue = __webpack_require__(29)
Object.defineProperty(exports, 'astFromValue', {
enumerable: true,
get: function get() {
return _astFromValue.astFromValue
}
})
var _TypeInfo = __webpack_require__(27)
Object.defineProperty(exports, 'TypeInfo', {
enumerable: true,
get: function get() {
return _TypeInfo.TypeInfo
}
})
var _isValidJSValue = __webpack_require__(33)
Object.defineProperty(exports, 'isValidJSValue', {
enumerable: true,
get: function get() {
return _isValidJSValue.isValidJSValue
}
})
var _isValidLiteralValue = __webpack_require__(18)
Object.defineProperty(exports, 'isValidLiteralValue', {
enumerable: true,
get: function get() {
return _isValidLiteralValue.isValidLiteralValue
}
})
var _concatAST = __webpack_require__(46)
Object.defineProperty(exports, 'concatAST', {
enumerable: true,
get: function get() {
return _concatAST.concatAST
}
})
var _separateOperations = __webpack_require__(54)
Object.defineProperty(exports, 'separateOperations', {
enumerable: true,
get: function get() {
return _separateOperations.separateOperations
}
})
var _typeComparators = __webpack_require__(19)
Object.defineProperty(exports, 'isEqualType', {
enumerable: true,
get: function get() {
return _typeComparators.isEqualType
}
})
Object.defineProperty(exports, 'isTypeSubTypeOf', {
enumerable: true,
get: function get() {
return _typeComparators.isTypeSubTypeOf
}
})
Object.defineProperty(exports, 'doTypesOverlap', {
enumerable: true,
get: function get() {
return _typeComparators.doTypesOverlap
}
})
var _assertValidName = __webpack_require__(28)
Object.defineProperty(exports, 'assertValidName', {
enumerable: true,
get: function get() {
return _assertValidName.assertValidName
}
})
var _findBreakingChanges = __webpack_require__(48)
Object.defineProperty(exports, 'findBreakingChanges', {
enumerable: true,
get: function get() {
return _findBreakingChanges.findBreakingChanges
}
})
var _findDeprecatedUsages = __webpack_require__(49)
Object.defineProperty(exports, 'findDeprecatedUsages', {
enumerable: true,
get: function get() {
return _findDeprecatedUsages.findDeprecatedUsages
}
})
/***/
}),
/* 52 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
var introspectionQuery = exports.introspectionQuery = '\n query IntrospectionQuery {\n __schema {\n queryType { name }\n mutationType { name }\n subscriptionType { name }\n types {\n ...FullType\n }\n directives {\n name\n description\n locations\n args {\n ...InputValue\n }\n }\n }\n }\n\n fragment FullType on __Type {\n kind\n name\n description\n fields(includeDeprecated: true) {\n name\n description\n args {\n ...InputValue\n }\n type {\n ...TypeRef\n }\n isDeprecated\n deprecationReason\n }\n inputFields {\n ...InputValue\n }\n interfaces {\n ...TypeRef\n }\n enumValues(includeDeprecated: true) {\n name\n description\n isDeprecated\n deprecationReason\n }\n possibleTypes {\n ...TypeRef\n }\n }\n\n fragment InputValue on __InputValue {\n name\n description\n type { ...TypeRef }\n defaultValue\n }\n\n fragment TypeRef on __Type {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n }\n }\n }\n }\n }\n }\n }\n }\n'
/**
* Copyright (c) 2015, 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.
*/
/***/
}),
/* 53 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.printSchema = printSchema
exports.printIntrospectionSchema = printIntrospectionSchema
exports.printType = printType
var _invariant = __webpack_require__(3)
var _invariant2 = _interopRequireDefault(_invariant)
var _isNullish = __webpack_require__(6)
var _isNullish2 = _interopRequireDefault(_isNullish)
var _isInvalid = __webpack_require__(14)
var _isInvalid2 = _interopRequireDefault(_isInvalid)
var _astFromValue = __webpack_require__(29)
var _printer = __webpack_require__(4)
var _definition = __webpack_require__(1)
var _scalars = __webpack_require__(7)
var _directives = __webpack_require__(5)
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
/**
* Copyright (c) 2015, 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.
*/
function printSchema(schema) {
return printFilteredSchema(schema, function(n) {
return !isSpecDirective(n)
}, isDefinedType)
}
function printIntrospectionSchema(schema) {
return printFilteredSchema(schema, isSpecDirective, isIntrospectionType)
}
function isSpecDirective(directiveName) {
return directiveName === 'skip' || directiveName === 'include' || directiveName === 'deprecated'
}
function isDefinedType(typename) {
return !isIntrospectionType(typename) && !isBuiltInScalar(typename)
}
function isIntrospectionType(typename) {
return typename.indexOf('__') === 0
}
function isBuiltInScalar(typename) {
return typename === 'String' || typename === 'Boolean' || typename === 'Int' || typename === 'Float'
|| typename === 'ID'
}
function printFilteredSchema(schema, directiveFilter, typeFilter) {
var directives = schema.getDirectives().filter(function(directive) {
return directiveFilter(directive.name)
})
var typeMap = schema.getTypeMap()
var types = Object.keys(typeMap).filter(typeFilter).sort(function(name1, name2) {
return name1.localeCompare(name2)
}).map(function(typeName) {
return typeMap[typeName]
})
return [printSchemaDefinition(schema)].concat(directives.map(printDirective), types.map(printType)).filter(
Boolean).join('\n\n') + '\n'
}
function printSchemaDefinition(schema) {
if (isSchemaOfCommonNames(schema)) {
return
}
var operationTypes = []
var queryType = schema.getQueryType()
if (queryType) {
operationTypes.push(' query: ' + queryType.name)
}
var mutationType = schema.getMutationType()
if (mutationType) {
operationTypes.push(' mutation: ' + mutationType.name)
}
var subscriptionType = schema.getSubscriptionType()
if (subscriptionType) {
operationTypes.push(' subscription: ' + subscriptionType.name)
}
return 'schema {\n' + operationTypes.join('\n') + '\n}'
}
/**
* GraphQL schema define root types for each type of operation. These types are
* the same as any other type and can be named in any manner, however there is
* a common naming convention:
*
* schema {
* query: Query
* mutation: Mutation
* }
*
* When using this naming convention, the schema description can be omitted.
*/
function isSchemaOfCommonNames(schema) {
var queryType = schema.getQueryType()
if (queryType && queryType.name !== 'Query') {
return false
}
var mutationType = schema.getMutationType()
if (mutationType && mutationType.name !== 'Mutation') {
return false
}
var subscriptionType = schema.getSubscriptionType()
if (subscriptionType && subscriptionType.name !== 'Subscription') {
return false
}
return true
}
function printType(type) {
if (type instanceof _definition.GraphQLScalarType) {
return printScalar(type)
} else if (type instanceof _definition.GraphQLObjectType) {
return printObject(type)
} else if (type instanceof _definition.GraphQLInterfaceType) {
return printInterface(type)
} else if (type instanceof _definition.GraphQLUnionType) {
return printUnion(type)
} else if (type instanceof _definition.GraphQLEnumType) {
return printEnum(type)
}
(0, _invariant2.default)(type instanceof _definition.GraphQLInputObjectType)
return printInputObject(type)
}
function printScalar(type) {
return printDescription(type) + ('scalar ' + type.name)
}
function printObject(type) {
var interfaces = type.getInterfaces()
var implementedInterfaces = interfaces.length ? ' implements ' + interfaces.map(function(i) {
return i.name
}).join(', ') : ''
return printDescription(type) + ('type ' + type.name + implementedInterfaces + ' {\n') + printFields(type)
+ '\n' + '}'
}
function printInterface(type) {
return printDescription(type) + ('interface ' + type.name + ' {\n') + printFields(type) + '\n' + '}'
}
function printUnion(type) {
return printDescription(type) + ('union ' + type.name + ' = ' + type.getTypes().join(' | '))
}
function printEnum(type) {
return printDescription(type) + ('enum ' + type.name + ' {\n') + printEnumValues(type.getValues()) + '\n'
+ '}'
}
function printEnumValues(values) {
return values.map(function(value, i) {
return printDescription(value, ' ', !i) + ' ' + value.name + printDeprecated(value)
}).join('\n')
}
function printInputObject(type) {
var fieldMap = type.getFields()
var fields = Object.keys(fieldMap).map(function(fieldName) {
return fieldMap[fieldName]
})
return printDescription(type) + ('input ' + type.name + ' {\n') + fields.map(function(f, i) {
return printDescription(f, ' ', !i) + ' ' + printInputValue(f)
}).join('\n') + '\n' + '}'
}
function printFields(type) {
var fieldMap = type.getFields()
var fields = Object.keys(fieldMap).map(function(fieldName) {
return fieldMap[fieldName]
})
return fields.map(function(f, i) {
return printDescription(f, ' ', !i) + ' ' + f.name + printArgs(f.args, ' ') + ': ' + String(f.type)
+ printDeprecated(f)
}).join('\n')
}
function printArgs(args) {
var indentation = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''
if (args.length === 0) {
return ''
}
// If every arg does not have a description, print them on one line.
if (args.every(function(arg) {
return !arg.description
})) {
return '(' + args.map(printInputValue).join(', ') + ')'
}
return '(\n' + args.map(function(arg, i) {
return printDescription(arg, ' ' + indentation, !i) + ' ' + indentation + printInputValue(arg)
}).join('\n') + '\n' + indentation + ')'
}
function printInputValue(arg) {
var argDecl = arg.name + ': ' + String(arg.type)
if (!(0, _isInvalid2.default)(arg.defaultValue)) {
argDecl += ' = ' + (0, _printer.print)((0, _astFromValue.astFromValue)(arg.defaultValue, arg.type))
}
return argDecl
}
function printDirective(directive) {
return printDescription(directive) + 'directive @' + directive.name + printArgs(directive.args) + ' on '
+ directive.locations.join(' | ')
}
function printDeprecated(fieldOrEnumVal) {
var reason = fieldOrEnumVal.deprecationReason
if ((0, _isNullish2.default)(reason)) {
return ''
}
if (reason === '' || reason === _directives.DEFAULT_DEPRECATION_REASON) {
return ' @deprecated'
}
return ' @deprecated(reason: ' + (0, _printer.print)(
(0, _astFromValue.astFromValue)(reason, _scalars.GraphQLString)) + ')'
}
function printDescription(def) {
var indentation = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''
var firstInBlock = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true
if (!def.description) {
return ''
}
var lines = def.description.split('\n')
var description = indentation && !firstInBlock ? '\n' : ''
for (var i = 0; i < lines.length; i++) {
if (lines[i] === '') {
description += indentation + '#\n'
} else {
// For > 120 character long lines, cut at space boundaries into sublines
// of ~80 chars.
var sublines = breakLine(lines[i], 120 - indentation.length)
for (var j = 0; j < sublines.length; j++) {
description += indentation + '# ' + sublines[j] + '\n'
}
}
}
return description
}
function breakLine(line, len) {
if (line.length < len + 5) {
return [line]
}
var parts = line.split(new RegExp('((?: |^).{15,' + (len - 40) + '}(?= |$))'))
if (parts.length < 4) {
return [line]
}
var sublines = [parts[0] + parts[1] + parts[2]]
for (var i = 3; i < parts.length; i += 2) {
sublines.push(parts[i].slice(1) + parts[i + 1])
}
return sublines
}
/***/
}),
/* 54 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.separateOperations = separateOperations
var _visitor = __webpack_require__(15)
/**
* separateOperations accepts a single AST document which may contain many
* operations and fragments and returns a collection of AST documents each of
* which contains a single operation as well the fragment definitions it
* refers to.
*/
function separateOperations(documentAST) {
var operations = []
var depGraph = Object.create(null)
var fromName = void 0;
// Populate the list of operations and build a dependency graph.
(0, _visitor.visit)(documentAST, {
OperationDefinition: function OperationDefinition(node) {
operations.push(node)
fromName = opName(node)
},
FragmentDefinition: function FragmentDefinition(node) {
fromName = node.name.value
},
FragmentSpread: function FragmentSpread(node) {
var toName = node.name.value;
(depGraph[fromName] || (depGraph[fromName] = Object.create(null)))[toName] = true
}
})
// For each operation, produce a new synthesized AST which includes only what
// is necessary for completing that operation.
var separatedDocumentASTs = Object.create(null)
operations.forEach(function(operation) {
var operationName = opName(operation)
var dependencies = Object.create(null)
collectTransitiveDependencies(dependencies, depGraph, operationName)
separatedDocumentASTs[operationName] = {
kind: 'Document',
definitions: documentAST.definitions.filter(function(def) {
return def === operation || def.kind === 'FragmentDefinition' && dependencies[def.name.value]
})
}
})
return separatedDocumentASTs
}
/**
* Copyright (c) 2015, 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.
*/
// Provides the empty string for anonymous operations.
function opName(operation) {
return operation.name ? operation.name.value : ''
}
// From a dependency graph, collects a list of transitive dependencies by
// recursing through a dependency graph.
function collectTransitiveDependencies(collected, depGraph, fromName) {
var immediateDeps = depGraph[fromName]
if (immediateDeps) {
Object.keys(immediateDeps).forEach(function(toName) {
if (!collected[toName]) {
collected[toName] = true
collectTransitiveDependencies(collected, depGraph, toName)
}
})
}
}
/***/
}),
/* 55 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
var _validate = __webpack_require__(35)
Object.defineProperty(exports, 'validate', {
enumerable: true,
get: function get() {
return _validate.validate
}
})
Object.defineProperty(exports, 'ValidationContext', {
enumerable: true,
get: function get() {
return _validate.ValidationContext
}
})
var _specifiedRules = __webpack_require__(34)
Object.defineProperty(exports, 'specifiedRules', {
enumerable: true,
get: function get() {
return _specifiedRules.specifiedRules
}
})
/***/
}),
/* 56 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.badValueMessage = badValueMessage
exports.ArgumentsOfCorrectType = ArgumentsOfCorrectType
var _error = __webpack_require__(0)
var _printer = __webpack_require__(4)
var _isValidLiteralValue = __webpack_require__(18)
/**
* Copyright (c) 2015, 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.
*/
function badValueMessage(argName, type, value, verboseErrors) {
var message = verboseErrors ? '\n' + verboseErrors.join('\n') : ''
return 'Argument "' + argName + '" has invalid value ' + value + '.' + message
}
/**
* Argument values of correct type
*
* A GraphQL document is only valid if all field argument literal values are
* of the type expected by their position.
*/
function ArgumentsOfCorrectType(context) {
return {
Argument: function Argument(node) {
var argDef = context.getArgument()
if (argDef) {
var errors = (0, _isValidLiteralValue.isValidLiteralValue)(argDef.type, node.value)
if (errors && errors.length > 0) {
context.reportError(new _error.GraphQLError(
badValueMessage(node.name.value, argDef.type, (0, _printer.print)(node.value), errors),
[node.value]))
}
}
return false
}
}
}
/***/
}),
/* 57 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.defaultForNonNullArgMessage = defaultForNonNullArgMessage
exports.badValueForDefaultArgMessage = badValueForDefaultArgMessage
exports.DefaultValuesOfCorrectType = DefaultValuesOfCorrectType
var _error = __webpack_require__(0)
var _printer = __webpack_require__(4)
var _definition = __webpack_require__(1)
var _isValidLiteralValue = __webpack_require__(18)
function defaultForNonNullArgMessage(varName, type, guessType) {
return 'Variable "$' + varName + '" of type "' + String(type) + '" is required and '
+ 'will not use the default value. ' + ('Perhaps you meant to use type "' + String(guessType) + '".')
}
/**
* Copyright (c) 2015, 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.
*/
function badValueForDefaultArgMessage(varName, type, value, verboseErrors) {
var message = verboseErrors ? '\n' + verboseErrors.join('\n') : ''
return 'Variable "$' + varName + '" of type "' + String(type) + '" has invalid ' + ('default value ' + value
+ '.' + message)
}
/**
* Variable default values of correct type
*
* A GraphQL document is only valid if all variable default values are of the
* type expected by their definition.
*/
function DefaultValuesOfCorrectType(context) {
return {
VariableDefinition: function VariableDefinition(node) {
var name = node.variable.name.value
var defaultValue = node.defaultValue
var type = context.getInputType()
if (type instanceof _definition.GraphQLNonNull && defaultValue) {
context.reportError(
new _error.GraphQLError(defaultForNonNullArgMessage(name, type, type.ofType), [defaultValue]))
}
if (type && defaultValue) {
var errors = (0, _isValidLiteralValue.isValidLiteralValue)(type, defaultValue)
if (errors && errors.length > 0) {
context.reportError(new _error.GraphQLError(
badValueForDefaultArgMessage(name, type, (0, _printer.print)(defaultValue), errors),
[defaultValue]))
}
}
return false
},
SelectionSet: function SelectionSet() {
return false
},
FragmentDefinition: function FragmentDefinition() {
return false
}
}
}
/***/
}),
/* 58 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.undefinedFieldMessage = undefinedFieldMessage
exports.FieldsOnCorrectType = FieldsOnCorrectType
var _error = __webpack_require__(0)
var _suggestionList = __webpack_require__(23)
var _suggestionList2 = _interopRequireDefault(_suggestionList)
var _quotedOrList = __webpack_require__(22)
var _quotedOrList2 = _interopRequireDefault(_quotedOrList)
var _definition = __webpack_require__(1)
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
function undefinedFieldMessage(fieldName, type, suggestedTypeNames, suggestedFieldNames) {
var message = 'Cannot query field "' + fieldName + '" on type "' + type + '".'
if (suggestedTypeNames.length !== 0) {
var suggestions = (0, _quotedOrList2.default)(suggestedTypeNames)
message += ' Did you mean to use an inline fragment on ' + suggestions + '?'
} else if (suggestedFieldNames.length !== 0) {
message += ' Did you mean ' + (0, _quotedOrList2.default)(suggestedFieldNames) + '?'
}
return message
}
/**
* Fields on correct type
*
* A GraphQL document is only valid if all fields selected are defined by the
* parent type, or are an allowed meta field such as __typename.
*/
/**
* Copyright (c) 2015, 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.
*/
function FieldsOnCorrectType(context) {
return {
Field: function Field(node) {
var type = context.getParentType()
if (type) {
var fieldDef = context.getFieldDef()
if (!fieldDef) {
// This field doesn't exist, lets look for suggestions.
var schema = context.getSchema()
var fieldName = node.name.value
// First determine if there are any suggested types to condition on.
var suggestedTypeNames = getSuggestedTypeNames(schema, type, fieldName)
// If there are no suggested types, then perhaps this was a typo?
var suggestedFieldNames = suggestedTypeNames.length !== 0 ? [] : getSuggestedFieldNames(schema, type,
fieldName)
// Report an error, including helpful suggestions.
context.reportError(new _error.GraphQLError(
undefinedFieldMessage(fieldName, type.name, suggestedTypeNames, suggestedFieldNames), [node]))
}
}
}
}
}
/**
* Go through all of the implementations of type, as well as the interfaces
* that they implement. If any of those types include the provided field,
* suggest them, sorted by how often the type is referenced, starting
* with Interfaces.
*/
function getSuggestedTypeNames(schema, type, fieldName) {
if (type instanceof _definition.GraphQLInterfaceType || type instanceof _definition.GraphQLUnionType) {
var _ret = function() {
var suggestedObjectTypes = []
var interfaceUsageCount = Object.create(null)
schema.getPossibleTypes(type).forEach(function(possibleType) {
if (!possibleType.getFields()[fieldName]) {
return
}
// This object type defines this field.
suggestedObjectTypes.push(possibleType.name)
possibleType.getInterfaces().forEach(function(possibleInterface) {
if (!possibleInterface.getFields()[fieldName]) {
return
}
// This interface type defines this field.
interfaceUsageCount[possibleInterface.name] = (interfaceUsageCount[possibleInterface.name] || 0) + 1
})
})
// Suggest interface types based on how common they are.
var suggestedInterfaceTypes = Object.keys(interfaceUsageCount).sort(function(a, b) {
return interfaceUsageCount[b] - interfaceUsageCount[a]
})
// Suggest both interface and object types.
return {
v: suggestedInterfaceTypes.concat(suggestedObjectTypes)
}
}()
if (typeof _ret === "object") {
return _ret.v
}
}
// Otherwise, must be an Object type, which does not have possible fields.
return []
}
/**
* For the field name provided, determine if there are any similar field names
* that may be the result of a typo.
*/
function getSuggestedFieldNames(schema, type, fieldName) {
if (type instanceof _definition.GraphQLObjectType || type instanceof _definition.GraphQLInterfaceType) {
var possibleFieldNames = Object.keys(type.getFields())
return (0, _suggestionList2.default)(fieldName, possibleFieldNames)
}
// Otherwise, must be a Union type, which does not define fields.
return []
}
/***/
}),
/* 59 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.inlineFragmentOnNonCompositeErrorMessage = inlineFragmentOnNonCompositeErrorMessage
exports.fragmentOnNonCompositeErrorMessage = fragmentOnNonCompositeErrorMessage
exports.FragmentsOnCompositeTypes = FragmentsOnCompositeTypes
var _error = __webpack_require__(0)
var _printer = __webpack_require__(4)
var _definition = __webpack_require__(1)
/**
* Copyright (c) 2015, 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.
*/
function inlineFragmentOnNonCompositeErrorMessage(type) {
return 'Fragment cannot condition on non composite type "' + String(type) + '".'
}
function fragmentOnNonCompositeErrorMessage(fragName, type) {
return 'Fragment "' + fragName + '" cannot condition on non composite ' + ('type "' + String(type) + '".')
}
/**
* Fragments on composite type
*
* Fragments use a type condition to determine if they apply, since fragments
* can only be spread into a composite type (object, interface, or union), the
* type condition must also be a composite type.
*/
function FragmentsOnCompositeTypes(context) {
return {
InlineFragment: function InlineFragment(node) {
var type = context.getType()
if (node.typeCondition && type && !(0, _definition.isCompositeType)(type)) {
context.reportError(new _error.GraphQLError(
inlineFragmentOnNonCompositeErrorMessage((0, _printer.print)(node.typeCondition)),
[node.typeCondition]))
}
},
FragmentDefinition: function FragmentDefinition(node) {
var type = context.getType()
if (type && !(0, _definition.isCompositeType)(type)) {
context.reportError(new _error.GraphQLError(
fragmentOnNonCompositeErrorMessage(node.name.value, (0, _printer.print)(node.typeCondition)),
[node.typeCondition]))
}
}
}
}
/***/
}),
/* 60 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.unknownArgMessage = unknownArgMessage
exports.unknownDirectiveArgMessage = unknownDirectiveArgMessage
exports.KnownArgumentNames = KnownArgumentNames
var _error = __webpack_require__(0)
var _find = __webpack_require__(10)
var _find2 = _interopRequireDefault(_find)
var _invariant = __webpack_require__(3)
var _invariant2 = _interopRequireDefault(_invariant)
var _suggestionList = __webpack_require__(23)
var _suggestionList2 = _interopRequireDefault(_suggestionList)
var _quotedOrList = __webpack_require__(22)
var _quotedOrList2 = _interopRequireDefault(_quotedOrList)
var _kinds = __webpack_require__(2)
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
function unknownArgMessage(argName, fieldName, type, suggestedArgs) {
var message = 'Unknown argument "' + argName + '" on field "' + fieldName + '" of ' + ('type "' + String(type)
+ '".')
if (suggestedArgs.length) {
message += ' Did you mean ' + (0, _quotedOrList2.default)(suggestedArgs) + '?'
}
return message
}
/**
* Copyright (c) 2015, 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.
*/
function unknownDirectiveArgMessage(argName, directiveName, suggestedArgs) {
var message = 'Unknown argument "' + argName + '" on directive "@' + directiveName + '".'
if (suggestedArgs.length) {
message += ' Did you mean ' + (0, _quotedOrList2.default)(suggestedArgs) + '?'
}
return message
}
/**
* Known argument names
*
* A GraphQL field is only valid if all supplied arguments are defined by
* that field.
*/
function KnownArgumentNames(context) {
return {
Argument: function Argument(node, key, parent, path, ancestors) {
var argumentOf = ancestors[ancestors.length - 1]
if (argumentOf.kind === _kinds.FIELD) {
var fieldDef = context.getFieldDef()
if (fieldDef) {
var fieldArgDef = (0, _find2.default)(fieldDef.args, function(arg) {
return arg.name === node.name.value
})
if (!fieldArgDef) {
var parentType = context.getParentType();
(0, _invariant2.default)(parentType)
context.reportError(new _error.GraphQLError(
unknownArgMessage(node.name.value, fieldDef.name, parentType.name,
(0, _suggestionList2.default)(node.name.value, fieldDef.args.map(function(arg) {
return arg.name
}))), [node]))
}
}
} else if (argumentOf.kind === _kinds.DIRECTIVE) {
var directive = context.getDirective()
if (directive) {
var directiveArgDef = (0, _find2.default)(directive.args, function(arg) {
return arg.name === node.name.value
})
if (!directiveArgDef) {
context.reportError(new _error.GraphQLError(
unknownDirectiveArgMessage(node.name.value, directive.name,
(0, _suggestionList2.default)(node.name.value, directive.args.map(function(arg) {
return arg.name
}))), [node]))
}
}
}
}
}
}
/***/
}),
/* 61 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.unknownDirectiveMessage = unknownDirectiveMessage
exports.misplacedDirectiveMessage = misplacedDirectiveMessage
exports.KnownDirectives = KnownDirectives
var _error = __webpack_require__(0)
var _find = __webpack_require__(10)
var _find2 = _interopRequireDefault(_find)
var _kinds = __webpack_require__(2)
var _directives = __webpack_require__(5)
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
function unknownDirectiveMessage(directiveName) {
return 'Unknown directive "' + directiveName + '".'
}
/**
* Copyright (c) 2015, 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.
*/
function misplacedDirectiveMessage(directiveName, location) {
return 'Directive "' + directiveName + '" may not be used on ' + location + '.'
}
/**
* Known directives
*
* A GraphQL document is only valid if all `@directives` are known by the
* schema and legally positioned.
*/
function KnownDirectives(context) {
return {
Directive: function Directive(node, key, parent, path, ancestors) {
var directiveDef = (0, _find2.default)(context.getSchema().getDirectives(), function(def) {
return def.name === node.name.value
})
if (!directiveDef) {
context.reportError(new _error.GraphQLError(unknownDirectiveMessage(node.name.value), [node]))
return
}
var candidateLocation = getDirectiveLocationForASTPath(ancestors)
if (!candidateLocation) {
context.reportError(
new _error.GraphQLError(misplacedDirectiveMessage(node.name.value, node.type), [node]))
} else if (directiveDef.locations.indexOf(candidateLocation) === -1) {
context.reportError(
new _error.GraphQLError(misplacedDirectiveMessage(node.name.value, candidateLocation), [node]))
}
}
}
}
function getDirectiveLocationForASTPath(ancestors) {
var appliedTo = ancestors[ancestors.length - 1]
switch (appliedTo.kind) {
case _kinds.OPERATION_DEFINITION:
switch (appliedTo.operation) {
case 'query':
return _directives.DirectiveLocation.QUERY
case 'mutation':
return _directives.DirectiveLocation.MUTATION
case 'subscription':
return _directives.DirectiveLocation.SUBSCRIPTION
}
break
case _kinds.FIELD:
return _directives.DirectiveLocation.FIELD
case _kinds.FRAGMENT_SPREAD:
return _directives.DirectiveLocation.FRAGMENT_SPREAD
case _kinds.INLINE_FRAGMENT:
return _directives.DirectiveLocation.INLINE_FRAGMENT
case _kinds.FRAGMENT_DEFINITION:
return _directives.DirectiveLocation.FRAGMENT_DEFINITION
case _kinds.SCHEMA_DEFINITION:
return _directives.DirectiveLocation.SCHEMA
case _kinds.SCALAR_TYPE_DEFINITION:
return _directives.DirectiveLocation.SCALAR
case _kinds.OBJECT_TYPE_DEFINITION:
return _directives.DirectiveLocation.OBJECT
case _kinds.FIELD_DEFINITION:
return _directives.DirectiveLocation.FIELD_DEFINITION
case _kinds.INTERFACE_TYPE_DEFINITION:
return _directives.DirectiveLocation.INTERFACE
case _kinds.UNION_TYPE_DEFINITION:
return _directives.DirectiveLocation.UNION
case _kinds.ENUM_TYPE_DEFINITION:
return _directives.DirectiveLocation.ENUM
case _kinds.ENUM_VALUE_DEFINITION:
return _directives.DirectiveLocation.ENUM_VALUE
case _kinds.INPUT_OBJECT_TYPE_DEFINITION:
return _directives.DirectiveLocation.INPUT_OBJECT
case _kinds.INPUT_VALUE_DEFINITION:
var parentNode = ancestors[ancestors.length - 3]
return parentNode.kind === _kinds.INPUT_OBJECT_TYPE_DEFINITION
? _directives.DirectiveLocation.INPUT_FIELD_DEFINITION
: _directives.DirectiveLocation.ARGUMENT_DEFINITION
}
}
/***/
}),
/* 62 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.unknownFragmentMessage = unknownFragmentMessage
exports.KnownFragmentNames = KnownFragmentNames
var _error = __webpack_require__(0)
/**
* Copyright (c) 2015, 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.
*/
function unknownFragmentMessage(fragName) {
return 'Unknown fragment "' + fragName + '".'
}
/**
* Known fragment names
*
* A GraphQL document is only valid if all `...Fragment` fragment spreads refer
* to fragments defined in the same document.
*/
function KnownFragmentNames(context) {
return {
FragmentSpread: function FragmentSpread(node) {
var fragmentName = node.name.value
var fragment = context.getFragment(fragmentName)
if (!fragment) {
context.reportError(new _error.GraphQLError(unknownFragmentMessage(fragmentName), [node.name]))
}
}
}
}
/***/
}),
/* 63 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.unknownTypeMessage = unknownTypeMessage
exports.KnownTypeNames = KnownTypeNames
var _error = __webpack_require__(0)
var _suggestionList = __webpack_require__(23)
var _suggestionList2 = _interopRequireDefault(_suggestionList)
var _quotedOrList = __webpack_require__(22)
var _quotedOrList2 = _interopRequireDefault(_quotedOrList)
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
/**
* Copyright (c) 2015, 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.
*/
function unknownTypeMessage(type, suggestedTypes) {
var message = 'Unknown type "' + String(type) + '".'
if (suggestedTypes.length) {
message += ' Did you mean ' + (0, _quotedOrList2.default)(suggestedTypes) + '?'
}
return message
}
/**
* Known type names
*
* A GraphQL document is only valid if referenced types (specifically
* variable definitions and fragment conditions) are defined by the type schema.
*/
function KnownTypeNames(context) {
return {
// TODO: when validating IDL, re-enable these. Experimental version does not
// add unreferenced types, resulting in false-positive errors. Squelched
// errors for now.
ObjectTypeDefinition: function ObjectTypeDefinition() {
return false
},
InterfaceTypeDefinition: function InterfaceTypeDefinition() {
return false
},
UnionTypeDefinition: function UnionTypeDefinition() {
return false
},
InputObjectTypeDefinition: function InputObjectTypeDefinition() {
return false
},
NamedType: function NamedType(node) {
var schema = context.getSchema()
var typeName = node.name.value
var type = schema.getType(typeName)
if (!type) {
context.reportError(new _error.GraphQLError(unknownTypeMessage(typeName,
(0, _suggestionList2.default)(typeName, Object.keys(schema.getTypeMap()))), [node]))
}
}
}
}
/***/
}),
/* 64 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.anonOperationNotAloneMessage = anonOperationNotAloneMessage
exports.LoneAnonymousOperation = LoneAnonymousOperation
var _error = __webpack_require__(0)
var _kinds = __webpack_require__(2)
function anonOperationNotAloneMessage() {
return 'This anonymous operation must be the only defined operation.'
}
/**
* Lone anonymous operation
*
* A GraphQL document is only valid if when it contains an anonymous operation
* (the query short-hand) that it contains only that one operation definition.
*/
/**
* Copyright (c) 2015, 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.
*/
function LoneAnonymousOperation(context) {
var operationCount = 0
return {
Document: function Document(node) {
operationCount = node.definitions.filter(function(definition) {
return definition.kind === _kinds.OPERATION_DEFINITION
}).length
},
OperationDefinition: function OperationDefinition(node) {
if (!node.name && operationCount > 1) {
context.reportError(new _error.GraphQLError(anonOperationNotAloneMessage(), [node]))
}
}
}
}
/***/
}),
/* 65 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.cycleErrorMessage = cycleErrorMessage
exports.NoFragmentCycles = NoFragmentCycles
var _error = __webpack_require__(0)
/**
* Copyright (c) 2015, 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.
*/
function cycleErrorMessage(fragName, spreadNames) {
var via = spreadNames.length ? ' via ' + spreadNames.join(', ') : ''
return 'Cannot spread fragment "' + fragName + '" within itself' + via + '.'
}
function NoFragmentCycles(context) {
// Tracks already visited fragments to maintain O(N) and to ensure that cycles
// are not redundantly reported.
var visitedFrags = Object.create(null)
// Array of AST nodes used to produce meaningful errors
var spreadPath = []
// Position in the spread path
var spreadPathIndexByName = Object.create(null)
return {
OperationDefinition: function OperationDefinition() {
return false
},
FragmentDefinition: function FragmentDefinition(node) {
if (!visitedFrags[node.name.value]) {
detectCycleRecursive(node)
}
return false
}
}
// This does a straight-forward DFS to find cycles.
// It does not terminate when a cycle was found but continues to explore
// the graph to find all possible cycles.
function detectCycleRecursive(fragment) {
var fragmentName = fragment.name.value
visitedFrags[fragmentName] = true
var spreadNodes = context.getFragmentSpreads(fragment.selectionSet)
if (spreadNodes.length === 0) {
return
}
spreadPathIndexByName[fragmentName] = spreadPath.length
for (var i = 0; i < spreadNodes.length; i++) {
var spreadNode = spreadNodes[i]
var spreadName = spreadNode.name.value
var cycleIndex = spreadPathIndexByName[spreadName]
if (cycleIndex === undefined) {
spreadPath.push(spreadNode)
if (!visitedFrags[spreadName]) {
var spreadFragment = context.getFragment(spreadName)
if (spreadFragment) {
detectCycleRecursive(spreadFragment)
}
}
spreadPath.pop()
} else {
var cyclePath = spreadPath.slice(cycleIndex)
context.reportError(new _error.GraphQLError(cycleErrorMessage(spreadName, cyclePath.map(function(s) {
return s.name.value
})), cyclePath.concat(spreadNode)))
}
}
spreadPathIndexByName[fragmentName] = undefined
}
}
/***/
}),
/* 66 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.undefinedVarMessage = undefinedVarMessage
exports.NoUndefinedVariables = NoUndefinedVariables
var _error = __webpack_require__(0)
/**
* Copyright (c) 2015, 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.
*/
function undefinedVarMessage(varName, opName) {
return opName ? 'Variable "$' + varName + '" is not defined by operation "' + opName + '".' : 'Variable "$'
+ varName + '" is not defined.'
}
/**
* No undefined variables
*
* A GraphQL operation is only valid if all variables encountered, both directly
* and via fragment spreads, are defined by that operation.
*/
function NoUndefinedVariables(context) {
var variableNameDefined = Object.create(null)
return {
OperationDefinition: {
enter: function enter() {
variableNameDefined = Object.create(null)
},
leave: function leave(operation) {
var usages = context.getRecursiveVariableUsages(operation)
usages.forEach(function(_ref) {
var node = _ref.node
var varName = node.name.value
if (variableNameDefined[varName] !== true) {
context.reportError(
new _error.GraphQLError(undefinedVarMessage(varName, operation.name && operation.name.value),
[node, operation]))
}
})
}
},
VariableDefinition: function VariableDefinition(node) {
variableNameDefined[node.variable.name.value] = true
}
}
}
/***/
}),
/* 67 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.unusedFragMessage = unusedFragMessage
exports.NoUnusedFragments = NoUnusedFragments
var _error = __webpack_require__(0)
/**
* Copyright (c) 2015, 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.
*/
function unusedFragMessage(fragName) {
return 'Fragment "' + fragName + '" is never used.'
}
/**
* No unused fragments
*
* A GraphQL document is only valid if all fragment definitions are spread
* within operations, or spread within other fragments spread within operations.
*/
function NoUnusedFragments(context) {
var operationDefs = []
var fragmentDefs = []
return {
OperationDefinition: function OperationDefinition(node) {
operationDefs.push(node)
return false
},
FragmentDefinition: function FragmentDefinition(node) {
fragmentDefs.push(node)
return false
},
Document: {
leave: function leave() {
var fragmentNameUsed = Object.create(null)
operationDefs.forEach(function(operation) {
context.getRecursivelyReferencedFragments(operation).forEach(function(fragment) {
fragmentNameUsed[fragment.name.value] = true
})
})
fragmentDefs.forEach(function(fragmentDef) {
var fragName = fragmentDef.name.value
if (fragmentNameUsed[fragName] !== true) {
context.reportError(new _error.GraphQLError(unusedFragMessage(fragName), [fragmentDef]))
}
})
}
}
}
}
/***/
}),
/* 68 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.unusedVariableMessage = unusedVariableMessage
exports.NoUnusedVariables = NoUnusedVariables
var _error = __webpack_require__(0)
/**
* Copyright (c) 2015, 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.
*/
function unusedVariableMessage(varName, opName) {
return opName ? 'Variable "$' + varName + '" is never used in operation "' + opName + '".' : 'Variable "$'
+ varName + '" is never used.'
}
/**
* No unused variables
*
* A GraphQL operation is only valid if all variables defined by an operation
* are used, either directly or within a spread fragment.
*/
function NoUnusedVariables(context) {
var variableDefs = []
return {
OperationDefinition: {
enter: function enter() {
variableDefs = []
},
leave: function leave(operation) {
var variableNameUsed = Object.create(null)
var usages = context.getRecursiveVariableUsages(operation)
var opName = operation.name ? operation.name.value : null
usages.forEach(function(_ref) {
var node = _ref.node
variableNameUsed[node.name.value] = true
})
variableDefs.forEach(function(variableDef) {
var variableName = variableDef.variable.name.value
if (variableNameUsed[variableName] !== true) {
context.reportError(
new _error.GraphQLError(unusedVariableMessage(variableName, opName), [variableDef]))
}
})
}
},
VariableDefinition: function VariableDefinition(def) {
variableDefs.push(def)
}
}
}
/***/
}),
/* 69 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.fieldsConflictMessage = fieldsConflictMessage
exports.OverlappingFieldsCanBeMerged = OverlappingFieldsCanBeMerged
var _error = __webpack_require__(0)
var _find = __webpack_require__(10)
var _find2 = _interopRequireDefault(_find)
var _kinds = __webpack_require__(2)
var _printer = __webpack_require__(4)
var _definition = __webpack_require__(1)
var _typeFromAST = __webpack_require__(9)
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function")
}
}
/**
* Copyright (c) 2015, 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.
*/
function fieldsConflictMessage(responseName, reason) {
return 'Fields "' + responseName + '" conflict because ' + reasonMessage(reason)
+ '. Use different aliases on the fields to fetch both if this was ' + 'intentional.'
}
function reasonMessage(reason) {
if (Array.isArray(reason)) {
return reason.map(function(_ref) {
var responseName = _ref[0],
subreason = _ref[1]
return 'subfields "' + responseName + '" conflict because ' + reasonMessage(subreason)
}).join(' and ')
}
return reason
}
/**
* Overlapping fields can be merged
*
* A selection set is only valid if all fields (including spreading any
* fragments) either correspond to distinct response names or can be merged
* without ambiguity.
*/
function OverlappingFieldsCanBeMerged(context) {
// A memoization for when two fragments are compared "between" each other for
// conflicts. Two fragments may be compared many times, so memoizing this can
// dramatically improve the performance of this validator.
var comparedFragments = new PairSet()
// A cache for the "field map" and list of fragment names found in any given
// selection set. Selection sets may be asked for this information multiple
// times, so this improves the performance of this validator.
var cachedFieldsAndFragmentNames = new Map()
return {
SelectionSet: function SelectionSet(selectionSet) {
var conflicts = findConflictsWithinSelectionSet(context, cachedFieldsAndFragmentNames, comparedFragments,
context.getParentType(), selectionSet)
conflicts.forEach(function(_ref2) {
var _ref2$ = _ref2[0],
responseName = _ref2$[0],
reason = _ref2$[1],
fields1 = _ref2[1],
fields2 = _ref2[2]
return context.reportError(
new _error.GraphQLError(fieldsConflictMessage(responseName, reason), fields1.concat(fields2)))
})
}
}
}
// Field name and reason.
// Reason is a string, or a nested list of conflicts.
// Tuple defining a field node in a context.
// Map of array of those.
/**
* Algorithm:
*
* Conflicts occur when two fields exist in a query which will produce the same
* response name, but represent differing values, thus creating a conflict.
* The algorithm below finds all conflicts via making a series of comparisons
* between fields. In order to compare as few fields as possible, this makes
* a series of comparisons "within" sets of fields and "between" sets of fields.
*
* Given any selection set, a collection produces both a set of fields by
* also including all inline fragments, as well as a list of fragments
* referenced by fragment spreads.
*
* A) Each selection set represented in the document first compares "within" its
* collected set of fields, finding any conflicts between every pair of
* overlapping fields.
* Note: This is the *only time* that a the fields "within" a set are compared
* to each other. After this only fields "between" sets are compared.
*
* B) Also, if any fragment is referenced in a selection set, then a
* comparison is made "between" the original set of fields and the
* referenced fragment.
*
* C) Also, if multiple fragments are referenced, then comparisons
* are made "between" each referenced fragment.
*
* D) When comparing "between" a set of fields and a referenced fragment, first
* a comparison is made between each field in the original set of fields and
* each field in the the referenced set of fields.
*
* E) Also, if any fragment is referenced in the referenced selection set,
* then a comparison is made "between" the original set of fields and the
* referenced fragment (recursively referring to step D).
*
* F) When comparing "between" two fragments, first a comparison is made between
* each field in the first referenced set of fields and each field in the the
* second referenced set of fields.
*
* G) Also, any fragments referenced by the first must be compared to the
* second, and any fragments referenced by the second must be compared to the
* first (recursively referring to step F).
*
* H) When comparing two fields, if both have selection sets, then a comparison
* is made "between" both selection sets, first comparing the set of fields in
* the first selection set with the set of fields in the second.
*
* I) Also, if any fragment is referenced in either selection set, then a
* comparison is made "between" the other set of fields and the
* referenced fragment.
*
* J) Also, if two fragments are referenced in both selection sets, then a
* comparison is made "between" the two fragments.
*
*/
// Find all conflicts found "within" a selection set, including those found
// via spreading in fragments. Called when visiting each SelectionSet in the
// GraphQL Document.
function findConflictsWithinSelectionSet(context, cachedFieldsAndFragmentNames, comparedFragments, parentType,
selectionSet) {
var conflicts = []
var _getFieldsAndFragment = getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType,
selectionSet),
fieldMap = _getFieldsAndFragment[0],
fragmentNames = _getFieldsAndFragment[1]
// (A) Find find all conflicts "within" the fields of this selection set.
// Note: this is the *only place* `collectConflictsWithin` is called.
collectConflictsWithin(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, fieldMap)
// (B) Then collect conflicts between these fields and those represented by
// each spread fragment name found.
for (var i = 0; i < fragmentNames.length; i++) {
collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames,
comparedFragments, false, fieldMap, fragmentNames[i])
// (C) Then compare this fragment with all other fragments found in this
// selection set to collect conflicts between fragments spread together.
// This compares each item in the list of fragment names to every other item
// in that same list (except for itself).
for (var j = i + 1; j < fragmentNames.length; j++) {
collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments,
false, fragmentNames[i], fragmentNames[j])
}
}
return conflicts
}
// Collect all conflicts found between a set of fields and a fragment reference
// including via spreading in any nested fragments.
function collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames,
comparedFragments, areMutuallyExclusive, fieldMap, fragmentName) {
var fragment = context.getFragment(fragmentName)
if (!fragment) {
return
}
var _getReferencedFieldsA = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames,
fragment),
fieldMap2 = _getReferencedFieldsA[0],
fragmentNames2 = _getReferencedFieldsA[1]
// (D) First collect any conflicts between the provided collection of fields
// and the collection of fields represented by the given fragment.
collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments,
areMutuallyExclusive, fieldMap, fieldMap2)
// (E) Then collect any conflicts between the provided collection of fields
// and any fragment names found in the given fragment.
for (var i = 0; i < fragmentNames2.length; i++) {
collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames,
comparedFragments, areMutuallyExclusive, fieldMap, fragmentNames2[i])
}
}
// Collect all conflicts found between two fragments, including via spreading in
// any nested fragments.
function collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments,
areMutuallyExclusive, fragmentName1, fragmentName2) {
var fragment1 = context.getFragment(fragmentName1)
var fragment2 = context.getFragment(fragmentName2)
if (!fragment1 || !fragment2) {
return
}
// No need to compare a fragment to itself.
if (fragment1 === fragment2) {
return
}
// Memoize so two fragments are not compared for conflicts more than once.
if (comparedFragments.has(fragmentName1, fragmentName2, areMutuallyExclusive)) {
return
}
comparedFragments.add(fragmentName1, fragmentName2, areMutuallyExclusive)
var _getReferencedFieldsA2 = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames,
fragment1),
fieldMap1 = _getReferencedFieldsA2[0],
fragmentNames1 = _getReferencedFieldsA2[1]
var _getReferencedFieldsA3 = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames,
fragment2),
fieldMap2 = _getReferencedFieldsA3[0],
fragmentNames2 = _getReferencedFieldsA3[1]
// (F) First, collect all conflicts between these two collections of fields
// (not including any nested fragments).
collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments,
areMutuallyExclusive, fieldMap1, fieldMap2)
// (G) Then collect conflicts between the first fragment and any nested
// fragments spread in the second fragment.
for (var j = 0; j < fragmentNames2.length; j++) {
collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments,
areMutuallyExclusive, fragmentName1, fragmentNames2[j])
}
// (G) Then collect conflicts between the second fragment and any nested
// fragments spread in the first fragment.
for (var i = 0; i < fragmentNames1.length; i++) {
collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments,
areMutuallyExclusive, fragmentNames1[i], fragmentName2)
}
}
// Find all conflicts found between two selection sets, including those found
// via spreading in fragments. Called when determining if conflicts exist
// between the sub-fields of two overlapping fields.
function findConflictsBetweenSubSelectionSets(context, cachedFieldsAndFragmentNames, comparedFragments,
areMutuallyExclusive, parentType1, selectionSet1, parentType2, selectionSet2) {
var conflicts = []
var _getFieldsAndFragment2 = getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType1,
selectionSet1),
fieldMap1 = _getFieldsAndFragment2[0],
fragmentNames1 = _getFieldsAndFragment2[1]
var _getFieldsAndFragment3 = getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType2,
selectionSet2),
fieldMap2 = _getFieldsAndFragment3[0],
fragmentNames2 = _getFieldsAndFragment3[1]
// (H) First, collect all conflicts between these two collections of field.
collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments,
areMutuallyExclusive, fieldMap1, fieldMap2)
// (I) Then collect conflicts between the first collection of fields and
// those referenced by each fragment name associated with the second.
for (var j = 0; j < fragmentNames2.length; j++) {
collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames,
comparedFragments, areMutuallyExclusive, fieldMap1, fragmentNames2[j])
}
// (I) Then collect conflicts between the second collection of fields and
// those referenced by each fragment name associated with the first.
for (var i = 0; i < fragmentNames1.length; i++) {
collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames,
comparedFragments, areMutuallyExclusive, fieldMap2, fragmentNames1[i])
}
// (J) Also collect conflicts between any fragment names by the first and
// fragment names by the second. This compares each item in the first set of
// names to each item in the second set of names.
for (var _i = 0; _i < fragmentNames1.length; _i++) {
for (var _j = 0; _j < fragmentNames2.length; _j++) {
collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments,
areMutuallyExclusive, fragmentNames1[_i], fragmentNames2[_j])
}
}
return conflicts
}
// Collect all Conflicts "within" one collection of fields.
function collectConflictsWithin(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, fieldMap) {
// A field map is a keyed collection, where each key represents a response
// name and the value at that key is a list of all fields which provide that
// response name. For every response name, if there are multiple fields, they
// must be compared to find a potential conflict.
Object.keys(fieldMap).forEach(function(responseName) {
var fields = fieldMap[responseName]
// This compares every field in the list to every other field in this list
// (except to itself). If the list only has one item, nothing needs to
// be compared.
if (fields.length > 1) {
for (var i = 0; i < fields.length; i++) {
for (var j = i + 1; j < fields.length; j++) {
var conflict = findConflict(context, cachedFieldsAndFragmentNames, comparedFragments, false, // within one collection is never mutually exclusive
responseName, fields[i], fields[j])
if (conflict) {
conflicts.push(conflict)
}
}
}
}
})
}
// Collect all Conflicts between two collections of fields. This is similar to,
// but different from the `collectConflictsWithin` function above. This check
// assumes that `collectConflictsWithin` has already been called on each
// provided collection of fields. This is true because this validator traverses
// each individual selection set.
function collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments,
parentFieldsAreMutuallyExclusive, fieldMap1, fieldMap2) {
// A field map is a keyed collection, where each key represents a response
// name and the value at that key is a list of all fields which provide that
// response name. For any response name which appears in both provided field
// maps, each field from the first field map must be compared to every field
// in the second field map to find potential conflicts.
Object.keys(fieldMap1).forEach(function(responseName) {
var fields2 = fieldMap2[responseName]
if (fields2) {
var fields1 = fieldMap1[responseName]
for (var i = 0; i < fields1.length; i++) {
for (var j = 0; j < fields2.length; j++) {
var conflict = findConflict(context, cachedFieldsAndFragmentNames, comparedFragments,
parentFieldsAreMutuallyExclusive, responseName, fields1[i], fields2[j])
if (conflict) {
conflicts.push(conflict)
}
}
}
}
})
}
// Determines if there is a conflict between two particular fields, including
// comparing their sub-fields.
function findConflict(context, cachedFieldsAndFragmentNames, comparedFragments,
parentFieldsAreMutuallyExclusive, responseName, field1, field2) {
var parentType1 = field1[0],
node1 = field1[1],
def1 = field1[2]
var parentType2 = field2[0],
node2 = field2[1],
def2 = field2[2]
// If it is known that two fields could not possibly apply at the same
// time, due to the parent types, then it is safe to permit them to diverge
// in aliased field or arguments used as they will not present any ambiguity
// by differing.
// It is known that two parent types could never overlap if they are
// different Object types. Interface or Union types might overlap - if not
// in the current state of the schema, then perhaps in some future version,
// thus may not safely diverge.
var areMutuallyExclusive = parentFieldsAreMutuallyExclusive || parentType1 !== parentType2 && parentType1
instanceof _definition.GraphQLObjectType && parentType2 instanceof _definition.GraphQLObjectType
// The return type for each field.
var type1 = def1 && def1.type
var type2 = def2 && def2.type
if (!areMutuallyExclusive) {
// Two aliases must refer to the same field.
var name1 = node1.name.value
var name2 = node2.name.value
if (name1 !== name2) {
return [[responseName, name1 + ' and ' + name2 + ' are different fields'], [node1], [node2]]
}
// Two field calls must have the same arguments.
if (!sameArguments(node1.arguments || [], node2.arguments || [])) {
return [[responseName, 'they have differing arguments'], [node1], [node2]]
}
}
if (type1 && type2 && doTypesConflict(type1, type2)) {
return [[responseName, 'they return conflicting types ' + String(type1) + ' and ' + String(type2)], [node1],
[node2]]
}
// Collect and compare sub-fields. Use the same "visited fragment names" list
// for both collections so fields in a fragment reference are never
// compared to themselves.
var selectionSet1 = node1.selectionSet
var selectionSet2 = node2.selectionSet
if (selectionSet1 && selectionSet2) {
var conflicts = findConflictsBetweenSubSelectionSets(context, cachedFieldsAndFragmentNames,
comparedFragments, areMutuallyExclusive, (0, _definition.getNamedType)(type1), selectionSet1,
(0, _definition.getNamedType)(type2), selectionSet2)
return subfieldConflicts(conflicts, responseName, node1, node2)
}
}
function sameArguments(arguments1, arguments2) {
if (arguments1.length !== arguments2.length) {
return false
}
return arguments1.every(function(argument1) {
var argument2 = (0, _find2.default)(arguments2, function(argument) {
return argument.name.value === argument1.name.value
})
if (!argument2) {
return false
}
return sameValue(argument1.value, argument2.value)
})
}
function sameValue(value1, value2) {
return !value1 && !value2 || (0, _printer.print)(value1) === (0, _printer.print)(value2)
}
// Two types conflict if both types could not apply to a value simultaneously.
// Composite types are ignored as their individual field types will be compared
// later recursively. However List and Non-Null types must match.
function doTypesConflict(type1, type2) {
if (type1 instanceof _definition.GraphQLList) {
return type2 instanceof _definition.GraphQLList ? doTypesConflict(type1.ofType, type2.ofType) : true
}
if (type2 instanceof _definition.GraphQLList) {
return type1 instanceof _definition.GraphQLList ? doTypesConflict(type1.ofType, type2.ofType) : true
}
if (type1 instanceof _definition.GraphQLNonNull) {
return type2 instanceof _definition.GraphQLNonNull ? doTypesConflict(type1.ofType, type2.ofType) : true
}
if (type2 instanceof _definition.GraphQLNonNull) {
return type1 instanceof _definition.GraphQLNonNull ? doTypesConflict(type1.ofType, type2.ofType) : true
}
if ((0, _definition.isLeafType)(type1) || (0, _definition.isLeafType)(type2)) {
return type1 !== type2
}
return false
}
// Given a selection set, return the collection of fields (a mapping of response
// name to field nodes and definitions) as well as a list of fragment names
// referenced via fragment spreads.
function getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType, selectionSet) {
var cached = cachedFieldsAndFragmentNames.get(selectionSet)
if (!cached) {
var nodeAndDefs = {}
var fragmentNames = {}
_collectFieldsAndFragmentNames(context, parentType, selectionSet, nodeAndDefs, fragmentNames)
cached = [nodeAndDefs, Object.keys(fragmentNames)]
cachedFieldsAndFragmentNames.set(selectionSet, cached)
}
return cached
}
// Given a reference to a fragment, return the represented collection of fields
// as well as a list of nested fragment names referenced via fragment spreads.
function getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment) {
// Short-circuit building a type from the node if possible.
var cached = cachedFieldsAndFragmentNames.get(fragment.selectionSet)
if (cached) {
return cached
}
var fragmentType = (0, _typeFromAST.typeFromAST)(context.getSchema(), fragment.typeCondition)
return getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragmentType, fragment.selectionSet)
}
function _collectFieldsAndFragmentNames(context, parentType, selectionSet, nodeAndDefs, fragmentNames) {
for (var i = 0; i < selectionSet.selections.length; i++) {
var selection = selectionSet.selections[i]
switch (selection.kind) {
case _kinds.FIELD:
var fieldName = selection.name.value
var fieldDef = void 0
if (parentType instanceof _definition.GraphQLObjectType || parentType
instanceof _definition.GraphQLInterfaceType) {
fieldDef = parentType.getFields()[fieldName]
}
var responseName = selection.alias ? selection.alias.value : fieldName
if (!nodeAndDefs[responseName]) {
nodeAndDefs[responseName] = []
}
nodeAndDefs[responseName].push([parentType, selection, fieldDef])
break
case _kinds.FRAGMENT_SPREAD:
fragmentNames[selection.name.value] = true
break
case _kinds.INLINE_FRAGMENT:
var typeCondition = selection.typeCondition
var inlineFragmentType = typeCondition ? (0, _typeFromAST.typeFromAST)(context.getSchema(),
typeCondition) : parentType
_collectFieldsAndFragmentNames(context, inlineFragmentType, selection.selectionSet, nodeAndDefs,
fragmentNames)
break
}
}
}
// Given a series of Conflicts which occurred between two sub-fields, generate
// a single Conflict.
function subfieldConflicts(conflicts, responseName, node1, node2) {
if (conflicts.length > 0) {
return [[responseName, conflicts.map(function(_ref3) {
var reason = _ref3[0]
return reason
})], conflicts.reduce(function(allFields, _ref4) {
var fields1 = _ref4[1]
return allFields.concat(fields1)
}, [node1]), conflicts.reduce(function(allFields, _ref5) {
var fields2 = _ref5[2]
return allFields.concat(fields2)
}, [node2])]
}
}
/**
* A way to keep track of pairs of things when the ordering of the pair does
* not matter. We do this by maintaining a sort of double adjacency sets.
*/
var PairSet = function() {
function PairSet() {
_classCallCheck(this, PairSet)
this._data = Object.create(null)
}
PairSet.prototype.has = function has(a, b, areMutuallyExclusive) {
var first = this._data[a]
var result = first && first[b]
if (result === undefined) {
return false
}
// areMutuallyExclusive being false is a superset of being true,
// hence if we want to know if this PairSet "has" these two with no
// exclusivity, we have to ensure it was added as such.
if (areMutuallyExclusive === false) {
return result === false
}
return true
}
PairSet.prototype.add = function add(a, b, areMutuallyExclusive) {
_pairSetAdd(this._data, a, b, areMutuallyExclusive)
_pairSetAdd(this._data, b, a, areMutuallyExclusive)
}
return PairSet
}()
function _pairSetAdd(data, a, b, areMutuallyExclusive) {
var map = data[a]
if (!map) {
map = Object.create(null)
data[a] = map
}
map[b] = areMutuallyExclusive
}
/***/
}),
/* 70 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.typeIncompatibleSpreadMessage = typeIncompatibleSpreadMessage
exports.typeIncompatibleAnonSpreadMessage = typeIncompatibleAnonSpreadMessage
exports.PossibleFragmentSpreads = PossibleFragmentSpreads
var _error = __webpack_require__(0)
var _typeComparators = __webpack_require__(19)
var _typeFromAST = __webpack_require__(9)
/**
* Copyright (c) 2015, 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.
*/
function typeIncompatibleSpreadMessage(fragName, parentType, fragType) {
return 'Fragment "' + fragName + '" cannot be spread here as objects of ' + ('type "' + String(parentType)
+ '" can never be of type "' + String(fragType) + '".')
}
function typeIncompatibleAnonSpreadMessage(parentType, fragType) {
return 'Fragment cannot be spread here as objects of ' + ('type "' + String(parentType)
+ '" can never be of type "' + String(fragType) + '".')
}
/**
* Possible fragment spread
*
* A fragment spread is only valid if the type condition could ever possibly
* be true: if there is a non-empty intersection of the possible parent types,
* and possible types which pass the type condition.
*/
function PossibleFragmentSpreads(context) {
return {
InlineFragment: function InlineFragment(node) {
var fragType = context.getType()
var parentType = context.getParentType()
if (fragType && parentType && !(0, _typeComparators.doTypesOverlap)(context.getSchema(), fragType,
parentType)) {
context.reportError(
new _error.GraphQLError(typeIncompatibleAnonSpreadMessage(parentType, fragType), [node]))
}
},
FragmentSpread: function FragmentSpread(node) {
var fragName = node.name.value
var fragType = getFragmentType(context, fragName)
var parentType = context.getParentType()
if (fragType && parentType && !(0, _typeComparators.doTypesOverlap)(context.getSchema(), fragType,
parentType)) {
context.reportError(
new _error.GraphQLError(typeIncompatibleSpreadMessage(fragName, parentType, fragType), [node]))
}
}
}
}
function getFragmentType(context, name) {
var frag = context.getFragment(name)
return frag && (0, _typeFromAST.typeFromAST)(context.getSchema(), frag.typeCondition)
}
/***/
}),
/* 71 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.missingFieldArgMessage = missingFieldArgMessage
exports.missingDirectiveArgMessage = missingDirectiveArgMessage
exports.ProvidedNonNullArguments = ProvidedNonNullArguments
var _error = __webpack_require__(0)
var _keyMap = __webpack_require__(12)
var _keyMap2 = _interopRequireDefault(_keyMap)
var _definition = __webpack_require__(1)
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { 'default': obj }
}
/**
* Copyright (c) 2015, 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.
*/
function missingFieldArgMessage(fieldName, argName, type) {
return 'Field "' + fieldName + '" argument "' + argName + '" of type ' + ('"' + String(type)
+ '" is required but not provided.')
}
function missingDirectiveArgMessage(directiveName, argName, type) {
return 'Directive "@' + directiveName + '" argument "' + argName + '" of type ' + ('"' + String(type)
+ '" is required but not provided.')
}
/**
* Provided required arguments
*
* A field or directive is only valid if all required (non-null) field arguments
* have been provided.
*/
function ProvidedNonNullArguments(context) {
return {
Field: {
// Validate on leave to allow for deeper errors to appear first.
leave: function leave(node) {
var fieldDef = context.getFieldDef()
if (!fieldDef) {
return false
}
var argNodes = node.arguments || []
var argNodeMap = (0, _keyMap2.default)(argNodes, function(arg) {
return arg.name.value
})
fieldDef.args.forEach(function(argDef) {
var argNode = argNodeMap[argDef.name]
if (!argNode && argDef.type instanceof _definition.GraphQLNonNull) {
context.reportError(
new _error.GraphQLError(missingFieldArgMessage(node.name.value, argDef.name, argDef.type),
[node]))
}
})
}
},
Directive: {
// Validate on leave to allow for deeper errors to appear first.
leave: function leave(node) {
var directiveDef = context.getDirective()
if (!directiveDef) {
return false
}
var argNodes = node.arguments || []
var argNodeMap = (0, _keyMap2.default)(argNodes, function(arg) {
return arg.name.value
})
directiveDef.args.forEach(function(argDef) {
var argNode = argNodeMap[argDef.name]
if (!argNode && argDef.type instanceof _definition.GraphQLNonNull) {
context.reportError(
new _error.GraphQLError(missingDirectiveArgMessage(node.name.value, argDef.name, argDef.type),
[node]))
}
})
}
}
}
}
/***/
}),
/* 72 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.noSubselectionAllowedMessage = noSubselectionAllowedMessage
exports.requiredSubselectionMessage = requiredSubselectionMessage
exports.ScalarLeafs = ScalarLeafs
var _error = __webpack_require__(0)
var _definition = __webpack_require__(1)
function noSubselectionAllowedMessage(fieldName, type) {
return 'Field "' + fieldName + '" must not have a selection since ' + ('type "' + String(type)
+ '" has no subfields.')
}
/**
* Copyright (c) 2015, 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.
*/
function requiredSubselectionMessage(fieldName, type) {
return 'Field "' + fieldName + '" of type "' + String(type) + '" must have a '
+ ('selection of subfields. Did you mean "' + fieldName + ' { ... }"?')
}
/**
* Scalar leafs
*
* A GraphQL document is valid only if all leaf fields (fields without
* sub selections) are of scalar or enum types.
*/
function ScalarLeafs(context) {
return {
Field: function Field(node) {
var type = context.getType()
if (type) {
if ((0, _definition.isLeafType)(type)) {
if (node.selectionSet) {
context.reportError(new _error.GraphQLError(noSubselectionAllowedMessage(node.name.value, type),
[node.selectionSet]))
}
} else if (!node.selectionSet) {
context.reportError(
new _error.GraphQLError(requiredSubselectionMessage(node.name.value, type), [node]))
}
}
}
}
}
/***/
}),
/* 73 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.duplicateArgMessage = duplicateArgMessage
exports.UniqueArgumentNames = UniqueArgumentNames
var _error = __webpack_require__(0)
/**
* Copyright (c) 2015, 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.
*/
function duplicateArgMessage(argName) {
return 'There can be only one argument named "' + argName + '".'
}
/**
* Unique argument names
*
* A GraphQL field or directive is only valid if all supplied arguments are
* uniquely named.
*/
function UniqueArgumentNames(context) {
var knownArgNames = Object.create(null)
return {
Field: function Field() {
knownArgNames = Object.create(null)
},
Directive: function Directive() {
knownArgNames = Object.create(null)
},
Argument: function Argument(node) {
var argName = node.name.value
if (knownArgNames[argName]) {
context.reportError(
new _error.GraphQLError(duplicateArgMessage(argName), [knownArgNames[argName], node.name]))
} else {
knownArgNames[argName] = node.name
}
return false
}
}
}
/***/
}),
/* 74 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.duplicateDirectiveMessage = duplicateDirectiveMessage
exports.UniqueDirectivesPerLocation = UniqueDirectivesPerLocation
var _error = __webpack_require__(0)
/**
* Copyright (c) 2015, 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.
*/
function duplicateDirectiveMessage(directiveName) {
return 'The directive "' + directiveName + '" can only be used once at ' + 'this location.'
}
/**
* Unique directive names per location
*
* A GraphQL document is only valid if all directives at a given location
* are uniquely named.
*/
function UniqueDirectivesPerLocation(context) {
return {
// Many different AST nodes may contain directives. Rather than listing
// them all, just listen for entering any node, and check to see if it
// defines any directives.
enter: function enter(node) {
if (node.directives) {
(function() {
var knownDirectives = Object.create(null)
node.directives.forEach(function(directive) {
var directiveName = directive.name.value
if (knownDirectives[directiveName]) {
context.reportError(new _error.GraphQLError(duplicateDirectiveMessage(directiveName),
[knownDirectives[directiveName], directive]))
} else {
knownDirectives[directiveName] = directive
}
})
})()
}
}
}
}
/***/
}),
/* 75 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.duplicateFragmentNameMessage = duplicateFragmentNameMessage
exports.UniqueFragmentNames = UniqueFragmentNames
var _error = __webpack_require__(0)
/**
* Copyright (c) 2015, 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.
*/
function duplicateFragmentNameMessage(fragName) {
return 'There can only be one fragment named "' + fragName + '".'
}
/**
* Unique fragment names
*
* A GraphQL document is only valid if all defined fragments have unique names.
*/
function UniqueFragmentNames(context) {
var knownFragmentNames = Object.create(null)
return {
OperationDefinition: function OperationDefinition() {
return false
},
FragmentDefinition: function FragmentDefinition(node) {
var fragmentName = node.name.value
if (knownFragmentNames[fragmentName]) {
context.reportError(new _error.GraphQLError(duplicateFragmentNameMessage(fragmentName),
[knownFragmentNames[fragmentName], node.name]))
} else {
knownFragmentNames[fragmentName] = node.name
}
return false
}
}
}
/***/
}),
/* 76 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.duplicateInputFieldMessage = duplicateInputFieldMessage
exports.UniqueInputFieldNames = UniqueInputFieldNames
var _error = __webpack_require__(0)
/**
* Copyright (c) 2015, 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.
*/
function duplicateInputFieldMessage(fieldName) {
return 'There can be only one input field named "' + fieldName + '".'
}
/**
* Unique input field names
*
* A GraphQL input object value is only valid if all supplied fields are
* uniquely named.
*/
function UniqueInputFieldNames(context) {
var knownNameStack = []
var knownNames = Object.create(null)
return {
ObjectValue: {
enter: function enter() {
knownNameStack.push(knownNames)
knownNames = Object.create(null)
},
leave: function leave() {
knownNames = knownNameStack.pop()
}
},
ObjectField: function ObjectField(node) {
var fieldName = node.name.value
if (knownNames[fieldName]) {
context.reportError(
new _error.GraphQLError(duplicateInputFieldMessage(fieldName), [knownNames[fieldName], node.name]))
} else {
knownNames[fieldName] = node.name
}
return false
}
}
}
/***/
}),
/* 77 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.duplicateOperationNameMessage = duplicateOperationNameMessage
exports.UniqueOperationNames = UniqueOperationNames
var _error = __webpack_require__(0)
/**
* Copyright (c) 2015, 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.
*/
function duplicateOperationNameMessage(operationName) {
return 'There can only be one operation named "' + operationName + '".'
}
/**
* Unique operation names
*
* A GraphQL document is only valid if all defined operations have unique names.
*/
function UniqueOperationNames(context) {
var knownOperationNames = Object.create(null)
return {
OperationDefinition: function OperationDefinition(node) {
var operationName = node.name
if (operationName) {
if (knownOperationNames[operationName.value]) {
context.reportError(new _error.GraphQLError(duplicateOperationNameMessage(operationName.value),
[knownOperationNames[operationName.value], operationName]))
} else {
knownOperationNames[operationName.value] = operationName
}
}
return false
},
FragmentDefinition: function FragmentDefinition() {
return false
}
}
}
/***/
}),
/* 78 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.duplicateVariableMessage = duplicateVariableMessage
exports.UniqueVariableNames = UniqueVariableNames
var _error = __webpack_require__(0)
function duplicateVariableMessage(variableName) {
return 'There can be only one variable named "' + variableName + '".'
}
/**
* Unique variable names
*
* A GraphQL operation is only valid if all its variables are uniquely named.
*/
/**
* Copyright (c) 2015, 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.
*/
function UniqueVariableNames(context) {
var knownVariableNames = Object.create(null)
return {
OperationDefinition: function OperationDefinition() {
knownVariableNames = Object.create(null)
},
VariableDefinition: function VariableDefinition(node) {
var variableName = node.variable.name.value
if (knownVariableNames[variableName]) {
context.reportError(new _error.GraphQLError(duplicateVariableMessage(variableName),
[knownVariableNames[variableName], node.variable.name]))
} else {
knownVariableNames[variableName] = node.variable.name
}
}
}
}
/***/
}),
/* 79 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.nonInputTypeOnVarMessage = nonInputTypeOnVarMessage
exports.VariablesAreInputTypes = VariablesAreInputTypes
var _error = __webpack_require__(0)
var _printer = __webpack_require__(4)
var _definition = __webpack_require__(1)
var _typeFromAST = __webpack_require__(9)
function nonInputTypeOnVarMessage(variableName, typeName) {
return 'Variable "$' + variableName + '" cannot be non-input type "' + typeName + '".'
}
/**
* Variables are input types
*
* A GraphQL operation is only valid if all the variables it defines are of
* input types (scalar, enum, or input object).
*/
/**
* Copyright (c) 2015, 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.
*/
function VariablesAreInputTypes(context) {
return {
VariableDefinition: function VariableDefinition(node) {
var type = (0, _typeFromAST.typeFromAST)(context.getSchema(), node.type)
// If the variable type is not an input type, return an error.
if (type && !(0, _definition.isInputType)(type)) {
var variableName = node.variable.name.value
context.reportError(
new _error.GraphQLError(nonInputTypeOnVarMessage(variableName, (0, _printer.print)(node.type)),
[node.type]))
}
}
}
}
/***/
}),
/* 80 */
/***/ (function(module, exports, __webpack_require__) {
"use strict"
Object.defineProperty(exports, "__esModule", {
value: true
})
exports.badVarPosMessage = badVarPosMessage
exports.VariablesInAllowedPosition = VariablesInAllowedPosition
var _error = __webpack_require__(0)
var _definition = __webpack_require__(1)
var _typeComparators = __webpack_require__(19)
var _typeFromAST = __webpack_require__(9)
function badVarPosMessage(varName, varType, expectedType) {
return 'Variable "$' + varName + '" of type "' + String(varType) + '" used in ' + ('position expecting type "'
+ String(expectedType) + '".')
}
/**
* Variables passed to field arguments conform to type
*/
/**
* Copyright (c) 2015, 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.
*/
function VariablesInAllowedPosition(context) {
var varDefMap = Object.create(null)
return {
OperationDefinition: {
enter: function enter() {
varDefMap = Object.create(null)
},
leave: function leave(operation) {
var usages = context.getRecursiveVariableUsages(operation)
usages.forEach(function(_ref) {
var node = _ref.node,
type = _ref.type
var varName = node.name.value
var varDef = varDefMap[varName]
if (varDef && type) {
// A var type is allowed if it is the same or more strict (e.g. is
// a subtype of) than the expected type. It can be more strict if
// the variable type is non-null when the expected type is nullable.
// If both are list types, the variable item type can be more strict
// than the expected item type (contravariant).
var schema = context.getSchema()
var varType = (0, _typeFromAST.typeFromAST)(schema, varDef.type)
if (varType && !(0, _typeComparators.isTypeSubTypeOf)(schema, effectiveType(varType, varDef),
type)) {
context.reportError(
new _error.GraphQLError(badVarPosMessage(varName, varType, type), [varDef, node]));
}
}
});
}
},
VariableDefinition: function VariableDefinition(node) {
varDefMap[node.variable.name.value] = node;
}
};
}
// If a variable definition has a default value, it's effectively non-null.
function effectiveType(varType, varDef) {
return !varDef.defaultValue || varType instanceof _definition.GraphQLNonNull ? varType
: new _definition.GraphQLNonNull(varType);
}
/***/
})
/******/]);
© 2015 - 2024 Weber Informatics LLC | Privacy Policy