diff --git a/graphiql-spring-boot-autoconfigure/src/main/resources/graphiql.html b/graphiql-spring-boot-autoconfigure/src/main/resources/graphiql.html index a6d3da1f..0c54a916 100644 --- a/graphiql-spring-boot-autoconfigure/src/main/resources/graphiql.html +++ b/graphiql-spring-boot-autoconfigure/src/main/resources/graphiql.html @@ -31,8 +31,8 @@ - - + +
diff --git a/graphiql-spring-boot-autoconfigure/src/main/resources/static/vendor/graphiql-subscriptions-fetcher-browser-client-0.0.2.js b/graphiql-spring-boot-autoconfigure/src/main/resources/static/vendor/graphiql-subscriptions-fetcher-browser-client-0.0.2.js new file mode 100644 index 00000000..c6eb3714 --- /dev/null +++ b/graphiql-spring-boot-autoconfigure/src/main/resources/static/vendor/graphiql-subscriptions-fetcher-browser-client-0.0.2.js @@ -0,0 +1,13515 @@ +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); +} + +/***/ }) +/******/ ]); \ No newline at end of file diff --git a/graphiql-spring-boot-autoconfigure/src/main/resources/static/vendor/subscriptions-transport-ws-browser-client-0.8.3.js b/graphiql-spring-boot-autoconfigure/src/main/resources/static/vendor/subscriptions-transport-ws-browser-client-0.8.3.js new file mode 100644 index 00000000..273200b7 --- /dev/null +++ b/graphiql-spring-boot-autoconfigure/src/main/resources/static/vendor/subscriptions-transport-ws-browser-client-0.8.3.js @@ -0,0 +1,3000 @@ +var SubscriptionsTransportWs = +/******/ (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; +/******/ +/******/ // 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 = 2); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ (function(module, exports) { + +var g; + +// This works in non-strict mode +g = (function() { + return this; +})(); + +try { + // This works if eval is allowed (see CSP) + g = g || Function("return this")() || (1,eval)("this"); +} catch(e) { + // This works if the window reference is available + if(typeof window === "object") + g = window; +} + +// g can still be undefined, but nothing to do about it... +// We return undefined, instead of nothing here, so it's +// easier to handle this case. if(!global) { ...} + +module.exports = g; + + +/***/ }), +/* 1 */ +/***/ (function(module, exports) { + +// shim for using process in browser +var process = module.exports = {}; + +// cached from whatever global is present so that test runners that stub it +// don't break things. But we need to wrap it in a try catch in case it is +// wrapped in strict mode code which doesn't define any globals. It's inside a +// function because try/catches deoptimize in certain engines. + +var cachedSetTimeout; +var cachedClearTimeout; + +function defaultSetTimout() { + throw new Error('setTimeout has not been defined'); +} +function defaultClearTimeout () { + throw new Error('clearTimeout has not been defined'); +} +(function () { + try { + if (typeof setTimeout === 'function') { + cachedSetTimeout = setTimeout; + } else { + cachedSetTimeout = defaultSetTimout; + } + } catch (e) { + cachedSetTimeout = defaultSetTimout; + } + try { + if (typeof clearTimeout === 'function') { + cachedClearTimeout = clearTimeout; + } else { + cachedClearTimeout = defaultClearTimeout; + } + } catch (e) { + cachedClearTimeout = defaultClearTimeout; + } +} ()) +function runTimeout(fun) { + if (cachedSetTimeout === setTimeout) { + //normal enviroments in sane situations + return setTimeout(fun, 0); + } + // if setTimeout wasn't available but was latter defined + if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { + cachedSetTimeout = setTimeout; + return setTimeout(fun, 0); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedSetTimeout(fun, 0); + } catch(e){ + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedSetTimeout.call(null, fun, 0); + } catch(e){ + // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error + return cachedSetTimeout.call(this, fun, 0); + } + } + + +} +function runClearTimeout(marker) { + if (cachedClearTimeout === clearTimeout) { + //normal enviroments in sane situations + return clearTimeout(marker); + } + // if clearTimeout wasn't available but was latter defined + if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { + cachedClearTimeout = clearTimeout; + return clearTimeout(marker); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedClearTimeout(marker); + } catch (e){ + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedClearTimeout.call(null, marker); + } catch (e){ + // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. + // Some versions of I.E. have different rules for clearTimeout vs setTimeout + return cachedClearTimeout.call(this, marker); + } + } + + + +} +var queue = []; +var draining = false; +var currentQueue; +var queueIndex = -1; + +function cleanUpNextTick() { + if (!draining || !currentQueue) { + return; + } + draining = false; + if (currentQueue.length) { + queue = currentQueue.concat(queue); + } else { + queueIndex = -1; + } + if (queue.length) { + drainQueue(); + } +} + +function drainQueue() { + if (draining) { + return; + } + var timeout = runTimeout(cleanUpNextTick); + draining = true; + + var len = queue.length; + while(len) { + currentQueue = queue; + queue = []; + while (++queueIndex < len) { + if (currentQueue) { + currentQueue[queueIndex].run(); + } + } + queueIndex = -1; + len = queue.length; + } + currentQueue = null; + draining = false; + runClearTimeout(timeout); +} + +process.nextTick = function (fun) { + var args = new Array(arguments.length - 1); + if (arguments.length > 1) { + for (var i = 1; i < arguments.length; i++) { + args[i - 1] = arguments[i]; + } + } + queue.push(new Item(fun, args)); + if (queue.length === 1 && !draining) { + runTimeout(drainQueue); + } +}; + +// v8 likes predictible objects +function Item(fun, array) { + this.fun = fun; + this.array = array; +} +Item.prototype.run = function () { + this.fun.apply(null, this.array); +}; +process.title = 'browser'; +process.browser = true; +process.env = {}; +process.argv = []; +process.version = ''; // empty string to avoid regexp issues +process.versions = {}; + +function noop() {} + +process.on = noop; +process.addListener = noop; +process.once = noop; +process.off = noop; +process.removeListener = noop; +process.removeAllListeners = noop; +process.emit = noop; +process.prependListener = noop; +process.prependOnceListener = noop; + +process.listeners = function (name) { return [] } + +process.binding = function (name) { + throw new Error('process.binding is not supported'); +}; + +process.cwd = function () { return '/' }; +process.chdir = function (dir) { + throw new Error('process.chdir is not supported'); +}; +process.umask = function() { return 0; }; + + +/***/ }), +/* 2 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/* WEBPACK VAR INJECTION */(function(global, process) { +var __assign = (this && this.__assign) || Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; +}; +function __export(m) { + for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; +} +Object.defineProperty(exports, "__esModule", { value: true }); +var _global = typeof global !== 'undefined' ? global : (typeof window !== 'undefined' ? window : {}); +var NativeWebSocket = _global.WebSocket || _global.MozWebSocket; +var Backoff = __webpack_require__(3); +var eventemitter3_1 = __webpack_require__(4); +var isString = __webpack_require__(5); +var isObject = __webpack_require__(6); +var printer_1 = __webpack_require__(7); +var getOperationAST_1 = __webpack_require__(9); +var symbol_observable_1 = __webpack_require__(11); +var protocol_1 = __webpack_require__(15); +var defaults_1 = __webpack_require__(16); +var message_types_1 = __webpack_require__(17); +__export(__webpack_require__(18)); +var SubscriptionClient = (function () { + function SubscriptionClient(url, options, webSocketImpl) { + var _a = (options || {}), _b = _a.connectionCallback, connectionCallback = _b === void 0 ? undefined : _b, _c = _a.connectionParams, connectionParams = _c === void 0 ? {} : _c, _d = _a.timeout, timeout = _d === void 0 ? defaults_1.WS_TIMEOUT : _d, _e = _a.reconnect, reconnect = _e === void 0 ? false : _e, _f = _a.reconnectionAttempts, reconnectionAttempts = _f === void 0 ? Infinity : _f, _g = _a.lazy, lazy = _g === void 0 ? false : _g; + this.wsImpl = webSocketImpl || NativeWebSocket; + if (!this.wsImpl) { + throw new Error('Unable to find native implementation, or alternative implementation for WebSocket!'); + } + this.connectionParams = connectionParams; + this.connectionCallback = connectionCallback; + this.url = url; + this.operations = {}; + this.nextOperationId = 0; + this.wsTimeout = timeout; + this.unsentMessagesQueue = []; + this.reconnect = reconnect; + this.reconnecting = false; + this.reconnectionAttempts = reconnectionAttempts; + this.lazy = !!lazy; + this.closedByUser = false; + this.backoff = new Backoff({ jitter: 0.5 }); + this.eventEmitter = new eventemitter3_1.EventEmitter(); + this.middlewares = []; + this.client = null; + this.maxConnectTimeGenerator = this.createMaxConnectTimeGenerator(); + if (!this.lazy) { + this.connect(); + } + } + Object.defineProperty(SubscriptionClient.prototype, "status", { + get: function () { + if (this.client === null) { + return this.wsImpl.CLOSED; + } + return this.client.readyState; + }, + enumerable: true, + configurable: true + }); + SubscriptionClient.prototype.close = function (isForced, closedByUser) { + if (isForced === void 0) { isForced = true; } + if (closedByUser === void 0) { closedByUser = true; } + if (this.client !== null) { + this.closedByUser = closedByUser; + if (isForced) { + this.clearCheckConnectionInterval(); + this.clearMaxConnectTimeout(); + this.clearTryReconnectTimeout(); + this.unsubscribeAll(); + this.sendMessage(undefined, message_types_1.default.GQL_CONNECTION_TERMINATE, null); + } + this.client.close(); + this.client = null; + this.eventEmitter.emit('disconnected'); + if (!isForced) { + this.tryReconnect(); + } + } + }; + SubscriptionClient.prototype.request = function (request) { + var getObserver = this.getObserver.bind(this); + var executeOperation = this.executeOperation.bind(this); + var unsubscribe = this.unsubscribe.bind(this); + var opId; + return _a = {}, + _a[symbol_observable_1.default] = function () { + return this; + }, + _a.subscribe = function (observerOrNext, onError, onComplete) { + var observer = getObserver(observerOrNext, onError, onComplete); + opId = executeOperation({ + query: request.query, + variables: request.variables, + operationName: request.operationName, + }, function (error, result) { + if (error === null && result === null) { + if (observer.complete) { + observer.complete(); + } + } + else if (error) { + if (observer.error) { + observer.error(error[0]); + } + } + else { + if (observer.next) { + observer.next(result); + } + } + }); + return { + unsubscribe: function () { + if (opId) { + unsubscribe(opId); + opId = null; + } + }, + }; + }, + _a; + var _a; + }; + SubscriptionClient.prototype.query = function (options) { + var _this = this; + return new Promise(function (resolve, reject) { + var handler = function (error, result) { + if (result) { + resolve(result); + } + else { + reject(error); + } + }; + _this.executeOperation(options, handler); + }); + }; + SubscriptionClient.prototype.subscribe = function (options, handler) { + var legacyHandler = function (error, result) { + var operationPayloadData = result && result.data || null; + var operationPayloadErrors = result && result.errors || null; + if (error) { + operationPayloadErrors = error; + operationPayloadData = null; + } + if (error !== null || result !== null) { + handler(operationPayloadErrors, operationPayloadData); + } + }; + if (this.client === null) { + this.connect(); + } + if (!handler) { + throw new Error('Must provide an handler.'); + } + return this.executeOperation(options, legacyHandler); + }; + SubscriptionClient.prototype.on = function (eventName, callback, context) { + var handler = this.eventEmitter.on(eventName, callback, context); + return function () { + handler.off(eventName, callback, context); + }; + }; + SubscriptionClient.prototype.onConnect = function (callback, context) { + this.logWarningOnNonProductionEnv('This method will become deprecated in the next release. ' + + 'You can use onConnecting and onConnected instead.'); + return this.onConnecting(callback, context); + }; + SubscriptionClient.prototype.onDisconnect = function (callback, context) { + this.logWarningOnNonProductionEnv('This method will become deprecated in the next release. ' + + 'You can use onDisconnected instead.'); + return this.onDisconnected(callback, context); + }; + SubscriptionClient.prototype.onReconnect = function (callback, context) { + this.logWarningOnNonProductionEnv('This method will become deprecated in the next release. ' + + 'You can use onReconnecting and onReconnected instead.'); + return this.onReconnecting(callback, context); + }; + SubscriptionClient.prototype.onConnected = function (callback, context) { + return this.on('connected', callback, context); + }; + SubscriptionClient.prototype.onConnecting = function (callback, context) { + return this.on('connecting', callback, context); + }; + SubscriptionClient.prototype.onDisconnected = function (callback, context) { + return this.on('disconnected', callback, context); + }; + SubscriptionClient.prototype.onReconnected = function (callback, context) { + return this.on('reconnected', callback, context); + }; + SubscriptionClient.prototype.onReconnecting = function (callback, context) { + return this.on('reconnecting', callback, context); + }; + SubscriptionClient.prototype.unsubscribe = function (opId) { + if (this.operations[opId]) { + delete this.operations[opId]; + this.sendMessage(opId, message_types_1.default.GQL_STOP, undefined); + } + }; + SubscriptionClient.prototype.unsubscribeAll = function () { + var _this = this; + Object.keys(this.operations).forEach(function (subId) { + _this.unsubscribe(subId); + }); + }; + SubscriptionClient.prototype.applyMiddlewares = function (options) { + var _this = this; + return new Promise(function (resolve, reject) { + var queue = function (funcs, scope) { + var next = function (error) { + if (error) { + reject(error); + } + else { + if (funcs.length > 0) { + var f = funcs.shift(); + if (f) { + f.applyMiddleware.apply(scope, [options, next]); + } + } + else { + resolve(options); + } + } + }; + next(); + }; + queue(_this.middlewares.slice(), _this); + }); + }; + SubscriptionClient.prototype.use = function (middlewares) { + var _this = this; + middlewares.map(function (middleware) { + if (typeof middleware.applyMiddleware === 'function') { + _this.middlewares.push(middleware); + } + else { + throw new Error('Middleware must implement the applyMiddleware function.'); + } + }); + return this; + }; + SubscriptionClient.prototype.executeOperation = function (options, handler) { + var _this = this; + var opId = this.generateOperationId(); + this.operations[opId] = { options: options, handler: handler }; + this.applyMiddlewares(options) + .then(function (processedOptions) { + _this.checkOperationOptions(processedOptions, handler); + if (_this.operations[opId]) { + _this.operations[opId] = { options: processedOptions, handler: handler }; + _this.sendMessage(opId, message_types_1.default.GQL_START, processedOptions); + } + }) + .catch(function (error) { + _this.unsubscribe(opId); + handler(_this.formatErrors(error)); + }); + return opId; + }; + SubscriptionClient.prototype.getObserver = function (observerOrNext, error, complete) { + if (typeof observerOrNext === 'function') { + return { + next: function (v) { return observerOrNext(v); }, + error: function (e) { return error && error(e); }, + complete: function () { return complete && complete(); }, + }; + } + return observerOrNext; + }; + SubscriptionClient.prototype.createMaxConnectTimeGenerator = function () { + var minValue = 1000; + var maxValue = this.wsTimeout; + return new Backoff({ + min: minValue, + max: maxValue, + factor: 1.2, + }); + }; + SubscriptionClient.prototype.clearCheckConnectionInterval = function () { + if (this.checkConnectionIntervalId) { + clearInterval(this.checkConnectionIntervalId); + this.checkConnectionIntervalId = null; + } + }; + SubscriptionClient.prototype.clearMaxConnectTimeout = function () { + if (this.maxConnectTimeoutId) { + clearTimeout(this.maxConnectTimeoutId); + this.maxConnectTimeoutId = null; + } + }; + SubscriptionClient.prototype.clearTryReconnectTimeout = function () { + if (this.tryReconnectTimeoutId) { + clearTimeout(this.tryReconnectTimeoutId); + this.tryReconnectTimeoutId = null; + } + }; + SubscriptionClient.prototype.logWarningOnNonProductionEnv = function (warning) { + if (process && process.env && process.env.NODE_ENV !== 'production') { + console.warn(warning); + } + }; + SubscriptionClient.prototype.checkOperationOptions = function (options, handler) { + var query = options.query, variables = options.variables, operationName = options.operationName; + if (!query) { + throw new Error('Must provide a query.'); + } + if (!handler) { + throw new Error('Must provide an handler.'); + } + if ((!isString(query) && !getOperationAST_1.getOperationAST(query, operationName)) || + (operationName && !isString(operationName)) || + (variables && !isObject(variables))) { + throw new Error('Incorrect option types. query must be a string or a document,' + + '`operationName` must be a string, and `variables` must be an object.'); + } + }; + SubscriptionClient.prototype.buildMessage = function (id, type, payload) { + var payloadToReturn = payload && payload.query ? __assign({}, payload, { query: typeof payload.query === 'string' ? payload.query : printer_1.print(payload.query) }) : + payload; + return { + id: id, + type: type, + payload: payloadToReturn, + }; + }; + SubscriptionClient.prototype.formatErrors = function (errors) { + if (Array.isArray(errors)) { + return errors; + } + if (errors && errors.errors) { + return this.formatErrors(errors.errors); + } + if (errors && errors.message) { + return [errors]; + } + return [{ + name: 'FormatedError', + message: 'Unknown error', + originalError: errors, + }]; + }; + SubscriptionClient.prototype.sendMessage = function (id, type, payload) { + this.sendMessageRaw(this.buildMessage(id, type, payload)); + }; + SubscriptionClient.prototype.sendMessageRaw = function (message) { + switch (this.status) { + case this.wsImpl.OPEN: + var serializedMessage = JSON.stringify(message); + var parsedMessage = void 0; + try { + parsedMessage = JSON.parse(serializedMessage); + } + catch (e) { + throw new Error("Message must be JSON-serializable. Got: " + message); + } + this.client.send(serializedMessage); + break; + case this.wsImpl.CONNECTING: + this.unsentMessagesQueue.push(message); + break; + default: + if (!this.reconnecting) { + throw new Error('A message was not sent because socket is not connected, is closing or ' + + 'is already closed. Message was: ' + JSON.stringify(message)); + } + } + }; + SubscriptionClient.prototype.generateOperationId = function () { + return String(++this.nextOperationId); + }; + SubscriptionClient.prototype.tryReconnect = function () { + var _this = this; + if (!this.reconnect || this.backoff.attempts >= this.reconnectionAttempts) { + return; + } + if (!this.reconnecting) { + Object.keys(this.operations).forEach(function (key) { + _this.unsentMessagesQueue.push(_this.buildMessage(key, message_types_1.default.GQL_START, _this.operations[key].options)); + }); + this.reconnecting = true; + } + this.clearTryReconnectTimeout(); + var delay = this.backoff.duration(); + this.tryReconnectTimeoutId = setTimeout(function () { + _this.connect(); + }, delay); + }; + SubscriptionClient.prototype.flushUnsentMessagesQueue = function () { + var _this = this; + this.unsentMessagesQueue.forEach(function (message) { + _this.sendMessageRaw(message); + }); + this.unsentMessagesQueue = []; + }; + SubscriptionClient.prototype.checkConnection = function () { + if (this.wasKeepAliveReceived) { + this.wasKeepAliveReceived = false; + return; + } + if (!this.reconnecting) { + this.close(false, true); + } + }; + SubscriptionClient.prototype.checkMaxConnectTimeout = function () { + var _this = this; + this.clearMaxConnectTimeout(); + this.maxConnectTimeoutId = setTimeout(function () { + if (_this.status !== _this.wsImpl.OPEN) { + _this.close(false, true); + } + }, this.maxConnectTimeGenerator.duration()); + }; + SubscriptionClient.prototype.connect = function () { + var _this = this; + this.client = new this.wsImpl(this.url, protocol_1.GRAPHQL_WS); + this.checkMaxConnectTimeout(); + this.client.onopen = function () { + _this.clearMaxConnectTimeout(); + _this.closedByUser = false; + _this.eventEmitter.emit(_this.reconnecting ? 'reconnecting' : 'connecting'); + var payload = typeof _this.connectionParams === 'function' ? _this.connectionParams() : _this.connectionParams; + _this.sendMessage(undefined, message_types_1.default.GQL_CONNECTION_INIT, payload); + _this.flushUnsentMessagesQueue(); + }; + this.client.onclose = function () { + if (!_this.closedByUser) { + _this.close(false, false); + } + }; + this.client.onerror = function () { + }; + this.client.onmessage = function (_a) { + var data = _a.data; + _this.processReceivedData(data); + }; + }; + SubscriptionClient.prototype.processReceivedData = function (receivedData) { + var parsedMessage; + var opId; + try { + parsedMessage = JSON.parse(receivedData); + opId = parsedMessage.id; + } + catch (e) { + throw new Error("Message must be JSON-parseable. Got: " + receivedData); + } + if ([message_types_1.default.GQL_DATA, + message_types_1.default.GQL_COMPLETE, + message_types_1.default.GQL_ERROR, + ].indexOf(parsedMessage.type) !== -1 && !this.operations[opId]) { + this.unsubscribe(opId); + return; + } + switch (parsedMessage.type) { + case message_types_1.default.GQL_CONNECTION_ERROR: + if (this.connectionCallback) { + this.connectionCallback(parsedMessage.payload); + } + break; + case message_types_1.default.GQL_CONNECTION_ACK: + this.eventEmitter.emit(this.reconnecting ? 'reconnected' : 'connected'); + this.reconnecting = false; + this.backoff.reset(); + this.maxConnectTimeGenerator.reset(); + if (this.connectionCallback) { + this.connectionCallback(); + } + break; + case message_types_1.default.GQL_COMPLETE: + this.operations[opId].handler(null, null); + delete this.operations[opId]; + break; + case message_types_1.default.GQL_ERROR: + this.operations[opId].handler(this.formatErrors(parsedMessage.payload), null); + delete this.operations[opId]; + break; + case message_types_1.default.GQL_DATA: + var parsedPayload = !parsedMessage.payload.errors ? + parsedMessage.payload : __assign({}, parsedMessage.payload, { errors: this.formatErrors(parsedMessage.payload.errors) }); + this.operations[opId].handler(null, parsedPayload); + break; + case message_types_1.default.GQL_CONNECTION_KEEP_ALIVE: + var firstKA = typeof this.wasKeepAliveReceived === 'undefined'; + this.wasKeepAliveReceived = true; + if (firstKA) { + this.checkConnection(); + } + if (this.checkConnectionIntervalId) { + clearInterval(this.checkConnectionIntervalId); + this.checkConnection(); + } + this.checkConnectionIntervalId = setInterval(this.checkConnection.bind(this), this.wsTimeout); + break; + default: + throw new Error('Invalid message type!'); + } + }; + return SubscriptionClient; +}()); +exports.SubscriptionClient = SubscriptionClient; +//# sourceMappingURL=client.js.map +/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(1))) + +/***/ }), +/* 3 */ +/***/ (function(module, exports) { + + +/** + * Expose `Backoff`. + */ + +module.exports = Backoff; + +/** + * Initialize backoff timer with `opts`. + * + * - `min` initial timeout in milliseconds [100] + * - `max` max timeout [10000] + * - `jitter` [0] + * - `factor` [2] + * + * @param {Object} opts + * @api public + */ + +function Backoff(opts) { + opts = opts || {}; + this.ms = opts.min || 100; + this.max = opts.max || 10000; + this.factor = opts.factor || 2; + this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0; + this.attempts = 0; +} + +/** + * Return the backoff duration. + * + * @return {Number} + * @api public + */ + +Backoff.prototype.duration = function(){ + var ms = this.ms * Math.pow(this.factor, this.attempts++); + if (this.jitter) { + var rand = Math.random(); + var deviation = Math.floor(rand * this.jitter * ms); + ms = (Math.floor(rand * 10) & 1) == 0 ? ms - deviation : ms + deviation; + } + return Math.min(ms, this.max) | 0; +}; + +/** + * Reset the number of attempts. + * + * @api public + */ + +Backoff.prototype.reset = function(){ + this.attempts = 0; +}; + +/** + * Set the minimum duration + * + * @api public + */ + +Backoff.prototype.setMin = function(min){ + this.ms = min; +}; + +/** + * Set the maximum duration + * + * @api public + */ + +Backoff.prototype.setMax = function(max){ + this.max = max; +}; + +/** + * Set the jitter + * + * @api public + */ + +Backoff.prototype.setJitter = function(jitter){ + this.jitter = jitter; +}; + + + +/***/ }), +/* 4 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var has = Object.prototype.hasOwnProperty + , prefix = '~'; + +/** + * Constructor to create a storage for our `EE` objects. + * An `Events` instance is a plain object whose properties are event names. + * + * @constructor + * @api private + */ +function Events() {} + +// +// We try to not inherit from `Object.prototype`. In some engines creating an +// instance in this way is faster than calling `Object.create(null)` directly. +// If `Object.create(null)` is not supported we prefix the event names with a +// character to make sure that the built-in object properties are not +// overridden or used as an attack vector. +// +if (Object.create) { + Events.prototype = Object.create(null); + + // + // This hack is needed because the `__proto__` property is still inherited in + // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5. + // + if (!new Events().__proto__) prefix = false; +} + +/** + * Representation of a single event listener. + * + * @param {Function} fn The listener function. + * @param {Mixed} context The context to invoke the listener with. + * @param {Boolean} [once=false] Specify if the listener is a one-time listener. + * @constructor + * @api private + */ +function EE(fn, context, once) { + this.fn = fn; + this.context = context; + this.once = once || false; +} + +/** + * Minimal `EventEmitter` interface that is molded against the Node.js + * `EventEmitter` interface. + * + * @constructor + * @api public + */ +function EventEmitter() { + this._events = new Events(); + this._eventsCount = 0; +} + +/** + * Return an array listing the events for which the emitter has registered + * listeners. + * + * @returns {Array} + * @api public + */ +EventEmitter.prototype.eventNames = function eventNames() { + var names = [] + , events + , name; + + if (this._eventsCount === 0) return names; + + for (name in (events = this._events)) { + if (has.call(events, name)) names.push(prefix ? name.slice(1) : name); + } + + if (Object.getOwnPropertySymbols) { + return names.concat(Object.getOwnPropertySymbols(events)); + } + + return names; +}; + +/** + * Return the listeners registered for a given event. + * + * @param {String|Symbol} event The event name. + * @param {Boolean} exists Only check if there are listeners. + * @returns {Array|Boolean} + * @api public + */ +EventEmitter.prototype.listeners = function listeners(event, exists) { + var evt = prefix ? prefix + event : event + , available = this._events[evt]; + + if (exists) return !!available; + if (!available) return []; + if (available.fn) return [available.fn]; + + for (var i = 0, l = available.length, ee = new Array(l); i < l; i++) { + ee[i] = available[i].fn; + } + + return ee; +}; + +/** + * Calls each of the listeners registered for a given event. + * + * @param {String|Symbol} event The event name. + * @returns {Boolean} `true` if the event had listeners, else `false`. + * @api public + */ +EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) { + var evt = prefix ? prefix + event : event; + + if (!this._events[evt]) return false; + + var listeners = this._events[evt] + , len = arguments.length + , args + , i; + + if (listeners.fn) { + if (listeners.once) this.removeListener(event, listeners.fn, undefined, true); + + switch (len) { + case 1: return listeners.fn.call(listeners.context), true; + case 2: return listeners.fn.call(listeners.context, a1), true; + case 3: return listeners.fn.call(listeners.context, a1, a2), true; + case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true; + case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true; + case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true; + } + + for (i = 1, args = new Array(len -1); i < len; i++) { + args[i - 1] = arguments[i]; + } + + listeners.fn.apply(listeners.context, args); + } else { + var length = listeners.length + , j; + + for (i = 0; i < length; i++) { + if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true); + + switch (len) { + case 1: listeners[i].fn.call(listeners[i].context); break; + case 2: listeners[i].fn.call(listeners[i].context, a1); break; + case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break; + case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break; + default: + if (!args) for (j = 1, args = new Array(len -1); j < len; j++) { + args[j - 1] = arguments[j]; + } + + listeners[i].fn.apply(listeners[i].context, args); + } + } + } + + return true; +}; + +/** + * Add a listener for a given event. + * + * @param {String|Symbol} event The event name. + * @param {Function} fn The listener function. + * @param {Mixed} [context=this] The context to invoke the listener with. + * @returns {EventEmitter} `this`. + * @api public + */ +EventEmitter.prototype.on = function on(event, fn, context) { + var listener = new EE(fn, context || this) + , evt = prefix ? prefix + event : event; + + if (!this._events[evt]) this._events[evt] = listener, this._eventsCount++; + else if (!this._events[evt].fn) this._events[evt].push(listener); + else this._events[evt] = [this._events[evt], listener]; + + return this; +}; + +/** + * Add a one-time listener for a given event. + * + * @param {String|Symbol} event The event name. + * @param {Function} fn The listener function. + * @param {Mixed} [context=this] The context to invoke the listener with. + * @returns {EventEmitter} `this`. + * @api public + */ +EventEmitter.prototype.once = function once(event, fn, context) { + var listener = new EE(fn, context || this, true) + , evt = prefix ? prefix + event : event; + + if (!this._events[evt]) this._events[evt] = listener, this._eventsCount++; + else if (!this._events[evt].fn) this._events[evt].push(listener); + else this._events[evt] = [this._events[evt], listener]; + + return this; +}; + +/** + * Remove the listeners of a given event. + * + * @param {String|Symbol} event The event name. + * @param {Function} fn Only remove the listeners that match this function. + * @param {Mixed} context Only remove the listeners that have this context. + * @param {Boolean} once Only remove one-time listeners. + * @returns {EventEmitter} `this`. + * @api public + */ +EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) { + var evt = prefix ? prefix + event : event; + + if (!this._events[evt]) return this; + if (!fn) { + if (--this._eventsCount === 0) this._events = new Events(); + else delete this._events[evt]; + return this; + } + + var listeners = this._events[evt]; + + if (listeners.fn) { + if ( + listeners.fn === fn + && (!once || listeners.once) + && (!context || listeners.context === context) + ) { + if (--this._eventsCount === 0) this._events = new Events(); + else delete this._events[evt]; + } + } else { + for (var i = 0, events = [], length = listeners.length; i < length; i++) { + if ( + listeners[i].fn !== fn + || (once && !listeners[i].once) + || (context && listeners[i].context !== context) + ) { + events.push(listeners[i]); + } + } + + // + // Reset the array, or remove it completely if we have no more listeners. + // + if (events.length) this._events[evt] = events.length === 1 ? events[0] : events; + else if (--this._eventsCount === 0) this._events = new Events(); + else delete this._events[evt]; + } + + return this; +}; + +/** + * Remove all listeners, or those of the specified event. + * + * @param {String|Symbol} [event] The event name. + * @returns {EventEmitter} `this`. + * @api public + */ +EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) { + var evt; + + if (event) { + evt = prefix ? prefix + event : event; + if (this._events[evt]) { + if (--this._eventsCount === 0) this._events = new Events(); + else delete this._events[evt]; + } + } else { + this._events = new Events(); + this._eventsCount = 0; + } + + return this; +}; + +// +// Alias methods names because people roll like that. +// +EventEmitter.prototype.off = EventEmitter.prototype.removeListener; +EventEmitter.prototype.addListener = EventEmitter.prototype.on; + +// +// This function doesn't apply anymore. +// +EventEmitter.prototype.setMaxListeners = function setMaxListeners() { + return this; +}; + +// +// Expose the prefix. +// +EventEmitter.prefixed = prefix; + +// +// Allow `EventEmitter` to be imported as module namespace. +// +EventEmitter.EventEmitter = EventEmitter; + +// +// Expose the module. +// +if (true) { + module.exports = EventEmitter; +} + + +/***/ }), +/* 5 */ +/***/ (function(module, exports) { + +/** + * lodash 4.0.1 (Custom Build) + * Build: `lodash modularize exports="npm" -o ./` + * Copyright 2012-2016 The Dojo Foundation + * Based on Underscore.js 1.8.3 + * Copyright 2009-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license + */ + +/** `Object#toString` result references. */ +var stringTag = '[object String]'; + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** + * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) + * of values. + */ +var objectToString = objectProto.toString; + +/** + * Checks if `value` is classified as an `Array` object. + * + * @static + * @memberOf _ + * @type Function + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. + * @example + * + * _.isArray([1, 2, 3]); + * // => true + * + * _.isArray(document.body.children); + * // => false + * + * _.isArray('abc'); + * // => false + * + * _.isArray(_.noop); + * // => false + */ +var isArray = Array.isArray; + +/** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ +function isObjectLike(value) { + return !!value && typeof value == 'object'; +} + +/** + * Checks if `value` is classified as a `String` primitive or object. + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. + * @example + * + * _.isString('abc'); + * // => true + * + * _.isString(1); + * // => false + */ +function isString(value) { + return typeof value == 'string' || + (!isArray(value) && isObjectLike(value) && objectToString.call(value) == stringTag); +} + +module.exports = isString; + + +/***/ }), +/* 6 */ +/***/ (function(module, exports) { + +/** + * lodash 3.0.2 (Custom Build) + * Build: `lodash modern modularize exports="npm" -o ./` + * Copyright 2012-2015 The Dojo Foundation + * Based on Underscore.js 1.8.3 + * Copyright 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license + */ + +/** + * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`. + * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(1); + * // => false + */ +function isObject(value) { + // Avoid a V8 JIT bug in Chrome 19-20. + // See https://code.google.com/p/v8/issues/detail?id=2291 for more details. + var type = typeof value; + return !!value && (type == 'object' || type == 'function'); +} + +module.exports = isObject; + + +/***/ }), +/* 7 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.print = print; + +var _visitor = __webpack_require__(8); + +/** + * 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 '); +} + +/***/ }), +/* 8 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.visit = visit; +exports.visitInParallel = visitInParallel; +exports.visitWithTypeInfo = visitWithTypeInfo; +exports.getVisitFn = getVisitFn; +/** + * 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; + } + } + } +} + +/***/ }), +/* 9 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.getOperationAST = getOperationAST; + +var _kinds = __webpack_require__(10); + +/** + * 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. + */ + +/***/ }), +/* 10 */ +/***/ (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'; + +/***/ }), +/* 11 */ +/***/ (function(module, exports, __webpack_require__) { + +module.exports = __webpack_require__(12); + + +/***/ }), +/* 12 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/* WEBPACK VAR INJECTION */(function(global, module) { + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _ponyfill = __webpack_require__(14); + +var _ponyfill2 = _interopRequireDefault(_ponyfill); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + +var root; /* global window */ + + +if (typeof self !== 'undefined') { + root = self; +} else if (typeof window !== 'undefined') { + root = window; +} else if (typeof global !== 'undefined') { + root = global; +} else if (true) { + root = module; +} else { + root = Function('return this')(); +} + +var result = (0, _ponyfill2['default'])(root); +exports['default'] = result; +/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(13)(module))) + +/***/ }), +/* 13 */ +/***/ (function(module, exports) { + +module.exports = function(module) { + if(!module.webpackPolyfill) { + module.deprecate = function() {}; + module.paths = []; + // module.parent = undefined by default + if(!module.children) module.children = []; + Object.defineProperty(module, "loaded", { + enumerable: true, + get: function() { + return module.l; + } + }); + Object.defineProperty(module, "id", { + enumerable: true, + get: function() { + return module.i; + } + }); + module.webpackPolyfill = 1; + } + return module; +}; + + +/***/ }), +/* 14 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports['default'] = symbolObservablePonyfill; +function symbolObservablePonyfill(root) { + var result; + var _Symbol = root.Symbol; + + if (typeof _Symbol === 'function') { + if (_Symbol.observable) { + result = _Symbol.observable; + } else { + result = _Symbol('observable'); + _Symbol.observable = result; + } + } else { + result = '@@observable'; + } + + return result; +}; + +/***/ }), +/* 15 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +var GRAPHQL_WS = 'graphql-ws'; +exports.GRAPHQL_WS = GRAPHQL_WS; +var GRAPHQL_SUBSCRIPTIONS = 'graphql-subscriptions'; +exports.GRAPHQL_SUBSCRIPTIONS = GRAPHQL_SUBSCRIPTIONS; +//# sourceMappingURL=protocol.js.map + +/***/ }), +/* 16 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +var WS_TIMEOUT = 10000; +exports.WS_TIMEOUT = WS_TIMEOUT; +//# sourceMappingURL=defaults.js.map + +/***/ }), +/* 17 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +var MessageTypes = (function () { + function MessageTypes() { + throw new Error('Static Class'); + } + MessageTypes.GQL_CONNECTION_INIT = 'connection_init'; + MessageTypes.GQL_CONNECTION_ACK = 'connection_ack'; + MessageTypes.GQL_CONNECTION_ERROR = 'connection_error'; + MessageTypes.GQL_CONNECTION_KEEP_ALIVE = 'ka'; + MessageTypes.GQL_CONNECTION_TERMINATE = 'connection_terminate'; + MessageTypes.GQL_START = 'start'; + MessageTypes.GQL_DATA = 'data'; + MessageTypes.GQL_ERROR = 'error'; + MessageTypes.GQL_COMPLETE = 'complete'; + MessageTypes.GQL_STOP = 'stop'; + MessageTypes.SUBSCRIPTION_START = 'subscription_start'; + MessageTypes.SUBSCRIPTION_DATA = 'subscription_data'; + MessageTypes.SUBSCRIPTION_SUCCESS = 'subscription_success'; + MessageTypes.SUBSCRIPTION_FAIL = 'subscription_fail'; + MessageTypes.SUBSCRIPTION_END = 'subscription_end'; + MessageTypes.INIT = 'init'; + MessageTypes.INIT_SUCCESS = 'init_success'; + MessageTypes.INIT_FAIL = 'init_fail'; + return MessageTypes; +}()); +exports.default = MessageTypes; +//# sourceMappingURL=message-types.js.map + +/***/ }), +/* 18 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/* WEBPACK VAR INJECTION */(function(process) { +Object.defineProperty(exports, "__esModule", { value: true }); +var assign = __webpack_require__(19); +function addGraphQLSubscriptions(networkInterface, wsClient) { + if (process && process.env && process.env.NODE_ENV !== 'production') { + console.warn('Notice that addGraphQLSubscriptions method will become deprecated in the new package ' + + 'graphql-transport-ws that will be released soon. Keep track for the new hybrid network release here: ' + + 'https://github.com/apollographql/subscriptions-transport-ws/issues/169'); + } + return assign(networkInterface, { + subscribe: function (request, handler) { + return wsClient.subscribe(request, handler); + }, + unsubscribe: function (id) { + wsClient.unsubscribe(id); + }, + }); +} +exports.addGraphQLSubscriptions = addGraphQLSubscriptions; +//# sourceMappingURL=helpers.js.map +/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1))) + +/***/ }), +/* 19 */ +/***/ (function(module, exports) { + +/** + * lodash (Custom Build) + * Build: `lodash modularize exports="npm" -o ./` + * Copyright jQuery Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + */ + +/** Used as references for various `Number` constants. */ +var MAX_SAFE_INTEGER = 9007199254740991; + +/** `Object#toString` result references. */ +var argsTag = '[object Arguments]', + funcTag = '[object Function]', + genTag = '[object GeneratorFunction]'; + +/** Used to detect unsigned integer values. */ +var reIsUint = /^(?:0|[1-9]\d*)$/; + +/** + * A faster alternative to `Function#apply`, this function invokes `func` + * with the `this` binding of `thisArg` and the arguments of `args`. + * + * @private + * @param {Function} func The function to invoke. + * @param {*} thisArg The `this` binding of `func`. + * @param {Array} args The arguments to invoke `func` with. + * @returns {*} Returns the result of `func`. + */ +function apply(func, thisArg, args) { + switch (args.length) { + case 0: return func.call(thisArg); + case 1: return func.call(thisArg, args[0]); + case 2: return func.call(thisArg, args[0], args[1]); + case 3: return func.call(thisArg, args[0], args[1], args[2]); + } + return func.apply(thisArg, args); +} + +/** + * The base implementation of `_.times` without support for iteratee shorthands + * or max array length checks. + * + * @private + * @param {number} n The number of times to invoke `iteratee`. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the array of results. + */ +function baseTimes(n, iteratee) { + var index = -1, + result = Array(n); + + while (++index < n) { + result[index] = iteratee(index); + } + return result; +} + +/** + * Creates a unary function that invokes `func` with its argument transformed. + * + * @private + * @param {Function} func The function to wrap. + * @param {Function} transform The argument transform. + * @returns {Function} Returns the new function. + */ +function overArg(func, transform) { + return function(arg) { + return func(transform(arg)); + }; +} + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ +var objectToString = objectProto.toString; + +/** Built-in value references. */ +var propertyIsEnumerable = objectProto.propertyIsEnumerable; + +/* Built-in method references for those with the same name as other `lodash` methods. */ +var nativeKeys = overArg(Object.keys, Object), + nativeMax = Math.max; + +/** Detect if properties shadowing those on `Object.prototype` are non-enumerable. */ +var nonEnumShadows = !propertyIsEnumerable.call({ 'valueOf': 1 }, 'valueOf'); + +/** + * Creates an array of the enumerable property names of the array-like `value`. + * + * @private + * @param {*} value The value to query. + * @param {boolean} inherited Specify returning inherited property names. + * @returns {Array} Returns the array of property names. + */ +function arrayLikeKeys(value, inherited) { + // Safari 8.1 makes `arguments.callee` enumerable in strict mode. + // Safari 9 makes `arguments.length` enumerable in strict mode. + var result = (isArray(value) || isArguments(value)) + ? baseTimes(value.length, String) + : []; + + var length = result.length, + skipIndexes = !!length; + + for (var key in value) { + if ((inherited || hasOwnProperty.call(value, key)) && + !(skipIndexes && (key == 'length' || isIndex(key, length)))) { + result.push(key); + } + } + return result; +} + +/** + * Assigns `value` to `key` of `object` if the existing value is not equivalent + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * @private + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. + */ +function assignValue(object, key, value) { + var objValue = object[key]; + if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || + (value === undefined && !(key in object))) { + object[key] = value; + } +} + +/** + * The base implementation of `_.keys` which doesn't treat sparse arrays as dense. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ +function baseKeys(object) { + if (!isPrototype(object)) { + return nativeKeys(object); + } + var result = []; + for (var key in Object(object)) { + if (hasOwnProperty.call(object, key) && key != 'constructor') { + result.push(key); + } + } + return result; +} + +/** + * The base implementation of `_.rest` which doesn't validate or coerce arguments. + * + * @private + * @param {Function} func The function to apply a rest parameter to. + * @param {number} [start=func.length-1] The start position of the rest parameter. + * @returns {Function} Returns the new function. + */ +function baseRest(func, start) { + start = nativeMax(start === undefined ? (func.length - 1) : start, 0); + return function() { + var args = arguments, + index = -1, + length = nativeMax(args.length - start, 0), + array = Array(length); + + while (++index < length) { + array[index] = args[start + index]; + } + index = -1; + var otherArgs = Array(start + 1); + while (++index < start) { + otherArgs[index] = args[index]; + } + otherArgs[start] = array; + return apply(func, this, otherArgs); + }; +} + +/** + * Copies properties of `source` to `object`. + * + * @private + * @param {Object} source The object to copy properties from. + * @param {Array} props The property identifiers to copy. + * @param {Object} [object={}] The object to copy properties to. + * @param {Function} [customizer] The function to customize copied values. + * @returns {Object} Returns `object`. + */ +function copyObject(source, props, object, customizer) { + object || (object = {}); + + var index = -1, + length = props.length; + + while (++index < length) { + var key = props[index]; + + var newValue = customizer + ? customizer(object[key], source[key], key, object, source) + : undefined; + + assignValue(object, key, newValue === undefined ? source[key] : newValue); + } + return object; +} + +/** + * Creates a function like `_.assign`. + * + * @private + * @param {Function} assigner The function to assign values. + * @returns {Function} Returns the new assigner function. + */ +function createAssigner(assigner) { + return baseRest(function(object, sources) { + var index = -1, + length = sources.length, + customizer = length > 1 ? sources[length - 1] : undefined, + guard = length > 2 ? sources[2] : undefined; + + customizer = (assigner.length > 3 && typeof customizer == 'function') + ? (length--, customizer) + : undefined; + + if (guard && isIterateeCall(sources[0], sources[1], guard)) { + customizer = length < 3 ? undefined : customizer; + length = 1; + } + object = Object(object); + while (++index < length) { + var source = sources[index]; + if (source) { + assigner(object, source, index, customizer); + } + } + return object; + }); +} + +/** + * Checks if `value` is a valid array-like index. + * + * @private + * @param {*} value The value to check. + * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. + * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. + */ +function isIndex(value, length) { + length = length == null ? MAX_SAFE_INTEGER : length; + return !!length && + (typeof value == 'number' || reIsUint.test(value)) && + (value > -1 && value % 1 == 0 && value < length); +} + +/** + * Checks if the given arguments are from an iteratee call. + * + * @private + * @param {*} value The potential iteratee value argument. + * @param {*} index The potential iteratee index or key argument. + * @param {*} object The potential iteratee object argument. + * @returns {boolean} Returns `true` if the arguments are from an iteratee call, + * else `false`. + */ +function isIterateeCall(value, index, object) { + if (!isObject(object)) { + return false; + } + var type = typeof index; + if (type == 'number' + ? (isArrayLike(object) && isIndex(index, object.length)) + : (type == 'string' && index in object) + ) { + return eq(object[index], value); + } + return false; +} + +/** + * Checks if `value` is likely a prototype object. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. + */ +function isPrototype(value) { + var Ctor = value && value.constructor, + proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto; + + return value === proto; +} + +/** + * Performs a + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * comparison between two values to determine if they are equivalent. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.eq(object, object); + * // => true + * + * _.eq(object, other); + * // => false + * + * _.eq('a', 'a'); + * // => true + * + * _.eq('a', Object('a')); + * // => false + * + * _.eq(NaN, NaN); + * // => true + */ +function eq(value, other) { + return value === other || (value !== value && other !== other); +} + +/** + * Checks if `value` is likely an `arguments` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an `arguments` object, + * else `false`. + * @example + * + * _.isArguments(function() { return arguments; }()); + * // => true + * + * _.isArguments([1, 2, 3]); + * // => false + */ +function isArguments(value) { + // Safari 8.1 makes `arguments.callee` enumerable in strict mode. + return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') && + (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag); +} + +/** + * Checks if `value` is classified as an `Array` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array, else `false`. + * @example + * + * _.isArray([1, 2, 3]); + * // => true + * + * _.isArray(document.body.children); + * // => false + * + * _.isArray('abc'); + * // => false + * + * _.isArray(_.noop); + * // => false + */ +var isArray = Array.isArray; + +/** + * Checks if `value` is array-like. A value is considered array-like if it's + * not a function and has a `value.length` that's an integer greater than or + * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is array-like, else `false`. + * @example + * + * _.isArrayLike([1, 2, 3]); + * // => true + * + * _.isArrayLike(document.body.children); + * // => true + * + * _.isArrayLike('abc'); + * // => true + * + * _.isArrayLike(_.noop); + * // => false + */ +function isArrayLike(value) { + return value != null && isLength(value.length) && !isFunction(value); +} + +/** + * This method is like `_.isArrayLike` except that it also checks if `value` + * is an object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array-like object, + * else `false`. + * @example + * + * _.isArrayLikeObject([1, 2, 3]); + * // => true + * + * _.isArrayLikeObject(document.body.children); + * // => true + * + * _.isArrayLikeObject('abc'); + * // => false + * + * _.isArrayLikeObject(_.noop); + * // => false + */ +function isArrayLikeObject(value) { + return isObjectLike(value) && isArrayLike(value); +} + +/** + * Checks if `value` is classified as a `Function` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a function, else `false`. + * @example + * + * _.isFunction(_); + * // => true + * + * _.isFunction(/abc/); + * // => false + */ +function isFunction(value) { + // The use of `Object#toString` avoids issues with the `typeof` operator + // in Safari 8-9 which returns 'object' for typed array and other constructors. + var tag = isObject(value) ? objectToString.call(value) : ''; + return tag == funcTag || tag == genTag; +} + +/** + * Checks if `value` is a valid array-like length. + * + * **Note:** This method is loosely based on + * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. + * @example + * + * _.isLength(3); + * // => true + * + * _.isLength(Number.MIN_VALUE); + * // => false + * + * _.isLength(Infinity); + * // => false + * + * _.isLength('3'); + * // => false + */ +function isLength(value) { + return typeof value == 'number' && + value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; +} + +/** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */ +function isObject(value) { + var type = typeof value; + return !!value && (type == 'object' || type == 'function'); +} + +/** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ +function isObjectLike(value) { + return !!value && typeof value == 'object'; +} + +/** + * Assigns own enumerable string keyed properties of source objects to the + * destination object. Source objects are applied from left to right. + * Subsequent sources overwrite property assignments of previous sources. + * + * **Note:** This method mutates `object` and is loosely based on + * [`Object.assign`](https://mdn.io/Object/assign). + * + * @static + * @memberOf _ + * @since 0.10.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @see _.assignIn + * @example + * + * function Foo() { + * this.a = 1; + * } + * + * function Bar() { + * this.c = 3; + * } + * + * Foo.prototype.b = 2; + * Bar.prototype.d = 4; + * + * _.assign({ 'a': 0 }, new Foo, new Bar); + * // => { 'a': 1, 'c': 3 } + */ +var assign = createAssigner(function(object, source) { + if (nonEnumShadows || isPrototype(source) || isArrayLike(source)) { + copyObject(source, keys(source), object); + return; + } + for (var key in source) { + if (hasOwnProperty.call(source, key)) { + assignValue(object, key, source[key]); + } + } +}); + +/** + * Creates an array of the own enumerable property names of `object`. + * + * **Note:** Non-object values are coerced to objects. See the + * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) + * for more details. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keys(new Foo); + * // => ['a', 'b'] (iteration order is not guaranteed) + * + * _.keys('hi'); + * // => ['0', '1'] + */ +function keys(object) { + return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object); +} + +module.exports = assign; + + +/***/ }) +/******/ ]); \ No newline at end of file