Initial commit

This commit is contained in:
Luis Fernando Molina committed 2018-09-03 15:19:57 +02:00
commit f47e08fdcb
2409 files changed
+363607

No files matched your search

+67
View File
@@ -0,0 +1,67 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.nonExecutableDefinitionMessage = nonExecutableDefinitionMessage;
exports.ExecutableDefinitions = ExecutableDefinitions;
var _GraphQLError = require("../../error/GraphQLError");
var _kinds = require("../../language/kinds");
var _predicates = require("../../language/predicates");
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
function nonExecutableDefinitionMessage(defName) {
return "The ".concat(defName, " definition is not executable.");
}
/**
* Executable definitions
*
* A GraphQL document is only valid for execution if all definitions are either
* operation or fragment definitions.
*/
function ExecutableDefinitions(context) {
return {
Document: function Document(node) {
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = node.definitions[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var definition = _step.value;
if (!(0, _predicates.isExecutableDefinitionNode)(definition)) {
context.reportError(new _GraphQLError.GraphQLError(nonExecutableDefinitionMessage(definition.kind === _kinds.Kind.SCHEMA_DEFINITION || definition.kind === _kinds.Kind.SCHEMA_EXTENSION ? 'schema' : definition.name.value), [definition]));
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return false;
}
};
}
@@ -0,0 +1,49 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type { ASTValidationContext } from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import { Kind } from '../../language/kinds';
import { isExecutableDefinitionNode } from '../../language/predicates';
import type { ASTVisitor } from '../../language/visitor';
export function nonExecutableDefinitionMessage(defName: string): string {
return `The ${defName} definition is not executable.`;
}
/**
* Executable definitions
*
* A GraphQL document is only valid for execution if all definitions are either
* operation or fragment definitions.
*/
export function ExecutableDefinitions(
context: ASTValidationContext,
): ASTVisitor {
return {
Document(node) {
for (const definition of node.definitions) {
if (!isExecutableDefinitionNode(definition)) {
context.reportError(
new GraphQLError(
nonExecutableDefinitionMessage(
definition.kind === Kind.SCHEMA_DEFINITION ||
definition.kind === Kind.SCHEMA_EXTENSION
? 'schema'
: definition.name.value,
),
[definition],
),
);
}
}
return false;
},
};
}
+55
View File
@@ -0,0 +1,55 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
import { Kind } from '../../language/kinds';
import { isExecutableDefinitionNode } from '../../language/predicates';
export function nonExecutableDefinitionMessage(defName) {
return "The ".concat(defName, " definition is not executable.");
}
/**
* Executable definitions
*
* A GraphQL document is only valid for execution if all definitions are either
* operation or fragment definitions.
*/
export function ExecutableDefinitions(context) {
return {
Document: function Document(node) {
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = node.definitions[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var definition = _step.value;
if (!isExecutableDefinitionNode(definition)) {
context.reportError(new GraphQLError(nonExecutableDefinitionMessage(definition.kind === Kind.SCHEMA_DEFINITION || definition.kind === Kind.SCHEMA_EXTENSION ? 'schema' : definition.name.value), [definition]));
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return false;
}
};
}
+165
View File
@@ -0,0 +1,165 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.undefinedFieldMessage = undefinedFieldMessage;
exports.FieldsOnCorrectType = FieldsOnCorrectType;
var _GraphQLError = require("../../error/GraphQLError");
var _suggestionList = _interopRequireDefault(require("../../jsutils/suggestionList"));
var _quotedOrList = _interopRequireDefault(require("../../jsutils/quotedOrList"));
var _definition = require("../../type/definition");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
function undefinedFieldMessage(fieldName, type, suggestedTypeNames, suggestedFieldNames) {
var message = "Cannot query field \"".concat(fieldName, "\" on type \"").concat(type, "\".");
if (suggestedTypeNames.length !== 0) {
var suggestions = (0, _quotedOrList.default)(suggestedTypeNames);
message += " Did you mean to use an inline fragment on ".concat(suggestions, "?");
} else if (suggestedFieldNames.length !== 0) {
message += " Did you mean ".concat((0, _quotedOrList.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.
*/
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 _GraphQLError.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 ((0, _definition.isAbstractType)(type)) {
var suggestedObjectTypes = [];
var interfaceUsageCount = Object.create(null);
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = schema.getPossibleTypes(type)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var possibleType = _step.value;
if (!possibleType.getFields()[fieldName]) {
continue;
} // This object type defines this field.
suggestedObjectTypes.push(possibleType.name);
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = possibleType.getInterfaces()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var possibleInterface = _step2.value;
if (!possibleInterface.getFields()[fieldName]) {
continue;
} // This interface type defines this field.
interfaceUsageCount[possibleInterface.name] = (interfaceUsageCount[possibleInterface.name] || 0) + 1;
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
} // Suggest interface types based on how common they are.
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
var suggestedInterfaceTypes = Object.keys(interfaceUsageCount).sort(function (a, b) {
return interfaceUsageCount[b] - interfaceUsageCount[a];
}); // Suggest both interface and object types.
return suggestedInterfaceTypes.concat(suggestedObjectTypes);
} // 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 ((0, _definition.isObjectType)(type) || (0, _definition.isInterfaceType)(type)) {
var possibleFieldNames = Object.keys(type.getFields());
return (0, _suggestionList.default)(fieldName, possibleFieldNames);
} // Otherwise, must be a Union type, which does not define fields.
return [];
}
@@ -0,0 +1,143 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type { ValidationContext } from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import suggestionList from '../../jsutils/suggestionList';
import quotedOrList from '../../jsutils/quotedOrList';
import type { FieldNode } from '../../language/ast';
import type { ASTVisitor } from '../../language/visitor';
import type { GraphQLSchema } from '../../type/schema';
import type { GraphQLOutputType } from '../../type/definition';
import {
isObjectType,
isInterfaceType,
isAbstractType,
} from '../../type/definition';
export function undefinedFieldMessage(
fieldName: string,
type: string,
suggestedTypeNames: Array<string>,
suggestedFieldNames: Array<string>,
): string {
let message = `Cannot query field "${fieldName}" on type "${type}".`;
if (suggestedTypeNames.length !== 0) {
const suggestions = quotedOrList(suggestedTypeNames);
message += ` Did you mean to use an inline fragment on ${suggestions}?`;
} else if (suggestedFieldNames.length !== 0) {
message += ` Did you mean ${quotedOrList(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.
*/
export function FieldsOnCorrectType(context: ValidationContext): ASTVisitor {
return {
Field(node: FieldNode) {
const type = context.getParentType();
if (type) {
const fieldDef = context.getFieldDef();
if (!fieldDef) {
// This field doesn't exist, lets look for suggestions.
const schema = context.getSchema();
const fieldName = node.name.value;
// First determine if there are any suggested types to condition on.
const suggestedTypeNames = getSuggestedTypeNames(
schema,
type,
fieldName,
);
// If there are no suggested types, then perhaps this was a typo?
const suggestedFieldNames =
suggestedTypeNames.length !== 0
? []
: getSuggestedFieldNames(schema, type, fieldName);
// Report an error, including helpful suggestions.
context.reportError(
new 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: GraphQLSchema,
type: GraphQLOutputType,
fieldName: string,
): Array<string> {
if (isAbstractType(type)) {
const suggestedObjectTypes = [];
const interfaceUsageCount = Object.create(null);
for (const possibleType of schema.getPossibleTypes(type)) {
if (!possibleType.getFields()[fieldName]) {
continue;
}
// This object type defines this field.
suggestedObjectTypes.push(possibleType.name);
for (const possibleInterface of possibleType.getInterfaces()) {
if (!possibleInterface.getFields()[fieldName]) {
continue;
}
// This interface type defines this field.
interfaceUsageCount[possibleInterface.name] =
(interfaceUsageCount[possibleInterface.name] || 0) + 1;
}
}
// Suggest interface types based on how common they are.
const suggestedInterfaceTypes = Object.keys(interfaceUsageCount).sort(
(a, b) => interfaceUsageCount[b] - interfaceUsageCount[a],
);
// Suggest both interface and object types.
return suggestedInterfaceTypes.concat(suggestedObjectTypes);
}
// 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: GraphQLSchema,
type: GraphQLOutputType,
fieldName: string,
): Array<string> {
if (isObjectType(type) || isInterfaceType(type)) {
const possibleFieldNames = Object.keys(type.getFields());
return suggestionList(fieldName, possibleFieldNames);
}
// Otherwise, must be a Union type, which does not define fields.
return [];
}
+149
View File
@@ -0,0 +1,149 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
import suggestionList from '../../jsutils/suggestionList';
import quotedOrList from '../../jsutils/quotedOrList';
import { isObjectType, isInterfaceType, isAbstractType } from '../../type/definition';
export function undefinedFieldMessage(fieldName, type, suggestedTypeNames, suggestedFieldNames) {
var message = "Cannot query field \"".concat(fieldName, "\" on type \"").concat(type, "\".");
if (suggestedTypeNames.length !== 0) {
var suggestions = quotedOrList(suggestedTypeNames);
message += " Did you mean to use an inline fragment on ".concat(suggestions, "?");
} else if (suggestedFieldNames.length !== 0) {
message += " Did you mean ".concat(quotedOrList(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.
*/
export 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 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 (isAbstractType(type)) {
var suggestedObjectTypes = [];
var interfaceUsageCount = Object.create(null);
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = schema.getPossibleTypes(type)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var possibleType = _step.value;
if (!possibleType.getFields()[fieldName]) {
continue;
} // This object type defines this field.
suggestedObjectTypes.push(possibleType.name);
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = possibleType.getInterfaces()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var possibleInterface = _step2.value;
if (!possibleInterface.getFields()[fieldName]) {
continue;
} // This interface type defines this field.
interfaceUsageCount[possibleInterface.name] = (interfaceUsageCount[possibleInterface.name] || 0) + 1;
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
} // Suggest interface types based on how common they are.
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
var suggestedInterfaceTypes = Object.keys(interfaceUsageCount).sort(function (a, b) {
return interfaceUsageCount[b] - interfaceUsageCount[a];
}); // Suggest both interface and object types.
return suggestedInterfaceTypes.concat(suggestedObjectTypes);
} // 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 (isObjectType(type) || isInterfaceType(type)) {
var possibleFieldNames = Object.keys(type.getFields());
return suggestionList(fieldName, possibleFieldNames);
} // Otherwise, must be a Union type, which does not define fields.
return [];
}
@@ -0,0 +1,63 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.inlineFragmentOnNonCompositeErrorMessage = inlineFragmentOnNonCompositeErrorMessage;
exports.fragmentOnNonCompositeErrorMessage = fragmentOnNonCompositeErrorMessage;
exports.FragmentsOnCompositeTypes = FragmentsOnCompositeTypes;
var _GraphQLError = require("../../error/GraphQLError");
var _printer = require("../../language/printer");
var _definition = require("../../type/definition");
var _typeFromAST = require("../../utilities/typeFromAST");
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
function inlineFragmentOnNonCompositeErrorMessage(type) {
return "Fragment cannot condition on non composite type \"".concat(type, "\".");
}
function fragmentOnNonCompositeErrorMessage(fragName, type) {
return "Fragment \"".concat(fragName, "\" cannot condition on non composite ") + "type \"".concat(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 typeCondition = node.typeCondition;
if (typeCondition) {
var type = (0, _typeFromAST.typeFromAST)(context.getSchema(), typeCondition);
if (type && !(0, _definition.isCompositeType)(type)) {
context.reportError(new _GraphQLError.GraphQLError(inlineFragmentOnNonCompositeErrorMessage((0, _printer.print)(typeCondition)), [typeCondition]));
}
}
},
FragmentDefinition: function FragmentDefinition(node) {
var type = (0, _typeFromAST.typeFromAST)(context.getSchema(), node.typeCondition);
if (type && !(0, _definition.isCompositeType)(type)) {
context.reportError(new _GraphQLError.GraphQLError(fragmentOnNonCompositeErrorMessage(node.name.value, (0, _printer.print)(node.typeCondition)), [node.typeCondition]));
}
}
};
}
@@ -0,0 +1,71 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type { ValidationContext } from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import { print } from '../../language/printer';
import type { ASTVisitor } from '../../language/visitor';
import { isCompositeType } from '../../type/definition';
import { typeFromAST } from '../../utilities/typeFromAST';
export function inlineFragmentOnNonCompositeErrorMessage(type: string): string {
return `Fragment cannot condition on non composite type "${type}".`;
}
export function fragmentOnNonCompositeErrorMessage(
fragName: string,
type: string,
): string {
return (
`Fragment "${fragName}" cannot condition on non composite ` +
`type "${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.
*/
export function FragmentsOnCompositeTypes(
context: ValidationContext,
): ASTVisitor {
return {
InlineFragment(node) {
const typeCondition = node.typeCondition;
if (typeCondition) {
const type = typeFromAST(context.getSchema(), typeCondition);
if (type && !isCompositeType(type)) {
context.reportError(
new GraphQLError(
inlineFragmentOnNonCompositeErrorMessage(print(typeCondition)),
[typeCondition],
),
);
}
}
},
FragmentDefinition(node) {
const type = typeFromAST(context.getSchema(), node.typeCondition);
if (type && !isCompositeType(type)) {
context.reportError(
new GraphQLError(
fragmentOnNonCompositeErrorMessage(
node.name.value,
print(node.typeCondition),
),
[node.typeCondition],
),
);
}
},
};
}
@@ -0,0 +1,48 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
import { print } from '../../language/printer';
import { isCompositeType } from '../../type/definition';
import { typeFromAST } from '../../utilities/typeFromAST';
export function inlineFragmentOnNonCompositeErrorMessage(type) {
return "Fragment cannot condition on non composite type \"".concat(type, "\".");
}
export function fragmentOnNonCompositeErrorMessage(fragName, type) {
return "Fragment \"".concat(fragName, "\" cannot condition on non composite ") + "type \"".concat(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.
*/
export function FragmentsOnCompositeTypes(context) {
return {
InlineFragment: function InlineFragment(node) {
var typeCondition = node.typeCondition;
if (typeCondition) {
var type = typeFromAST(context.getSchema(), typeCondition);
if (type && !isCompositeType(type)) {
context.reportError(new GraphQLError(inlineFragmentOnNonCompositeErrorMessage(print(typeCondition)), [typeCondition]));
}
}
},
FragmentDefinition: function FragmentDefinition(node) {
var type = typeFromAST(context.getSchema(), node.typeCondition);
if (type && !isCompositeType(type)) {
context.reportError(new GraphQLError(fragmentOnNonCompositeErrorMessage(node.name.value, print(node.typeCondition)), [node.typeCondition]));
}
}
};
}
+172
View File
@@ -0,0 +1,172 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.unknownArgMessage = unknownArgMessage;
exports.unknownDirectiveArgMessage = unknownDirectiveArgMessage;
exports.KnownArgumentNames = KnownArgumentNames;
exports.KnownArgumentNamesOnDirectives = KnownArgumentNamesOnDirectives;
var _GraphQLError = require("../../error/GraphQLError");
var _suggestionList = _interopRequireDefault(require("../../jsutils/suggestionList"));
var _quotedOrList = _interopRequireDefault(require("../../jsutils/quotedOrList"));
var _kinds = require("../../language/kinds");
var _directives = require("../../type/directives");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function unknownArgMessage(argName, fieldName, typeName, suggestedArgs) {
var message = "Unknown argument \"".concat(argName, "\" on field \"").concat(fieldName, "\" of ") + "type \"".concat(typeName, "\".");
if (suggestedArgs.length) {
message += " Did you mean ".concat((0, _quotedOrList.default)(suggestedArgs), "?");
}
return message;
}
function unknownDirectiveArgMessage(argName, directiveName, suggestedArgs) {
var message = "Unknown argument \"".concat(argName, "\" on directive \"@").concat(directiveName, "\".");
if (suggestedArgs.length) {
message += " Did you mean ".concat((0, _quotedOrList.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 _objectSpread({}, KnownArgumentNamesOnDirectives(context), {
Argument: function Argument(argNode) {
var argDef = context.getArgument();
var fieldDef = context.getFieldDef();
var parentType = context.getParentType();
if (!argDef && fieldDef && parentType) {
var argName = argNode.name.value;
var knownArgsNames = fieldDef.args.map(function (arg) {
return arg.name;
});
context.reportError(new _GraphQLError.GraphQLError(unknownArgMessage(argName, fieldDef.name, parentType.name, (0, _suggestionList.default)(argName, knownArgsNames)), argNode));
}
}
});
} // @internal
function KnownArgumentNamesOnDirectives(context) {
var directiveArgs = Object.create(null);
var schema = context.getSchema();
var definedDirectives = schema ? schema.getDirectives() : _directives.specifiedDirectives;
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = definedDirectives[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var directive = _step.value;
directiveArgs[directive.name] = directive.args.map(function (arg) {
return arg.name;
});
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
var astDefinitions = context.getDocument().definitions;
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = astDefinitions[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var def = _step2.value;
if (def.kind === _kinds.Kind.DIRECTIVE_DEFINITION) {
directiveArgs[def.name.value] = def.arguments ? def.arguments.map(function (arg) {
return arg.name.value;
}) : [];
}
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
return {
Directive: function Directive(directiveNode) {
var directiveName = directiveNode.name.value;
var knownArgs = directiveArgs[directiveName];
if (directiveNode.arguments && knownArgs) {
var _iteratorNormalCompletion3 = true;
var _didIteratorError3 = false;
var _iteratorError3 = undefined;
try {
for (var _iterator3 = directiveNode.arguments[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
var argNode = _step3.value;
var argName = argNode.name.value;
if (knownArgs.indexOf(argName) === -1) {
var suggestions = (0, _suggestionList.default)(argName, knownArgs);
context.reportError(new _GraphQLError.GraphQLError(unknownDirectiveArgMessage(argName, directiveName, suggestions), argNode));
}
}
} catch (err) {
_didIteratorError3 = true;
_iteratorError3 = err;
} finally {
try {
if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
_iterator3.return();
}
} finally {
if (_didIteratorError3) {
throw _iteratorError3;
}
}
}
}
return false;
}
};
}
+127
View File
@@ -0,0 +1,127 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type {
ValidationContext,
SDLValidationContext,
} from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import type { ASTVisitor } from '../../language/visitor';
import suggestionList from '../../jsutils/suggestionList';
import quotedOrList from '../../jsutils/quotedOrList';
import { Kind } from '../../language/kinds';
import { specifiedDirectives } from '../../type/directives';
export function unknownArgMessage(
argName: string,
fieldName: string,
typeName: string,
suggestedArgs: Array<string>,
): string {
let message =
`Unknown argument "${argName}" on field "${fieldName}" of ` +
`type "${typeName}".`;
if (suggestedArgs.length) {
message += ` Did you mean ${quotedOrList(suggestedArgs)}?`;
}
return message;
}
export function unknownDirectiveArgMessage(
argName: string,
directiveName: string,
suggestedArgs: Array<string>,
): string {
let message = `Unknown argument "${argName}" on directive "@${directiveName}".`;
if (suggestedArgs.length) {
message += ` Did you mean ${quotedOrList(suggestedArgs)}?`;
}
return message;
}
/**
* Known argument names
*
* A GraphQL field is only valid if all supplied arguments are defined by
* that field.
*/
export function KnownArgumentNames(context: ValidationContext): ASTVisitor {
return {
...KnownArgumentNamesOnDirectives(context),
Argument(argNode) {
const argDef = context.getArgument();
const fieldDef = context.getFieldDef();
const parentType = context.getParentType();
if (!argDef && fieldDef && parentType) {
const argName = argNode.name.value;
const knownArgsNames = fieldDef.args.map(arg => arg.name);
context.reportError(
new GraphQLError(
unknownArgMessage(
argName,
fieldDef.name,
parentType.name,
suggestionList(argName, knownArgsNames),
),
argNode,
),
);
}
},
};
}
// @internal
export function KnownArgumentNamesOnDirectives(
context: ValidationContext | SDLValidationContext,
): ASTVisitor {
const directiveArgs = Object.create(null);
const schema = context.getSchema();
const definedDirectives = schema
? schema.getDirectives()
: specifiedDirectives;
for (const directive of definedDirectives) {
directiveArgs[directive.name] = directive.args.map(arg => arg.name);
}
const astDefinitions = context.getDocument().definitions;
for (const def of astDefinitions) {
if (def.kind === Kind.DIRECTIVE_DEFINITION) {
directiveArgs[def.name.value] = def.arguments
? def.arguments.map(arg => arg.name.value)
: [];
}
}
return {
Directive(directiveNode) {
const directiveName = directiveNode.name.value;
const knownArgs = directiveArgs[directiveName];
if (directiveNode.arguments && knownArgs) {
for (const argNode of directiveNode.arguments) {
const argName = argNode.name.value;
if (knownArgs.indexOf(argName) === -1) {
const suggestions = suggestionList(argName, knownArgs);
context.reportError(
new GraphQLError(
unknownDirectiveArgMessage(argName, directiveName, suggestions),
argNode,
),
);
}
}
}
return false;
},
};
}
+160
View File
@@ -0,0 +1,160 @@
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
import suggestionList from '../../jsutils/suggestionList';
import quotedOrList from '../../jsutils/quotedOrList';
import { Kind } from '../../language/kinds';
import { specifiedDirectives } from '../../type/directives';
export function unknownArgMessage(argName, fieldName, typeName, suggestedArgs) {
var message = "Unknown argument \"".concat(argName, "\" on field \"").concat(fieldName, "\" of ") + "type \"".concat(typeName, "\".");
if (suggestedArgs.length) {
message += " Did you mean ".concat(quotedOrList(suggestedArgs), "?");
}
return message;
}
export function unknownDirectiveArgMessage(argName, directiveName, suggestedArgs) {
var message = "Unknown argument \"".concat(argName, "\" on directive \"@").concat(directiveName, "\".");
if (suggestedArgs.length) {
message += " Did you mean ".concat(quotedOrList(suggestedArgs), "?");
}
return message;
}
/**
* Known argument names
*
* A GraphQL field is only valid if all supplied arguments are defined by
* that field.
*/
export function KnownArgumentNames(context) {
return _objectSpread({}, KnownArgumentNamesOnDirectives(context), {
Argument: function Argument(argNode) {
var argDef = context.getArgument();
var fieldDef = context.getFieldDef();
var parentType = context.getParentType();
if (!argDef && fieldDef && parentType) {
var argName = argNode.name.value;
var knownArgsNames = fieldDef.args.map(function (arg) {
return arg.name;
});
context.reportError(new GraphQLError(unknownArgMessage(argName, fieldDef.name, parentType.name, suggestionList(argName, knownArgsNames)), argNode));
}
}
});
} // @internal
export function KnownArgumentNamesOnDirectives(context) {
var directiveArgs = Object.create(null);
var schema = context.getSchema();
var definedDirectives = schema ? schema.getDirectives() : specifiedDirectives;
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = definedDirectives[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var directive = _step.value;
directiveArgs[directive.name] = directive.args.map(function (arg) {
return arg.name;
});
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
var astDefinitions = context.getDocument().definitions;
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = astDefinitions[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var def = _step2.value;
if (def.kind === Kind.DIRECTIVE_DEFINITION) {
directiveArgs[def.name.value] = def.arguments ? def.arguments.map(function (arg) {
return arg.name.value;
}) : [];
}
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
return {
Directive: function Directive(directiveNode) {
var directiveName = directiveNode.name.value;
var knownArgs = directiveArgs[directiveName];
if (directiveNode.arguments && knownArgs) {
var _iteratorNormalCompletion3 = true;
var _didIteratorError3 = false;
var _iteratorError3 = undefined;
try {
for (var _iterator3 = directiveNode.arguments[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
var argNode = _step3.value;
var argName = argNode.name.value;
if (knownArgs.indexOf(argName) === -1) {
var suggestions = suggestionList(argName, knownArgs);
context.reportError(new GraphQLError(unknownDirectiveArgMessage(argName, directiveName, suggestions), argNode));
}
}
} catch (err) {
_didIteratorError3 = true;
_iteratorError3 = err;
} finally {
try {
if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
_iterator3.return();
}
} finally {
if (_didIteratorError3) {
throw _iteratorError3;
}
}
}
}
return false;
}
};
}
+191
View File
@@ -0,0 +1,191 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.unknownDirectiveMessage = unknownDirectiveMessage;
exports.misplacedDirectiveMessage = misplacedDirectiveMessage;
exports.KnownDirectives = KnownDirectives;
var _GraphQLError = require("../../error/GraphQLError");
var _kinds = require("../../language/kinds");
var _directiveLocation = require("../../language/directiveLocation");
var _directives = require("../../type/directives");
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
function unknownDirectiveMessage(directiveName) {
return "Unknown directive \"".concat(directiveName, "\".");
}
function misplacedDirectiveMessage(directiveName, location) {
return "Directive \"".concat(directiveName, "\" may not be used on ").concat(location, ".");
}
/**
* Known directives
*
* A GraphQL document is only valid if all `@directives` are known by the
* schema and legally positioned.
*/
function KnownDirectives(context) {
var locationsMap = Object.create(null);
var schema = context.getSchema();
var definedDirectives = schema ? schema.getDirectives() : _directives.specifiedDirectives;
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = definedDirectives[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var directive = _step.value;
locationsMap[directive.name] = directive.locations;
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
var astDefinitions = context.getDocument().definitions;
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = astDefinitions[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var def = _step2.value;
if (def.kind === _kinds.Kind.DIRECTIVE_DEFINITION) {
locationsMap[def.name.value] = def.locations.map(function (name) {
return name.value;
});
}
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
return {
Directive: function Directive(node, key, parent, path, ancestors) {
var name = node.name.value;
var locations = locationsMap[name];
if (!locations) {
context.reportError(new _GraphQLError.GraphQLError(unknownDirectiveMessage(name), [node]));
return;
}
var candidateLocation = getDirectiveLocationForASTPath(ancestors);
if (candidateLocation && locations.indexOf(candidateLocation) === -1) {
context.reportError(new _GraphQLError.GraphQLError(misplacedDirectiveMessage(name, candidateLocation), [node]));
}
}
};
}
function getDirectiveLocationForASTPath(ancestors) {
var appliedTo = ancestors[ancestors.length - 1];
if (!Array.isArray(appliedTo)) {
switch (appliedTo.kind) {
case _kinds.Kind.OPERATION_DEFINITION:
switch (appliedTo.operation) {
case 'query':
return _directiveLocation.DirectiveLocation.QUERY;
case 'mutation':
return _directiveLocation.DirectiveLocation.MUTATION;
case 'subscription':
return _directiveLocation.DirectiveLocation.SUBSCRIPTION;
}
break;
case _kinds.Kind.FIELD:
return _directiveLocation.DirectiveLocation.FIELD;
case _kinds.Kind.FRAGMENT_SPREAD:
return _directiveLocation.DirectiveLocation.FRAGMENT_SPREAD;
case _kinds.Kind.INLINE_FRAGMENT:
return _directiveLocation.DirectiveLocation.INLINE_FRAGMENT;
case _kinds.Kind.FRAGMENT_DEFINITION:
return _directiveLocation.DirectiveLocation.FRAGMENT_DEFINITION;
case _kinds.Kind.VARIABLE_DEFINITION:
return _directiveLocation.DirectiveLocation.VARIABLE_DEFINITION;
case _kinds.Kind.SCHEMA_DEFINITION:
case _kinds.Kind.SCHEMA_EXTENSION:
return _directiveLocation.DirectiveLocation.SCHEMA;
case _kinds.Kind.SCALAR_TYPE_DEFINITION:
case _kinds.Kind.SCALAR_TYPE_EXTENSION:
return _directiveLocation.DirectiveLocation.SCALAR;
case _kinds.Kind.OBJECT_TYPE_DEFINITION:
case _kinds.Kind.OBJECT_TYPE_EXTENSION:
return _directiveLocation.DirectiveLocation.OBJECT;
case _kinds.Kind.FIELD_DEFINITION:
return _directiveLocation.DirectiveLocation.FIELD_DEFINITION;
case _kinds.Kind.INTERFACE_TYPE_DEFINITION:
case _kinds.Kind.INTERFACE_TYPE_EXTENSION:
return _directiveLocation.DirectiveLocation.INTERFACE;
case _kinds.Kind.UNION_TYPE_DEFINITION:
case _kinds.Kind.UNION_TYPE_EXTENSION:
return _directiveLocation.DirectiveLocation.UNION;
case _kinds.Kind.ENUM_TYPE_DEFINITION:
case _kinds.Kind.ENUM_TYPE_EXTENSION:
return _directiveLocation.DirectiveLocation.ENUM;
case _kinds.Kind.ENUM_VALUE_DEFINITION:
return _directiveLocation.DirectiveLocation.ENUM_VALUE;
case _kinds.Kind.INPUT_OBJECT_TYPE_DEFINITION:
case _kinds.Kind.INPUT_OBJECT_TYPE_EXTENSION:
return _directiveLocation.DirectiveLocation.INPUT_OBJECT;
case _kinds.Kind.INPUT_VALUE_DEFINITION:
var parentNode = ancestors[ancestors.length - 3];
return parentNode.kind === _kinds.Kind.INPUT_OBJECT_TYPE_DEFINITION ? _directiveLocation.DirectiveLocation.INPUT_FIELD_DEFINITION : _directiveLocation.DirectiveLocation.ARGUMENT_DEFINITION;
}
}
}
+136
View File
@@ -0,0 +1,136 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type {
ValidationContext,
SDLValidationContext,
} from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import { Kind } from '../../language/kinds';
import { DirectiveLocation } from '../../language/directiveLocation';
import type { ASTVisitor } from '../../language/visitor';
import { specifiedDirectives } from '../../type/directives';
export function unknownDirectiveMessage(directiveName: string): string {
return `Unknown directive "${directiveName}".`;
}
export function misplacedDirectiveMessage(
directiveName: string,
location: string,
): string {
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.
*/
export function KnownDirectives(
context: ValidationContext | SDLValidationContext,
): ASTVisitor {
const locationsMap = Object.create(null);
const schema = context.getSchema();
const definedDirectives = schema
? schema.getDirectives()
: specifiedDirectives;
for (const directive of definedDirectives) {
locationsMap[directive.name] = directive.locations;
}
const astDefinitions = context.getDocument().definitions;
for (const def of astDefinitions) {
if (def.kind === Kind.DIRECTIVE_DEFINITION) {
locationsMap[def.name.value] = def.locations.map(name => name.value);
}
}
return {
Directive(node, key, parent, path, ancestors) {
const name = node.name.value;
const locations = locationsMap[name];
if (!locations) {
context.reportError(
new GraphQLError(unknownDirectiveMessage(name), [node]),
);
return;
}
const candidateLocation = getDirectiveLocationForASTPath(ancestors);
if (candidateLocation && locations.indexOf(candidateLocation) === -1) {
context.reportError(
new GraphQLError(misplacedDirectiveMessage(name, candidateLocation), [
node,
]),
);
}
},
};
}
function getDirectiveLocationForASTPath(ancestors) {
const appliedTo = ancestors[ancestors.length - 1];
if (!Array.isArray(appliedTo)) {
switch (appliedTo.kind) {
case Kind.OPERATION_DEFINITION:
switch (appliedTo.operation) {
case 'query':
return DirectiveLocation.QUERY;
case 'mutation':
return DirectiveLocation.MUTATION;
case 'subscription':
return DirectiveLocation.SUBSCRIPTION;
}
break;
case Kind.FIELD:
return DirectiveLocation.FIELD;
case Kind.FRAGMENT_SPREAD:
return DirectiveLocation.FRAGMENT_SPREAD;
case Kind.INLINE_FRAGMENT:
return DirectiveLocation.INLINE_FRAGMENT;
case Kind.FRAGMENT_DEFINITION:
return DirectiveLocation.FRAGMENT_DEFINITION;
case Kind.VARIABLE_DEFINITION:
return DirectiveLocation.VARIABLE_DEFINITION;
case Kind.SCHEMA_DEFINITION:
case Kind.SCHEMA_EXTENSION:
return DirectiveLocation.SCHEMA;
case Kind.SCALAR_TYPE_DEFINITION:
case Kind.SCALAR_TYPE_EXTENSION:
return DirectiveLocation.SCALAR;
case Kind.OBJECT_TYPE_DEFINITION:
case Kind.OBJECT_TYPE_EXTENSION:
return DirectiveLocation.OBJECT;
case Kind.FIELD_DEFINITION:
return DirectiveLocation.FIELD_DEFINITION;
case Kind.INTERFACE_TYPE_DEFINITION:
case Kind.INTERFACE_TYPE_EXTENSION:
return DirectiveLocation.INTERFACE;
case Kind.UNION_TYPE_DEFINITION:
case Kind.UNION_TYPE_EXTENSION:
return DirectiveLocation.UNION;
case Kind.ENUM_TYPE_DEFINITION:
case Kind.ENUM_TYPE_EXTENSION:
return DirectiveLocation.ENUM;
case Kind.ENUM_VALUE_DEFINITION:
return DirectiveLocation.ENUM_VALUE;
case Kind.INPUT_OBJECT_TYPE_DEFINITION:
case Kind.INPUT_OBJECT_TYPE_EXTENSION:
return DirectiveLocation.INPUT_OBJECT;
case Kind.INPUT_VALUE_DEFINITION:
const parentNode = ancestors[ancestors.length - 3];
return parentNode.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION
? DirectiveLocation.INPUT_FIELD_DEFINITION
: DirectiveLocation.ARGUMENT_DEFINITION;
}
}
}
+176
View File
@@ -0,0 +1,176 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
import { Kind } from '../../language/kinds';
import { DirectiveLocation } from '../../language/directiveLocation';
import { specifiedDirectives } from '../../type/directives';
export function unknownDirectiveMessage(directiveName) {
return "Unknown directive \"".concat(directiveName, "\".");
}
export function misplacedDirectiveMessage(directiveName, location) {
return "Directive \"".concat(directiveName, "\" may not be used on ").concat(location, ".");
}
/**
* Known directives
*
* A GraphQL document is only valid if all `@directives` are known by the
* schema and legally positioned.
*/
export function KnownDirectives(context) {
var locationsMap = Object.create(null);
var schema = context.getSchema();
var definedDirectives = schema ? schema.getDirectives() : specifiedDirectives;
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = definedDirectives[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var directive = _step.value;
locationsMap[directive.name] = directive.locations;
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
var astDefinitions = context.getDocument().definitions;
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = astDefinitions[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var def = _step2.value;
if (def.kind === Kind.DIRECTIVE_DEFINITION) {
locationsMap[def.name.value] = def.locations.map(function (name) {
return name.value;
});
}
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
return {
Directive: function Directive(node, key, parent, path, ancestors) {
var name = node.name.value;
var locations = locationsMap[name];
if (!locations) {
context.reportError(new GraphQLError(unknownDirectiveMessage(name), [node]));
return;
}
var candidateLocation = getDirectiveLocationForASTPath(ancestors);
if (candidateLocation && locations.indexOf(candidateLocation) === -1) {
context.reportError(new GraphQLError(misplacedDirectiveMessage(name, candidateLocation), [node]));
}
}
};
}
function getDirectiveLocationForASTPath(ancestors) {
var appliedTo = ancestors[ancestors.length - 1];
if (!Array.isArray(appliedTo)) {
switch (appliedTo.kind) {
case Kind.OPERATION_DEFINITION:
switch (appliedTo.operation) {
case 'query':
return DirectiveLocation.QUERY;
case 'mutation':
return DirectiveLocation.MUTATION;
case 'subscription':
return DirectiveLocation.SUBSCRIPTION;
}
break;
case Kind.FIELD:
return DirectiveLocation.FIELD;
case Kind.FRAGMENT_SPREAD:
return DirectiveLocation.FRAGMENT_SPREAD;
case Kind.INLINE_FRAGMENT:
return DirectiveLocation.INLINE_FRAGMENT;
case Kind.FRAGMENT_DEFINITION:
return DirectiveLocation.FRAGMENT_DEFINITION;
case Kind.VARIABLE_DEFINITION:
return DirectiveLocation.VARIABLE_DEFINITION;
case Kind.SCHEMA_DEFINITION:
case Kind.SCHEMA_EXTENSION:
return DirectiveLocation.SCHEMA;
case Kind.SCALAR_TYPE_DEFINITION:
case Kind.SCALAR_TYPE_EXTENSION:
return DirectiveLocation.SCALAR;
case Kind.OBJECT_TYPE_DEFINITION:
case Kind.OBJECT_TYPE_EXTENSION:
return DirectiveLocation.OBJECT;
case Kind.FIELD_DEFINITION:
return DirectiveLocation.FIELD_DEFINITION;
case Kind.INTERFACE_TYPE_DEFINITION:
case Kind.INTERFACE_TYPE_EXTENSION:
return DirectiveLocation.INTERFACE;
case Kind.UNION_TYPE_DEFINITION:
case Kind.UNION_TYPE_EXTENSION:
return DirectiveLocation.UNION;
case Kind.ENUM_TYPE_DEFINITION:
case Kind.ENUM_TYPE_EXTENSION:
return DirectiveLocation.ENUM;
case Kind.ENUM_VALUE_DEFINITION:
return DirectiveLocation.ENUM_VALUE;
case Kind.INPUT_OBJECT_TYPE_DEFINITION:
case Kind.INPUT_OBJECT_TYPE_EXTENSION:
return DirectiveLocation.INPUT_OBJECT;
case Kind.INPUT_VALUE_DEFINITION:
var parentNode = ancestors[ancestors.length - 3];
return parentNode.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION ? DirectiveLocation.INPUT_FIELD_DEFINITION : DirectiveLocation.ARGUMENT_DEFINITION;
}
}
}
+41
View File
@@ -0,0 +1,41 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.unknownFragmentMessage = unknownFragmentMessage;
exports.KnownFragmentNames = KnownFragmentNames;
var _GraphQLError = require("../../error/GraphQLError");
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
function unknownFragmentMessage(fragName) {
return "Unknown fragment \"".concat(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 _GraphQLError.GraphQLError(unknownFragmentMessage(fragmentName), [node.name]));
}
}
};
}
@@ -0,0 +1,36 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type { ValidationContext } from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import type { ASTVisitor } from '../../language/visitor';
export function unknownFragmentMessage(fragName: string): string {
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.
*/
export function KnownFragmentNames(context: ValidationContext): ASTVisitor {
return {
FragmentSpread(node) {
const fragmentName = node.name.value;
const fragment = context.getFragment(fragmentName);
if (!fragment) {
context.reportError(
new GraphQLError(unknownFragmentMessage(fragmentName), [node.name]),
);
}
},
};
}
+31
View File
@@ -0,0 +1,31 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
export function unknownFragmentMessage(fragName) {
return "Unknown fragment \"".concat(fragName, "\".");
}
/**
* Known fragment names
*
* A GraphQL document is only valid if all `...Fragment` fragment spreads refer
* to fragments defined in the same document.
*/
export function KnownFragmentNames(context) {
return {
FragmentSpread: function FragmentSpread(node) {
var fragmentName = node.name.value;
var fragment = context.getFragment(fragmentName);
if (!fragment) {
context.reportError(new GraphQLError(unknownFragmentMessage(fragmentName), [node.name]));
}
}
};
}
+69
View File
@@ -0,0 +1,69 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.unknownTypeMessage = unknownTypeMessage;
exports.KnownTypeNames = KnownTypeNames;
var _GraphQLError = require("../../error/GraphQLError");
var _suggestionList = _interopRequireDefault(require("../../jsutils/suggestionList"));
var _quotedOrList = _interopRequireDefault(require("../../jsutils/quotedOrList"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
function unknownTypeMessage(typeName, suggestedTypes) {
var message = "Unknown type \"".concat(typeName, "\".");
if (suggestedTypes.length) {
message += " Did you mean ".concat((0, _quotedOrList.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 _GraphQLError.GraphQLError(unknownTypeMessage(typeName, (0, _suggestionList.default)(typeName, Object.keys(schema.getTypeMap()))), [node]));
}
}
};
}
+59
View File
@@ -0,0 +1,59 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type { ValidationContext } from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import suggestionList from '../../jsutils/suggestionList';
import quotedOrList from '../../jsutils/quotedOrList';
import type { ASTVisitor } from '../../language/visitor';
export function unknownTypeMessage(
typeName: string,
suggestedTypes: Array<string>,
): string {
let message = `Unknown type "${typeName}".`;
if (suggestedTypes.length) {
message += ` Did you mean ${quotedOrList(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.
*/
export function KnownTypeNames(context: ValidationContext): ASTVisitor {
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: () => false,
InterfaceTypeDefinition: () => false,
UnionTypeDefinition: () => false,
InputObjectTypeDefinition: () => false,
NamedType(node) {
const schema = context.getSchema();
const typeName = node.name.value;
const type = schema.getType(typeName);
if (!type) {
context.reportError(
new GraphQLError(
unknownTypeMessage(
typeName,
suggestionList(typeName, Object.keys(schema.getTypeMap())),
),
[node],
),
);
}
},
};
}
+55
View File
@@ -0,0 +1,55 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
import suggestionList from '../../jsutils/suggestionList';
import quotedOrList from '../../jsutils/quotedOrList';
export function unknownTypeMessage(typeName, suggestedTypes) {
var message = "Unknown type \"".concat(typeName, "\".");
if (suggestedTypes.length) {
message += " Did you mean ".concat(quotedOrList(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.
*/
export 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 GraphQLError(unknownTypeMessage(typeName, suggestionList(typeName, Object.keys(schema.getTypeMap()))), [node]));
}
}
};
}
+46
View File
@@ -0,0 +1,46 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.anonOperationNotAloneMessage = anonOperationNotAloneMessage;
exports.LoneAnonymousOperation = LoneAnonymousOperation;
var _GraphQLError = require("../../error/GraphQLError");
var _kinds = require("../../language/kinds");
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
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.
*/
function LoneAnonymousOperation(context) {
var operationCount = 0;
return {
Document: function Document(node) {
operationCount = node.definitions.filter(function (definition) {
return definition.kind === _kinds.Kind.OPERATION_DEFINITION;
}).length;
},
OperationDefinition: function OperationDefinition(node) {
if (!node.name && operationCount > 1) {
context.reportError(new _GraphQLError.GraphQLError(anonOperationNotAloneMessage(), [node]));
}
}
};
}
@@ -0,0 +1,43 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type { ASTValidationContext } from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import { Kind } from '../../language/kinds';
import type { ASTVisitor } from '../../language/visitor';
export function anonOperationNotAloneMessage(): string {
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.
*/
export function LoneAnonymousOperation(
context: ASTValidationContext,
): ASTVisitor {
let operationCount = 0;
return {
Document(node) {
operationCount = node.definitions.filter(
definition => definition.kind === Kind.OPERATION_DEFINITION,
).length;
},
OperationDefinition(node) {
if (!node.name && operationCount > 1) {
context.reportError(
new GraphQLError(anonOperationNotAloneMessage(), [node]),
);
}
},
};
}
@@ -0,0 +1,35 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
import { Kind } from '../../language/kinds';
export 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.
*/
export function LoneAnonymousOperation(context) {
var operationCount = 0;
return {
Document: function Document(node) {
operationCount = node.definitions.filter(function (definition) {
return definition.kind === Kind.OPERATION_DEFINITION;
}).length;
},
OperationDefinition: function OperationDefinition(node) {
if (!node.name && operationCount > 1) {
context.reportError(new GraphQLError(anonOperationNotAloneMessage(), [node]));
}
}
};
}
+52
View File
@@ -0,0 +1,52 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.schemaDefinitionNotAloneMessage = schemaDefinitionNotAloneMessage;
exports.canNotDefineSchemaWithinExtensionMessage = canNotDefineSchemaWithinExtensionMessage;
exports.LoneSchemaDefinition = LoneSchemaDefinition;
var _GraphQLError = require("../../error/GraphQLError");
/**
* Copyright (c) 2018-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
function schemaDefinitionNotAloneMessage() {
return 'Must provide only one schema definition.';
}
function canNotDefineSchemaWithinExtensionMessage() {
return 'Cannot define a new schema within a schema extension.';
}
/**
* Lone Schema definition
*
* A GraphQL document is only valid if it contains only one schema definition.
*/
function LoneSchemaDefinition(context) {
var oldSchema = context.getSchema();
var alreadyDefined = oldSchema && (oldSchema.astNode || oldSchema.getQueryType() || oldSchema.getMutationType() || oldSchema.getSubscriptionType());
var schemaDefinitionsCount = 0;
return {
SchemaDefinition: function SchemaDefinition(node) {
if (alreadyDefined) {
context.reportError(new _GraphQLError.GraphQLError(canNotDefineSchemaWithinExtensionMessage(), node));
return;
}
if (schemaDefinitionsCount > 0) {
context.reportError(new _GraphQLError.GraphQLError(schemaDefinitionNotAloneMessage(), node));
}
++schemaDefinitionsCount;
}
};
}
@@ -0,0 +1,56 @@
/**
* Copyright (c) 2018-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type { SDLValidationContext } from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import type { ASTVisitor } from '../../language/visitor';
export function schemaDefinitionNotAloneMessage(): string {
return 'Must provide only one schema definition.';
}
export function canNotDefineSchemaWithinExtensionMessage(): string {
return 'Cannot define a new schema within a schema extension.';
}
/**
* Lone Schema definition
*
* A GraphQL document is only valid if it contains only one schema definition.
*/
export function LoneSchemaDefinition(
context: SDLValidationContext,
): ASTVisitor {
const oldSchema = context.getSchema();
const alreadyDefined =
oldSchema &&
(oldSchema.astNode ||
oldSchema.getQueryType() ||
oldSchema.getMutationType() ||
oldSchema.getSubscriptionType());
let schemaDefinitionsCount = 0;
return {
SchemaDefinition(node) {
if (alreadyDefined) {
context.reportError(
new GraphQLError(canNotDefineSchemaWithinExtensionMessage(), node),
);
return;
}
if (schemaDefinitionsCount > 0) {
context.reportError(
new GraphQLError(schemaDefinitionNotAloneMessage(), node),
);
}
++schemaDefinitionsCount;
},
};
}
+40
View File
@@ -0,0 +1,40 @@
/**
* Copyright (c) 2018-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
export function schemaDefinitionNotAloneMessage() {
return 'Must provide only one schema definition.';
}
export function canNotDefineSchemaWithinExtensionMessage() {
return 'Cannot define a new schema within a schema extension.';
}
/**
* Lone Schema definition
*
* A GraphQL document is only valid if it contains only one schema definition.
*/
export function LoneSchemaDefinition(context) {
var oldSchema = context.getSchema();
var alreadyDefined = oldSchema && (oldSchema.astNode || oldSchema.getQueryType() || oldSchema.getMutationType() || oldSchema.getSubscriptionType());
var schemaDefinitionsCount = 0;
return {
SchemaDefinition: function SchemaDefinition(node) {
if (alreadyDefined) {
context.reportError(new GraphQLError(canNotDefineSchemaWithinExtensionMessage(), node));
return;
}
if (schemaDefinitionsCount > 0) {
context.reportError(new GraphQLError(schemaDefinitionNotAloneMessage(), node));
}
++schemaDefinitionsCount;
}
};
}
+84
View File
@@ -0,0 +1,84 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.cycleErrorMessage = cycleErrorMessage;
exports.NoFragmentCycles = NoFragmentCycles;
var _GraphQLError = require("../../error/GraphQLError");
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
function cycleErrorMessage(fragName, spreadNames) {
var via = spreadNames.length ? ' via ' + spreadNames.join(', ') : '';
return "Cannot spread fragment \"".concat(fragName, "\" within itself").concat(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) {
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) {
if (visitedFrags[fragment.name.value]) {
return;
}
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];
spreadPath.push(spreadNode);
if (cycleIndex === undefined) {
var spreadFragment = context.getFragment(spreadName);
if (spreadFragment) {
detectCycleRecursive(spreadFragment);
}
} else {
var cyclePath = spreadPath.slice(cycleIndex);
var fragmentNames = cyclePath.slice(0, -1).map(function (s) {
return s.name.value;
});
context.reportError(new _GraphQLError.GraphQLError(cycleErrorMessage(spreadName, fragmentNames), cyclePath));
}
spreadPath.pop();
}
spreadPathIndexByName[fragmentName] = undefined;
}
}
+86
View File
@@ -0,0 +1,86 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type { ValidationContext } from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import type { FragmentDefinitionNode } from '../../language/ast';
import type { ASTVisitor } from '../../language/visitor';
export function cycleErrorMessage(
fragName: string,
spreadNames: Array<string>,
): string {
const via = spreadNames.length ? ' via ' + spreadNames.join(', ') : '';
return `Cannot spread fragment "${fragName}" within itself${via}.`;
}
export function NoFragmentCycles(context: ValidationContext): ASTVisitor {
// Tracks already visited fragments to maintain O(N) and to ensure that cycles
// are not redundantly reported.
const visitedFrags = Object.create(null);
// Array of AST nodes used to produce meaningful errors
const spreadPath = [];
// Position in the spread path
const spreadPathIndexByName = Object.create(null);
return {
OperationDefinition: () => false,
FragmentDefinition(node) {
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: FragmentDefinitionNode) {
if (visitedFrags[fragment.name.value]) {
return;
}
const fragmentName = fragment.name.value;
visitedFrags[fragmentName] = true;
const spreadNodes = context.getFragmentSpreads(fragment.selectionSet);
if (spreadNodes.length === 0) {
return;
}
spreadPathIndexByName[fragmentName] = spreadPath.length;
for (let i = 0; i < spreadNodes.length; i++) {
const spreadNode = spreadNodes[i];
const spreadName = spreadNode.name.value;
const cycleIndex = spreadPathIndexByName[spreadName];
spreadPath.push(spreadNode);
if (cycleIndex === undefined) {
const spreadFragment = context.getFragment(spreadName);
if (spreadFragment) {
detectCycleRecursive(spreadFragment);
}
} else {
const cyclePath = spreadPath.slice(cycleIndex);
const fragmentNames = cyclePath.slice(0, -1).map(s => s.name.value);
context.reportError(
new GraphQLError(
cycleErrorMessage(spreadName, fragmentNames),
cyclePath,
),
);
}
spreadPath.pop();
}
spreadPathIndexByName[fragmentName] = undefined;
}
}
+74
View File
@@ -0,0 +1,74 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
export function cycleErrorMessage(fragName, spreadNames) {
var via = spreadNames.length ? ' via ' + spreadNames.join(', ') : '';
return "Cannot spread fragment \"".concat(fragName, "\" within itself").concat(via, ".");
}
export 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) {
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) {
if (visitedFrags[fragment.name.value]) {
return;
}
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];
spreadPath.push(spreadNode);
if (cycleIndex === undefined) {
var spreadFragment = context.getFragment(spreadName);
if (spreadFragment) {
detectCycleRecursive(spreadFragment);
}
} else {
var cyclePath = spreadPath.slice(cycleIndex);
var fragmentNames = cyclePath.slice(0, -1).map(function (s) {
return s.name.value;
});
context.reportError(new GraphQLError(cycleErrorMessage(spreadName, fragmentNames), cyclePath));
}
spreadPath.pop();
}
spreadPathIndexByName[fragmentName] = undefined;
}
}
+73
View File
@@ -0,0 +1,73 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.undefinedVarMessage = undefinedVarMessage;
exports.NoUndefinedVariables = NoUndefinedVariables;
var _GraphQLError = require("../../error/GraphQLError");
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
function undefinedVarMessage(varName, opName) {
return opName ? "Variable \"$".concat(varName, "\" is not defined by operation \"").concat(opName, "\".") : "Variable \"$".concat(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);
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = usages[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var _ref2 = _step.value;
var node = _ref2.node;
var varName = node.name.value;
if (variableNameDefined[varName] !== true) {
context.reportError(new _GraphQLError.GraphQLError(undefinedVarMessage(varName, operation.name && operation.name.value), [node, operation]));
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
}
},
VariableDefinition: function VariableDefinition(node) {
variableNameDefined[node.variable.name.value] = true;
}
};
}
@@ -0,0 +1,57 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type { ValidationContext } from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import type { ASTVisitor } from '../../language/visitor';
export function undefinedVarMessage(varName: string, opName: ?string): string {
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.
*/
export function NoUndefinedVariables(context: ValidationContext): ASTVisitor {
let variableNameDefined = Object.create(null);
return {
OperationDefinition: {
enter() {
variableNameDefined = Object.create(null);
},
leave(operation) {
const usages = context.getRecursiveVariableUsages(operation);
for (const { node } of usages) {
const varName = node.name.value;
if (variableNameDefined[varName] !== true) {
context.reportError(
new GraphQLError(
undefinedVarMessage(
varName,
operation.name && operation.name.value,
),
[node, operation],
),
);
}
}
},
},
VariableDefinition(node) {
variableNameDefined[node.variable.name.value] = true;
},
};
}
+63
View File
@@ -0,0 +1,63 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
export function undefinedVarMessage(varName, opName) {
return opName ? "Variable \"$".concat(varName, "\" is not defined by operation \"").concat(opName, "\".") : "Variable \"$".concat(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.
*/
export 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);
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = usages[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var _ref2 = _step.value;
var node = _ref2.node;
var varName = node.name.value;
if (variableNameDefined[varName] !== true) {
context.reportError(new GraphQLError(undefinedVarMessage(varName, operation.name && operation.name.value), [node, operation]));
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
}
},
VariableDefinition: function VariableDefinition(node) {
variableNameDefined[node.variable.name.value] = true;
}
};
}
+84
View File
@@ -0,0 +1,84 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.unusedFragMessage = unusedFragMessage;
exports.NoUnusedFragments = NoUnusedFragments;
var _GraphQLError = require("../../error/GraphQLError");
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
function unusedFragMessage(fragName) {
return "Fragment \"".concat(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);
for (var _i = 0; _i < operationDefs.length; _i++) {
var operation = operationDefs[_i];
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = context.getRecursivelyReferencedFragments(operation)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var fragment = _step.value;
fragmentNameUsed[fragment.name.value] = true;
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
}
for (var _i2 = 0; _i2 < fragmentDefs.length; _i2++) {
var fragmentDef = fragmentDefs[_i2];
var fragName = fragmentDef.name.value;
if (fragmentNameUsed[fragName] !== true) {
context.reportError(new _GraphQLError.GraphQLError(unusedFragMessage(fragName), [fragmentDef]));
}
}
}
}
};
}
+59
View File
@@ -0,0 +1,59 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type { ValidationContext } from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import type { ASTVisitor } from '../../language/visitor';
export function unusedFragMessage(fragName: string): string {
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.
*/
export function NoUnusedFragments(context: ValidationContext): ASTVisitor {
const operationDefs = [];
const fragmentDefs = [];
return {
OperationDefinition(node) {
operationDefs.push(node);
return false;
},
FragmentDefinition(node) {
fragmentDefs.push(node);
return false;
},
Document: {
leave() {
const fragmentNameUsed = Object.create(null);
for (const operation of operationDefs) {
for (const fragment of context.getRecursivelyReferencedFragments(
operation,
)) {
fragmentNameUsed[fragment.name.value] = true;
}
}
for (const fragmentDef of fragmentDefs) {
const fragName = fragmentDef.name.value;
if (fragmentNameUsed[fragName] !== true) {
context.reportError(
new GraphQLError(unusedFragMessage(fragName), [fragmentDef]),
);
}
}
},
},
};
}
+74
View File
@@ -0,0 +1,74 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
export function unusedFragMessage(fragName) {
return "Fragment \"".concat(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.
*/
export 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);
for (var _i = 0; _i < operationDefs.length; _i++) {
var operation = operationDefs[_i];
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = context.getRecursivelyReferencedFragments(operation)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var fragment = _step.value;
fragmentNameUsed[fragment.name.value] = true;
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
}
for (var _i2 = 0; _i2 < fragmentDefs.length; _i2++) {
var fragmentDef = fragmentDefs[_i2];
var fragName = fragmentDef.name.value;
if (fragmentNameUsed[fragName] !== true) {
context.reportError(new GraphQLError(unusedFragMessage(fragName), [fragmentDef]));
}
}
}
}
};
}
+80
View File
@@ -0,0 +1,80 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.unusedVariableMessage = unusedVariableMessage;
exports.NoUnusedVariables = NoUnusedVariables;
var _GraphQLError = require("../../error/GraphQLError");
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
function unusedVariableMessage(varName, opName) {
return opName ? "Variable \"$".concat(varName, "\" is never used in operation \"").concat(opName, "\".") : "Variable \"$".concat(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;
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = usages[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var _ref2 = _step.value;
var node = _ref2.node;
variableNameUsed[node.name.value] = true;
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
for (var _i = 0; _i < variableDefs.length; _i++) {
var variableDef = variableDefs[_i];
var variableName = variableDef.variable.name.value;
if (variableNameUsed[variableName] !== true) {
context.reportError(new _GraphQLError.GraphQLError(unusedVariableMessage(variableName, opName), [variableDef]));
}
}
}
},
VariableDefinition: function VariableDefinition(def) {
variableDefs.push(def);
}
};
}
+62
View File
@@ -0,0 +1,62 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type { ValidationContext } from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import type { ASTVisitor } from '../../language/visitor';
export function unusedVariableMessage(
varName: string,
opName: ?string,
): string {
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.
*/
export function NoUnusedVariables(context: ValidationContext): ASTVisitor {
let variableDefs = [];
return {
OperationDefinition: {
enter() {
variableDefs = [];
},
leave(operation) {
const variableNameUsed = Object.create(null);
const usages = context.getRecursiveVariableUsages(operation);
const opName = operation.name ? operation.name.value : null;
for (const { node } of usages) {
variableNameUsed[node.name.value] = true;
}
for (const variableDef of variableDefs) {
const variableName = variableDef.variable.name.value;
if (variableNameUsed[variableName] !== true) {
context.reportError(
new GraphQLError(unusedVariableMessage(variableName, opName), [
variableDef,
]),
);
}
}
},
},
VariableDefinition(def) {
variableDefs.push(def);
},
};
}
+70
View File
@@ -0,0 +1,70 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
export function unusedVariableMessage(varName, opName) {
return opName ? "Variable \"$".concat(varName, "\" is never used in operation \"").concat(opName, "\".") : "Variable \"$".concat(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.
*/
export 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;
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = usages[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var _ref2 = _step.value;
var node = _ref2.node;
variableNameUsed[node.name.value] = true;
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
for (var _i = 0; _i < variableDefs.length; _i++) {
var variableDef = variableDefs[_i];
var variableName = variableDef.variable.name.value;
if (variableNameUsed[variableName] !== true) {
context.reportError(new GraphQLError(unusedVariableMessage(variableName, opName), [variableDef]));
}
}
}
},
VariableDefinition: function VariableDefinition(def) {
variableDefs.push(def);
}
};
}
@@ -0,0 +1,595 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.fieldsConflictMessage = fieldsConflictMessage;
exports.OverlappingFieldsCanBeMerged = OverlappingFieldsCanBeMerged;
var _GraphQLError = require("../../error/GraphQLError");
var _inspect = _interopRequireDefault(require("../../jsutils/inspect"));
var _find = _interopRequireDefault(require("../../jsutils/find"));
var _kinds = require("../../language/kinds");
var _printer = require("../../language/printer");
var _definition = require("../../type/definition");
var _typeFromAST = require("../../utilities/typeFromAST");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function fieldsConflictMessage(responseName, reason) {
return "Fields \"".concat(responseName, "\" conflict because ").concat(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 \"".concat(responseName, "\" conflict because ").concat(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 comparedFragmentPairs = 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, comparedFragmentPairs, context.getParentType(), selectionSet);
for (var _i = 0; _i < conflicts.length; _i++) {
var _ref3 = conflicts[_i];
var _ref2$ = _ref3[0];
var responseName = _ref2$[0];
var reason = _ref2$[1];
var fields1 = _ref3[1];
var fields2 = _ref3[2];
context.reportError(new _GraphQLError.GraphQLError(fieldsConflictMessage(responseName, reason), fields1.concat(fields2)));
}
}
};
}
/**
* 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, comparedFragmentPairs, 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, comparedFragmentPairs, fieldMap);
if (fragmentNames.length !== 0) {
// (B) Then collect conflicts between these fields and those represented by
// each spread fragment name found.
var comparedFragments = Object.create(null);
for (var i = 0; i < fragmentNames.length; i++) {
collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, comparedFragmentPairs, 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, comparedFragmentPairs, 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, comparedFragmentPairs, areMutuallyExclusive, fieldMap, fragmentName) {
// Memoize so a fragment is not compared for conflicts more than once.
if (comparedFragments[fragmentName]) {
return;
}
comparedFragments[fragmentName] = true;
var fragment = context.getFragment(fragmentName);
if (!fragment) {
return;
}
var _getReferencedFieldsA = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment),
fieldMap2 = _getReferencedFieldsA[0],
fragmentNames2 = _getReferencedFieldsA[1]; // Do not compare a fragment's fieldMap to itself.
if (fieldMap === fieldMap2) {
return;
} // (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, comparedFragmentPairs, 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, comparedFragmentPairs, areMutuallyExclusive, fieldMap, fragmentNames2[i]);
}
} // Collect all conflicts found between two fragments, including via spreading in
// any nested fragments.
function collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fragmentName1, fragmentName2) {
// No need to compare a fragment to itself.
if (fragmentName1 === fragmentName2) {
return;
} // Memoize so two fragments are not compared for conflicts more than once.
if (comparedFragmentPairs.has(fragmentName1, fragmentName2, areMutuallyExclusive)) {
return;
}
comparedFragmentPairs.add(fragmentName1, fragmentName2, areMutuallyExclusive);
var fragment1 = context.getFragment(fragmentName1);
var fragment2 = context.getFragment(fragmentName2);
if (!fragment1 || !fragment2) {
return;
}
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, comparedFragmentPairs, 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, comparedFragmentPairs, 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, comparedFragmentPairs, 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, comparedFragmentPairs, 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, comparedFragmentPairs, areMutuallyExclusive, fieldMap1, fieldMap2); // (I) Then collect conflicts between the first collection of fields and
// those referenced by each fragment name associated with the second.
if (fragmentNames2.length !== 0) {
var comparedFragments = Object.create(null);
for (var j = 0; j < fragmentNames2.length; j++) {
collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, comparedFragmentPairs, 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.
if (fragmentNames1.length !== 0) {
var _comparedFragments = Object.create(null);
for (var i = 0; i < fragmentNames1.length; i++) {
collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, _comparedFragments, comparedFragmentPairs, 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 _i2 = 0; _i2 < fragmentNames1.length; _i2++) {
for (var _j = 0; _j < fragmentNames2.length; _j++) {
collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fragmentNames1[_i2], fragmentNames2[_j]);
}
}
return conflicts;
} // Collect all Conflicts "within" one collection of fields.
function collectConflictsWithin(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, 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.
var _arr = Object.keys(fieldMap);
for (var _i3 = 0; _i3 < _arr.length; _i3++) {
var responseName = _arr[_i3];
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, comparedFragmentPairs, 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, comparedFragmentPairs, 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.
var _arr2 = Object.keys(fieldMap1);
for (var _i4 = 0; _i4 < _arr2.length; _i4++) {
var responseName = _arr2[_i4];
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, comparedFragmentPairs, 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, comparedFragmentPairs, 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 && (0, _definition.isObjectType)(parentType1) && (0, _definition.isObjectType)(parentType2); // 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, "".concat(name1, " and ").concat(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 ".concat((0, _inspect.default)(type1), " and ").concat((0, _inspect.default)(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, comparedFragmentPairs, 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, _find.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 ((0, _definition.isListType)(type1)) {
return (0, _definition.isListType)(type2) ? doTypesConflict(type1.ofType, type2.ofType) : true;
}
if ((0, _definition.isListType)(type2)) {
return true;
}
if ((0, _definition.isNonNullType)(type1)) {
return (0, _definition.isNonNullType)(type2) ? doTypesConflict(type1.ofType, type2.ofType) : true;
}
if ((0, _definition.isNonNullType)(type2)) {
return 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 = Object.create(null);
var fragmentNames = Object.create(null);
_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.Kind.FIELD:
var fieldName = selection.name.value;
var fieldDef = void 0;
if ((0, _definition.isObjectType)(parentType) || (0, _definition.isInterfaceType)(parentType)) {
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.Kind.FRAGMENT_SPREAD:
fragmentNames[selection.name.value] = true;
break;
case _kinds.Kind.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 (_ref4) {
var reason = _ref4[0];
return reason;
})], conflicts.reduce(function (allFields, _ref5) {
var fields1 = _ref5[1];
return allFields.concat(fields1);
}, [node1]), conflicts.reduce(function (allFields, _ref6) {
var fields2 = _ref6[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 =
/*#__PURE__*/
function () {
function PairSet() {
_defineProperty(this, "_data", void 0);
this._data = Object.create(null);
}
var _proto = PairSet.prototype;
_proto.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;
};
_proto.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;
}
@@ -0,0 +1,848 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type { ValidationContext } from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import inspect from '../../jsutils/inspect';
import find from '../../jsutils/find';
import type { ObjMap } from '../../jsutils/ObjMap';
import type {
SelectionSetNode,
FieldNode,
ArgumentNode,
FragmentDefinitionNode,
} from '../../language/ast';
import { Kind } from '../../language/kinds';
import { print } from '../../language/printer';
import type { ASTVisitor } from '../../language/visitor';
import {
getNamedType,
isNonNullType,
isLeafType,
isObjectType,
isListType,
isInterfaceType,
} from '../../type/definition';
import type {
GraphQLNamedType,
GraphQLOutputType,
GraphQLCompositeType,
GraphQLField,
} from '../../type/definition';
import { typeFromAST } from '../../utilities/typeFromAST';
export function fieldsConflictMessage(
responseName: string,
reason: ConflictReasonMessage,
): string {
return (
`Fields "${responseName}" conflict because ${reasonMessage(reason)}` +
'. Use different aliases on the fields to fetch both if this was ' +
'intentional.'
);
}
function reasonMessage(reason: ConflictReasonMessage): string {
if (Array.isArray(reason)) {
return reason
.map(
([responseName, subreason]) =>
`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.
*/
export function OverlappingFieldsCanBeMerged(
context: ValidationContext,
): ASTVisitor {
// 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.
const comparedFragmentPairs = 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.
const cachedFieldsAndFragmentNames = new Map();
return {
SelectionSet(selectionSet) {
const conflicts = findConflictsWithinSelectionSet(
context,
cachedFieldsAndFragmentNames,
comparedFragmentPairs,
context.getParentType(),
selectionSet,
);
for (const [[responseName, reason], fields1, fields2] of conflicts) {
context.reportError(
new GraphQLError(
fieldsConflictMessage(responseName, reason),
fields1.concat(fields2),
),
);
}
},
};
}
type Conflict = [ConflictReason, Array<FieldNode>, Array<FieldNode>];
// Field name and reason.
type ConflictReason = [string, ConflictReasonMessage];
// Reason is a string, or a nested list of conflicts.
type ConflictReasonMessage = string | Array<ConflictReason>;
// Tuple defining a field node in a context.
type NodeAndDef = [GraphQLCompositeType, FieldNode, ?GraphQLField<*, *>];
// Map of array of those.
type NodeAndDefCollection = ObjMap<Array<NodeAndDef>>;
/**
* 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: ValidationContext,
cachedFieldsAndFragmentNames,
comparedFragmentPairs: PairSet,
parentType: ?GraphQLNamedType,
selectionSet: SelectionSetNode,
): Array<Conflict> {
const conflicts = [];
const [fieldMap, fragmentNames] = getFieldsAndFragmentNames(
context,
cachedFieldsAndFragmentNames,
parentType,
selectionSet,
);
// (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,
comparedFragmentPairs,
fieldMap,
);
if (fragmentNames.length !== 0) {
// (B) Then collect conflicts between these fields and those represented by
// each spread fragment name found.
const comparedFragments = Object.create(null);
for (let i = 0; i < fragmentNames.length; i++) {
collectConflictsBetweenFieldsAndFragment(
context,
conflicts,
cachedFieldsAndFragmentNames,
comparedFragments,
comparedFragmentPairs,
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 (let j = i + 1; j < fragmentNames.length; j++) {
collectConflictsBetweenFragments(
context,
conflicts,
cachedFieldsAndFragmentNames,
comparedFragmentPairs,
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: ValidationContext,
conflicts: Array<Conflict>,
cachedFieldsAndFragmentNames,
comparedFragments: ObjMap<boolean>,
comparedFragmentPairs: PairSet,
areMutuallyExclusive: boolean,
fieldMap: NodeAndDefCollection,
fragmentName: string,
): void {
// Memoize so a fragment is not compared for conflicts more than once.
if (comparedFragments[fragmentName]) {
return;
}
comparedFragments[fragmentName] = true;
const fragment = context.getFragment(fragmentName);
if (!fragment) {
return;
}
const [fieldMap2, fragmentNames2] = getReferencedFieldsAndFragmentNames(
context,
cachedFieldsAndFragmentNames,
fragment,
);
// Do not compare a fragment's fieldMap to itself.
if (fieldMap === fieldMap2) {
return;
}
// (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,
comparedFragmentPairs,
areMutuallyExclusive,
fieldMap,
fieldMap2,
);
// (E) Then collect any conflicts between the provided collection of fields
// and any fragment names found in the given fragment.
for (let i = 0; i < fragmentNames2.length; i++) {
collectConflictsBetweenFieldsAndFragment(
context,
conflicts,
cachedFieldsAndFragmentNames,
comparedFragments,
comparedFragmentPairs,
areMutuallyExclusive,
fieldMap,
fragmentNames2[i],
);
}
}
// Collect all conflicts found between two fragments, including via spreading in
// any nested fragments.
function collectConflictsBetweenFragments(
context: ValidationContext,
conflicts: Array<Conflict>,
cachedFieldsAndFragmentNames,
comparedFragmentPairs: PairSet,
areMutuallyExclusive: boolean,
fragmentName1: string,
fragmentName2: string,
): void {
// No need to compare a fragment to itself.
if (fragmentName1 === fragmentName2) {
return;
}
// Memoize so two fragments are not compared for conflicts more than once.
if (
comparedFragmentPairs.has(
fragmentName1,
fragmentName2,
areMutuallyExclusive,
)
) {
return;
}
comparedFragmentPairs.add(fragmentName1, fragmentName2, areMutuallyExclusive);
const fragment1 = context.getFragment(fragmentName1);
const fragment2 = context.getFragment(fragmentName2);
if (!fragment1 || !fragment2) {
return;
}
const [fieldMap1, fragmentNames1] = getReferencedFieldsAndFragmentNames(
context,
cachedFieldsAndFragmentNames,
fragment1,
);
const [fieldMap2, fragmentNames2] = getReferencedFieldsAndFragmentNames(
context,
cachedFieldsAndFragmentNames,
fragment2,
);
// (F) First, collect all conflicts between these two collections of fields
// (not including any nested fragments).
collectConflictsBetween(
context,
conflicts,
cachedFieldsAndFragmentNames,
comparedFragmentPairs,
areMutuallyExclusive,
fieldMap1,
fieldMap2,
);
// (G) Then collect conflicts between the first fragment and any nested
// fragments spread in the second fragment.
for (let j = 0; j < fragmentNames2.length; j++) {
collectConflictsBetweenFragments(
context,
conflicts,
cachedFieldsAndFragmentNames,
comparedFragmentPairs,
areMutuallyExclusive,
fragmentName1,
fragmentNames2[j],
);
}
// (G) Then collect conflicts between the second fragment and any nested
// fragments spread in the first fragment.
for (let i = 0; i < fragmentNames1.length; i++) {
collectConflictsBetweenFragments(
context,
conflicts,
cachedFieldsAndFragmentNames,
comparedFragmentPairs,
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: ValidationContext,
cachedFieldsAndFragmentNames,
comparedFragmentPairs: PairSet,
areMutuallyExclusive: boolean,
parentType1: ?GraphQLNamedType,
selectionSet1: SelectionSetNode,
parentType2: ?GraphQLNamedType,
selectionSet2: SelectionSetNode,
): Array<Conflict> {
const conflicts = [];
const [fieldMap1, fragmentNames1] = getFieldsAndFragmentNames(
context,
cachedFieldsAndFragmentNames,
parentType1,
selectionSet1,
);
const [fieldMap2, fragmentNames2] = getFieldsAndFragmentNames(
context,
cachedFieldsAndFragmentNames,
parentType2,
selectionSet2,
);
// (H) First, collect all conflicts between these two collections of field.
collectConflictsBetween(
context,
conflicts,
cachedFieldsAndFragmentNames,
comparedFragmentPairs,
areMutuallyExclusive,
fieldMap1,
fieldMap2,
);
// (I) Then collect conflicts between the first collection of fields and
// those referenced by each fragment name associated with the second.
if (fragmentNames2.length !== 0) {
const comparedFragments = Object.create(null);
for (let j = 0; j < fragmentNames2.length; j++) {
collectConflictsBetweenFieldsAndFragment(
context,
conflicts,
cachedFieldsAndFragmentNames,
comparedFragments,
comparedFragmentPairs,
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.
if (fragmentNames1.length !== 0) {
const comparedFragments = Object.create(null);
for (let i = 0; i < fragmentNames1.length; i++) {
collectConflictsBetweenFieldsAndFragment(
context,
conflicts,
cachedFieldsAndFragmentNames,
comparedFragments,
comparedFragmentPairs,
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 (let i = 0; i < fragmentNames1.length; i++) {
for (let j = 0; j < fragmentNames2.length; j++) {
collectConflictsBetweenFragments(
context,
conflicts,
cachedFieldsAndFragmentNames,
comparedFragmentPairs,
areMutuallyExclusive,
fragmentNames1[i],
fragmentNames2[j],
);
}
}
return conflicts;
}
// Collect all Conflicts "within" one collection of fields.
function collectConflictsWithin(
context: ValidationContext,
conflicts: Array<Conflict>,
cachedFieldsAndFragmentNames,
comparedFragmentPairs: PairSet,
fieldMap: NodeAndDefCollection,
): void {
// 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.
for (const responseName of Object.keys(fieldMap)) {
const 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 (let i = 0; i < fields.length; i++) {
for (let j = i + 1; j < fields.length; j++) {
const conflict = findConflict(
context,
cachedFieldsAndFragmentNames,
comparedFragmentPairs,
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: ValidationContext,
conflicts: Array<Conflict>,
cachedFieldsAndFragmentNames,
comparedFragmentPairs: PairSet,
parentFieldsAreMutuallyExclusive: boolean,
fieldMap1: NodeAndDefCollection,
fieldMap2: NodeAndDefCollection,
): void {
// 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.
for (const responseName of Object.keys(fieldMap1)) {
const fields2 = fieldMap2[responseName];
if (fields2) {
const fields1 = fieldMap1[responseName];
for (let i = 0; i < fields1.length; i++) {
for (let j = 0; j < fields2.length; j++) {
const conflict = findConflict(
context,
cachedFieldsAndFragmentNames,
comparedFragmentPairs,
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: ValidationContext,
cachedFieldsAndFragmentNames,
comparedFragmentPairs: PairSet,
parentFieldsAreMutuallyExclusive: boolean,
responseName: string,
field1: NodeAndDef,
field2: NodeAndDef,
): ?Conflict {
const [parentType1, node1, def1] = field1;
const [parentType2, node2, def2] = field2;
// 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.
const areMutuallyExclusive =
parentFieldsAreMutuallyExclusive ||
(parentType1 !== parentType2 &&
isObjectType(parentType1) &&
isObjectType(parentType2));
// The return type for each field.
const type1 = def1 && def1.type;
const type2 = def2 && def2.type;
if (!areMutuallyExclusive) {
// Two aliases must refer to the same field.
const name1 = node1.name.value;
const 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 ${inspect(type1)} and ${inspect(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.
const selectionSet1 = node1.selectionSet;
const selectionSet2 = node2.selectionSet;
if (selectionSet1 && selectionSet2) {
const conflicts = findConflictsBetweenSubSelectionSets(
context,
cachedFieldsAndFragmentNames,
comparedFragmentPairs,
areMutuallyExclusive,
getNamedType(type1),
selectionSet1,
getNamedType(type2),
selectionSet2,
);
return subfieldConflicts(conflicts, responseName, node1, node2);
}
}
function sameArguments(
arguments1: $ReadOnlyArray<ArgumentNode>,
arguments2: $ReadOnlyArray<ArgumentNode>,
): boolean {
if (arguments1.length !== arguments2.length) {
return false;
}
return arguments1.every(argument1 => {
const argument2 = find(
arguments2,
argument => argument.name.value === argument1.name.value,
);
if (!argument2) {
return false;
}
return sameValue(argument1.value, argument2.value);
});
}
function sameValue(value1, value2) {
return (!value1 && !value2) || print(value1) === 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: GraphQLOutputType,
type2: GraphQLOutputType,
): boolean {
if (isListType(type1)) {
return isListType(type2)
? doTypesConflict(type1.ofType, type2.ofType)
: true;
}
if (isListType(type2)) {
return true;
}
if (isNonNullType(type1)) {
return isNonNullType(type2)
? doTypesConflict(type1.ofType, type2.ofType)
: true;
}
if (isNonNullType(type2)) {
return true;
}
if (isLeafType(type1) || 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: ValidationContext,
cachedFieldsAndFragmentNames,
parentType: ?GraphQLNamedType,
selectionSet: SelectionSetNode,
): [NodeAndDefCollection, Array<string>] {
let cached = cachedFieldsAndFragmentNames.get(selectionSet);
if (!cached) {
const nodeAndDefs = Object.create(null);
const fragmentNames = Object.create(null);
_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: ValidationContext,
cachedFieldsAndFragmentNames,
fragment: FragmentDefinitionNode,
) {
// Short-circuit building a type from the node if possible.
const cached = cachedFieldsAndFragmentNames.get(fragment.selectionSet);
if (cached) {
return cached;
}
const fragmentType = typeFromAST(context.getSchema(), fragment.typeCondition);
return getFieldsAndFragmentNames(
context,
cachedFieldsAndFragmentNames,
fragmentType,
fragment.selectionSet,
);
}
function _collectFieldsAndFragmentNames(
context: ValidationContext,
parentType: ?GraphQLNamedType,
selectionSet: SelectionSetNode,
nodeAndDefs,
fragmentNames,
): void {
for (let i = 0; i < selectionSet.selections.length; i++) {
const selection = selectionSet.selections[i];
switch (selection.kind) {
case Kind.FIELD:
const fieldName = selection.name.value;
let fieldDef;
if (isObjectType(parentType) || isInterfaceType(parentType)) {
fieldDef = parentType.getFields()[fieldName];
}
const responseName = selection.alias
? selection.alias.value
: fieldName;
if (!nodeAndDefs[responseName]) {
nodeAndDefs[responseName] = [];
}
nodeAndDefs[responseName].push([parentType, selection, fieldDef]);
break;
case Kind.FRAGMENT_SPREAD:
fragmentNames[selection.name.value] = true;
break;
case Kind.INLINE_FRAGMENT:
const typeCondition = selection.typeCondition;
const inlineFragmentType = typeCondition
? 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: Array<Conflict>,
responseName: string,
node1: FieldNode,
node2: FieldNode,
): ?Conflict {
if (conflicts.length > 0) {
return [
[responseName, conflicts.map(([reason]) => reason)],
conflicts.reduce((allFields, [, fields1]) => allFields.concat(fields1), [
node1,
]),
conflicts.reduce(
(allFields, [, , fields2]) => 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.
*/
class PairSet {
_data: ObjMap<ObjMap<boolean>>;
constructor(): void {
this._data = Object.create(null);
}
has(a: string, b: string, areMutuallyExclusive: boolean) {
const first = this._data[a];
const 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;
}
add(a: string, b: string, areMutuallyExclusive: boolean) {
_pairSetAdd(this._data, a, b, areMutuallyExclusive);
_pairSetAdd(this._data, b, a, areMutuallyExclusive);
}
}
function _pairSetAdd(data, a, b, areMutuallyExclusive) {
let map = data[a];
if (!map) {
map = Object.create(null);
data[a] = map;
}
map[b] = areMutuallyExclusive;
}
@@ -0,0 +1,586 @@
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
import inspect from '../../jsutils/inspect';
import find from '../../jsutils/find';
import { Kind } from '../../language/kinds';
import { print } from '../../language/printer';
import { getNamedType, isNonNullType, isLeafType, isObjectType, isListType, isInterfaceType } from '../../type/definition';
import { typeFromAST } from '../../utilities/typeFromAST';
export function fieldsConflictMessage(responseName, reason) {
return "Fields \"".concat(responseName, "\" conflict because ").concat(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 \"".concat(responseName, "\" conflict because ").concat(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.
*/
export 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 comparedFragmentPairs = 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, comparedFragmentPairs, context.getParentType(), selectionSet);
for (var _i = 0; _i < conflicts.length; _i++) {
var _ref3 = conflicts[_i];
var _ref2$ = _ref3[0];
var responseName = _ref2$[0];
var reason = _ref2$[1];
var fields1 = _ref3[1];
var fields2 = _ref3[2];
context.reportError(new GraphQLError(fieldsConflictMessage(responseName, reason), fields1.concat(fields2)));
}
}
};
}
/**
* 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, comparedFragmentPairs, 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, comparedFragmentPairs, fieldMap);
if (fragmentNames.length !== 0) {
// (B) Then collect conflicts between these fields and those represented by
// each spread fragment name found.
var comparedFragments = Object.create(null);
for (var i = 0; i < fragmentNames.length; i++) {
collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, comparedFragmentPairs, 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, comparedFragmentPairs, 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, comparedFragmentPairs, areMutuallyExclusive, fieldMap, fragmentName) {
// Memoize so a fragment is not compared for conflicts more than once.
if (comparedFragments[fragmentName]) {
return;
}
comparedFragments[fragmentName] = true;
var fragment = context.getFragment(fragmentName);
if (!fragment) {
return;
}
var _getReferencedFieldsA = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment),
fieldMap2 = _getReferencedFieldsA[0],
fragmentNames2 = _getReferencedFieldsA[1]; // Do not compare a fragment's fieldMap to itself.
if (fieldMap === fieldMap2) {
return;
} // (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, comparedFragmentPairs, 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, comparedFragmentPairs, areMutuallyExclusive, fieldMap, fragmentNames2[i]);
}
} // Collect all conflicts found between two fragments, including via spreading in
// any nested fragments.
function collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fragmentName1, fragmentName2) {
// No need to compare a fragment to itself.
if (fragmentName1 === fragmentName2) {
return;
} // Memoize so two fragments are not compared for conflicts more than once.
if (comparedFragmentPairs.has(fragmentName1, fragmentName2, areMutuallyExclusive)) {
return;
}
comparedFragmentPairs.add(fragmentName1, fragmentName2, areMutuallyExclusive);
var fragment1 = context.getFragment(fragmentName1);
var fragment2 = context.getFragment(fragmentName2);
if (!fragment1 || !fragment2) {
return;
}
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, comparedFragmentPairs, 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, comparedFragmentPairs, 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, comparedFragmentPairs, 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, comparedFragmentPairs, 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, comparedFragmentPairs, areMutuallyExclusive, fieldMap1, fieldMap2); // (I) Then collect conflicts between the first collection of fields and
// those referenced by each fragment name associated with the second.
if (fragmentNames2.length !== 0) {
var comparedFragments = Object.create(null);
for (var j = 0; j < fragmentNames2.length; j++) {
collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, comparedFragmentPairs, 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.
if (fragmentNames1.length !== 0) {
var _comparedFragments = Object.create(null);
for (var i = 0; i < fragmentNames1.length; i++) {
collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, _comparedFragments, comparedFragmentPairs, 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 _i2 = 0; _i2 < fragmentNames1.length; _i2++) {
for (var _j = 0; _j < fragmentNames2.length; _j++) {
collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fragmentNames1[_i2], fragmentNames2[_j]);
}
}
return conflicts;
} // Collect all Conflicts "within" one collection of fields.
function collectConflictsWithin(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, 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.
var _arr = Object.keys(fieldMap);
for (var _i3 = 0; _i3 < _arr.length; _i3++) {
var responseName = _arr[_i3];
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, comparedFragmentPairs, 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, comparedFragmentPairs, 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.
var _arr2 = Object.keys(fieldMap1);
for (var _i4 = 0; _i4 < _arr2.length; _i4++) {
var responseName = _arr2[_i4];
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, comparedFragmentPairs, 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, comparedFragmentPairs, 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 && isObjectType(parentType1) && isObjectType(parentType2); // 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, "".concat(name1, " and ").concat(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 ".concat(inspect(type1), " and ").concat(inspect(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, comparedFragmentPairs, areMutuallyExclusive, getNamedType(type1), selectionSet1, 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 = find(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 || print(value1) === 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 (isListType(type1)) {
return isListType(type2) ? doTypesConflict(type1.ofType, type2.ofType) : true;
}
if (isListType(type2)) {
return true;
}
if (isNonNullType(type1)) {
return isNonNullType(type2) ? doTypesConflict(type1.ofType, type2.ofType) : true;
}
if (isNonNullType(type2)) {
return true;
}
if (isLeafType(type1) || 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 = Object.create(null);
var fragmentNames = Object.create(null);
_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 = 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 Kind.FIELD:
var fieldName = selection.name.value;
var fieldDef = void 0;
if (isObjectType(parentType) || isInterfaceType(parentType)) {
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 Kind.FRAGMENT_SPREAD:
fragmentNames[selection.name.value] = true;
break;
case Kind.INLINE_FRAGMENT:
var typeCondition = selection.typeCondition;
var inlineFragmentType = typeCondition ? 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 (_ref4) {
var reason = _ref4[0];
return reason;
})], conflicts.reduce(function (allFields, _ref5) {
var fields1 = _ref5[1];
return allFields.concat(fields1);
}, [node1]), conflicts.reduce(function (allFields, _ref6) {
var fields2 = _ref6[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 =
/*#__PURE__*/
function () {
function PairSet() {
_defineProperty(this, "_data", void 0);
this._data = Object.create(null);
}
var _proto = PairSet.prototype;
_proto.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;
};
_proto.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;
}
@@ -0,0 +1,78 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.typeIncompatibleSpreadMessage = typeIncompatibleSpreadMessage;
exports.typeIncompatibleAnonSpreadMessage = typeIncompatibleAnonSpreadMessage;
exports.PossibleFragmentSpreads = PossibleFragmentSpreads;
var _inspect = _interopRequireDefault(require("../../jsutils/inspect"));
var _GraphQLError = require("../../error/GraphQLError");
var _typeComparators = require("../../utilities/typeComparators");
var _typeFromAST = require("../../utilities/typeFromAST");
var _definition = require("../../type/definition");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
function typeIncompatibleSpreadMessage(fragName, parentType, fragType) {
return "Fragment \"".concat(fragName, "\" cannot be spread here as objects of ") + "type \"".concat(parentType, "\" can never be of type \"").concat(fragType, "\".");
}
function typeIncompatibleAnonSpreadMessage(parentType, fragType) {
return 'Fragment cannot be spread here as objects of ' + "type \"".concat(parentType, "\" can never be of type \"").concat(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 ((0, _definition.isCompositeType)(fragType) && (0, _definition.isCompositeType)(parentType) && !(0, _typeComparators.doTypesOverlap)(context.getSchema(), fragType, parentType)) {
context.reportError(new _GraphQLError.GraphQLError(typeIncompatibleAnonSpreadMessage((0, _inspect.default)(parentType), (0, _inspect.default)(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 _GraphQLError.GraphQLError(typeIncompatibleSpreadMessage(fragName, (0, _inspect.default)(parentType), (0, _inspect.default)(fragType)), [node]));
}
}
};
}
function getFragmentType(context, name) {
var frag = context.getFragment(name);
if (frag) {
var type = (0, _typeFromAST.typeFromAST)(context.getSchema(), frag.typeCondition);
if ((0, _definition.isCompositeType)(type)) {
return type;
}
}
}
@@ -0,0 +1,101 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import inspect from '../../jsutils/inspect';
import type { ValidationContext } from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import type { ASTVisitor } from '../../language/visitor';
import { doTypesOverlap } from '../../utilities/typeComparators';
import { typeFromAST } from '../../utilities/typeFromAST';
import { isCompositeType } from '../../type/definition';
export function typeIncompatibleSpreadMessage(
fragName: string,
parentType: string,
fragType: string,
): string {
return (
`Fragment "${fragName}" cannot be spread here as objects of ` +
`type "${parentType}" can never be of type "${fragType}".`
);
}
export function typeIncompatibleAnonSpreadMessage(
parentType: string,
fragType: string,
): string {
return (
'Fragment cannot be spread here as objects of ' +
`type "${parentType}" can never be of type "${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.
*/
export function PossibleFragmentSpreads(
context: ValidationContext,
): ASTVisitor {
return {
InlineFragment(node) {
const fragType = context.getType();
const parentType = context.getParentType();
if (
isCompositeType(fragType) &&
isCompositeType(parentType) &&
!doTypesOverlap(context.getSchema(), fragType, parentType)
) {
context.reportError(
new GraphQLError(
typeIncompatibleAnonSpreadMessage(
inspect(parentType),
inspect(fragType),
),
[node],
),
);
}
},
FragmentSpread(node) {
const fragName = node.name.value;
const fragType = getFragmentType(context, fragName);
const parentType = context.getParentType();
if (
fragType &&
parentType &&
!doTypesOverlap(context.getSchema(), fragType, parentType)
) {
context.reportError(
new GraphQLError(
typeIncompatibleSpreadMessage(
fragName,
inspect(parentType),
inspect(fragType),
),
[node],
),
);
}
},
};
}
function getFragmentType(context, name) {
const frag = context.getFragment(name);
if (frag) {
const type = typeFromAST(context.getSchema(), frag.typeCondition);
if (isCompositeType(type)) {
return type;
}
}
}
@@ -0,0 +1,60 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import inspect from '../../jsutils/inspect';
import { GraphQLError } from '../../error/GraphQLError';
import { doTypesOverlap } from '../../utilities/typeComparators';
import { typeFromAST } from '../../utilities/typeFromAST';
import { isCompositeType } from '../../type/definition';
export function typeIncompatibleSpreadMessage(fragName, parentType, fragType) {
return "Fragment \"".concat(fragName, "\" cannot be spread here as objects of ") + "type \"".concat(parentType, "\" can never be of type \"").concat(fragType, "\".");
}
export function typeIncompatibleAnonSpreadMessage(parentType, fragType) {
return 'Fragment cannot be spread here as objects of ' + "type \"".concat(parentType, "\" can never be of type \"").concat(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.
*/
export function PossibleFragmentSpreads(context) {
return {
InlineFragment: function InlineFragment(node) {
var fragType = context.getType();
var parentType = context.getParentType();
if (isCompositeType(fragType) && isCompositeType(parentType) && !doTypesOverlap(context.getSchema(), fragType, parentType)) {
context.reportError(new GraphQLError(typeIncompatibleAnonSpreadMessage(inspect(parentType), inspect(fragType)), [node]));
}
},
FragmentSpread: function FragmentSpread(node) {
var fragName = node.name.value;
var fragType = getFragmentType(context, fragName);
var parentType = context.getParentType();
if (fragType && parentType && !doTypesOverlap(context.getSchema(), fragType, parentType)) {
context.reportError(new GraphQLError(typeIncompatibleSpreadMessage(fragName, inspect(parentType), inspect(fragType)), [node]));
}
}
};
}
function getFragmentType(context, name) {
var frag = context.getFragment(name);
if (frag) {
var type = typeFromAST(context.getSchema(), frag.typeCondition);
if (isCompositeType(type)) {
return type;
}
}
}
@@ -0,0 +1,185 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.missingFieldArgMessage = missingFieldArgMessage;
exports.missingDirectiveArgMessage = missingDirectiveArgMessage;
exports.ProvidedRequiredArguments = ProvidedRequiredArguments;
exports.ProvidedRequiredArgumentsOnDirectives = ProvidedRequiredArgumentsOnDirectives;
var _GraphQLError = require("../../error/GraphQLError");
var _kinds = require("../../language/kinds");
var _inspect = _interopRequireDefault(require("../../jsutils/inspect"));
var _keyMap = _interopRequireDefault(require("../../jsutils/keyMap"));
var _definition = require("../../type/definition");
var _printer = require("../../language/printer");
var _directives = require("../../type/directives");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function missingFieldArgMessage(fieldName, argName, type) {
return "Field \"".concat(fieldName, "\" argument \"").concat(argName, "\" of type ") + "\"".concat(type, "\" is required but not provided.");
}
function missingDirectiveArgMessage(directiveName, argName, type) {
return "Directive \"@".concat(directiveName, "\" argument \"").concat(argName, "\" of type ") + "\"".concat(type, "\" is required but not provided.");
}
/**
* Provided required arguments
*
* A field or directive is only valid if all required (non-null without a
* default value) field arguments have been provided.
*/
function ProvidedRequiredArguments(context) {
return _objectSpread({}, ProvidedRequiredArgumentsOnDirectives(context), {
Field: {
// Validate on leave to allow for deeper errors to appear first.
leave: function leave(fieldNode) {
var fieldDef = context.getFieldDef();
if (!fieldDef) {
return false;
}
var argNodes = fieldNode.arguments || [];
var argNodeMap = (0, _keyMap.default)(argNodes, function (arg) {
return arg.name.value;
});
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = fieldDef.args[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var argDef = _step.value;
var argNode = argNodeMap[argDef.name];
if (!argNode && (0, _definition.isRequiredArgument)(argDef)) {
context.reportError(new _GraphQLError.GraphQLError(missingFieldArgMessage(fieldDef.name, argDef.name, (0, _inspect.default)(argDef.type)), [fieldNode]));
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
}
}
});
} // @internal
function ProvidedRequiredArgumentsOnDirectives(context) {
var requiredArgsMap = Object.create(null);
var schema = context.getSchema();
var definedDirectives = schema ? schema.getDirectives() : _directives.specifiedDirectives;
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = definedDirectives[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var directive = _step2.value;
requiredArgsMap[directive.name] = (0, _keyMap.default)(directive.args.filter(_definition.isRequiredArgument), function (arg) {
return arg.name;
});
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
var astDefinitions = context.getDocument().definitions;
var _iteratorNormalCompletion3 = true;
var _didIteratorError3 = false;
var _iteratorError3 = undefined;
try {
for (var _iterator3 = astDefinitions[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
var def = _step3.value;
if (def.kind === _kinds.Kind.DIRECTIVE_DEFINITION) {
requiredArgsMap[def.name.value] = (0, _keyMap.default)(def.arguments ? def.arguments.filter(isRequiredArgumentNode) : [], function (arg) {
return arg.name.value;
});
}
}
} catch (err) {
_didIteratorError3 = true;
_iteratorError3 = err;
} finally {
try {
if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
_iterator3.return();
}
} finally {
if (_didIteratorError3) {
throw _iteratorError3;
}
}
}
return {
Directive: {
// Validate on leave to allow for deeper errors to appear first.
leave: function leave(directiveNode) {
var directiveName = directiveNode.name.value;
var requiredArgs = requiredArgsMap[directiveName];
if (requiredArgs) {
var argNodes = directiveNode.arguments || [];
var argNodeMap = (0, _keyMap.default)(argNodes, function (arg) {
return arg.name.value;
});
var _arr = Object.keys(requiredArgs);
for (var _i = 0; _i < _arr.length; _i++) {
var argName = _arr[_i];
if (!argNodeMap[argName]) {
var argType = requiredArgs[argName].type;
context.reportError(new _GraphQLError.GraphQLError(missingDirectiveArgMessage(directiveName, argName, (0, _definition.isType)(argType) ? (0, _inspect.default)(argType) : (0, _printer.print)(argType)), directiveNode));
}
}
}
}
}
};
}
function isRequiredArgumentNode(arg) {
return arg.type.kind === _kinds.Kind.NON_NULL_TYPE && arg.defaultValue == null;
}
@@ -0,0 +1,145 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type {
ValidationContext,
SDLValidationContext,
} from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import { Kind } from '../../language/kinds';
import inspect from '../../jsutils/inspect';
import keyMap from '../../jsutils/keyMap';
import { isType, isRequiredArgument } from '../../type/definition';
import type { ASTVisitor } from '../../language/visitor';
import { print } from '../../language/printer';
import { specifiedDirectives } from '../../type/directives';
export function missingFieldArgMessage(
fieldName: string,
argName: string,
type: string,
): string {
return (
`Field "${fieldName}" argument "${argName}" of type ` +
`"${type}" is required but not provided.`
);
}
export function missingDirectiveArgMessage(
directiveName: string,
argName: string,
type: string,
): string {
return (
`Directive "@${directiveName}" argument "${argName}" of type ` +
`"${type}" is required but not provided.`
);
}
/**
* Provided required arguments
*
* A field or directive is only valid if all required (non-null without a
* default value) field arguments have been provided.
*/
export function ProvidedRequiredArguments(
context: ValidationContext,
): ASTVisitor {
return {
...ProvidedRequiredArgumentsOnDirectives(context),
Field: {
// Validate on leave to allow for deeper errors to appear first.
leave(fieldNode) {
const fieldDef = context.getFieldDef();
if (!fieldDef) {
return false;
}
const argNodes = fieldNode.arguments || [];
const argNodeMap = keyMap(argNodes, arg => arg.name.value);
for (const argDef of fieldDef.args) {
const argNode = argNodeMap[argDef.name];
if (!argNode && isRequiredArgument(argDef)) {
context.reportError(
new GraphQLError(
missingFieldArgMessage(
fieldDef.name,
argDef.name,
inspect(argDef.type),
),
[fieldNode],
),
);
}
}
},
},
};
}
// @internal
export function ProvidedRequiredArgumentsOnDirectives(
context: ValidationContext | SDLValidationContext,
): ASTVisitor {
const requiredArgsMap = Object.create(null);
const schema = context.getSchema();
const definedDirectives = schema
? schema.getDirectives()
: specifiedDirectives;
for (const directive of definedDirectives) {
requiredArgsMap[directive.name] = keyMap(
directive.args.filter(isRequiredArgument),
arg => arg.name,
);
}
const astDefinitions = context.getDocument().definitions;
for (const def of astDefinitions) {
if (def.kind === Kind.DIRECTIVE_DEFINITION) {
requiredArgsMap[def.name.value] = keyMap(
def.arguments ? def.arguments.filter(isRequiredArgumentNode) : [],
arg => arg.name.value,
);
}
}
return {
Directive: {
// Validate on leave to allow for deeper errors to appear first.
leave(directiveNode) {
const directiveName = directiveNode.name.value;
const requiredArgs = requiredArgsMap[directiveName];
if (requiredArgs) {
const argNodes = directiveNode.arguments || [];
const argNodeMap = keyMap(argNodes, arg => arg.name.value);
for (const argName of Object.keys(requiredArgs)) {
if (!argNodeMap[argName]) {
const argType = requiredArgs[argName].type;
context.reportError(
new GraphQLError(
missingDirectiveArgMessage(
directiveName,
argName,
isType(argType) ? inspect(argType) : print(argType),
),
directiveNode,
),
);
}
}
}
},
},
};
}
function isRequiredArgumentNode(arg) {
return arg.type.kind === Kind.NON_NULL_TYPE && arg.defaultValue == null;
}
@@ -0,0 +1,171 @@
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
import { Kind } from '../../language/kinds';
import inspect from '../../jsutils/inspect';
import keyMap from '../../jsutils/keyMap';
import { isType, isRequiredArgument } from '../../type/definition';
import { print } from '../../language/printer';
import { specifiedDirectives } from '../../type/directives';
export function missingFieldArgMessage(fieldName, argName, type) {
return "Field \"".concat(fieldName, "\" argument \"").concat(argName, "\" of type ") + "\"".concat(type, "\" is required but not provided.");
}
export function missingDirectiveArgMessage(directiveName, argName, type) {
return "Directive \"@".concat(directiveName, "\" argument \"").concat(argName, "\" of type ") + "\"".concat(type, "\" is required but not provided.");
}
/**
* Provided required arguments
*
* A field or directive is only valid if all required (non-null without a
* default value) field arguments have been provided.
*/
export function ProvidedRequiredArguments(context) {
return _objectSpread({}, ProvidedRequiredArgumentsOnDirectives(context), {
Field: {
// Validate on leave to allow for deeper errors to appear first.
leave: function leave(fieldNode) {
var fieldDef = context.getFieldDef();
if (!fieldDef) {
return false;
}
var argNodes = fieldNode.arguments || [];
var argNodeMap = keyMap(argNodes, function (arg) {
return arg.name.value;
});
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = fieldDef.args[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var argDef = _step.value;
var argNode = argNodeMap[argDef.name];
if (!argNode && isRequiredArgument(argDef)) {
context.reportError(new GraphQLError(missingFieldArgMessage(fieldDef.name, argDef.name, inspect(argDef.type)), [fieldNode]));
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
}
}
});
} // @internal
export function ProvidedRequiredArgumentsOnDirectives(context) {
var requiredArgsMap = Object.create(null);
var schema = context.getSchema();
var definedDirectives = schema ? schema.getDirectives() : specifiedDirectives;
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = definedDirectives[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var directive = _step2.value;
requiredArgsMap[directive.name] = keyMap(directive.args.filter(isRequiredArgument), function (arg) {
return arg.name;
});
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
var astDefinitions = context.getDocument().definitions;
var _iteratorNormalCompletion3 = true;
var _didIteratorError3 = false;
var _iteratorError3 = undefined;
try {
for (var _iterator3 = astDefinitions[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
var def = _step3.value;
if (def.kind === Kind.DIRECTIVE_DEFINITION) {
requiredArgsMap[def.name.value] = keyMap(def.arguments ? def.arguments.filter(isRequiredArgumentNode) : [], function (arg) {
return arg.name.value;
});
}
}
} catch (err) {
_didIteratorError3 = true;
_iteratorError3 = err;
} finally {
try {
if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
_iterator3.return();
}
} finally {
if (_didIteratorError3) {
throw _iteratorError3;
}
}
}
return {
Directive: {
// Validate on leave to allow for deeper errors to appear first.
leave: function leave(directiveNode) {
var directiveName = directiveNode.name.value;
var requiredArgs = requiredArgsMap[directiveName];
if (requiredArgs) {
var argNodes = directiveNode.arguments || [];
var argNodeMap = keyMap(argNodes, function (arg) {
return arg.name.value;
});
var _arr = Object.keys(requiredArgs);
for (var _i = 0; _i < _arr.length; _i++) {
var argName = _arr[_i];
if (!argNodeMap[argName]) {
var argType = requiredArgs[argName].type;
context.reportError(new GraphQLError(missingDirectiveArgMessage(directiveName, argName, isType(argType) ? inspect(argType) : print(argType)), directiveNode));
}
}
}
}
}
};
}
function isRequiredArgumentNode(arg) {
return arg.type.kind === Kind.NON_NULL_TYPE && arg.defaultValue == null;
}
+58
View File
@@ -0,0 +1,58 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.noSubselectionAllowedMessage = noSubselectionAllowedMessage;
exports.requiredSubselectionMessage = requiredSubselectionMessage;
exports.ScalarLeafs = ScalarLeafs;
var _inspect = _interopRequireDefault(require("../../jsutils/inspect"));
var _GraphQLError = require("../../error/GraphQLError");
var _definition = require("../../type/definition");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
function noSubselectionAllowedMessage(fieldName, type) {
return "Field \"".concat(fieldName, "\" must not have a selection since ") + "type \"".concat(type, "\" has no subfields.");
}
function requiredSubselectionMessage(fieldName, type) {
return "Field \"".concat(fieldName, "\" of type \"").concat(type, "\" must have a ") + "selection of subfields. Did you mean \"".concat(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();
var selectionSet = node.selectionSet;
if (type) {
if ((0, _definition.isLeafType)((0, _definition.getNamedType)(type))) {
if (selectionSet) {
context.reportError(new _GraphQLError.GraphQLError(noSubselectionAllowedMessage(node.name.value, (0, _inspect.default)(type)), [selectionSet]));
}
} else if (!selectionSet) {
context.reportError(new _GraphQLError.GraphQLError(requiredSubselectionMessage(node.name.value, (0, _inspect.default)(type)), [node]));
}
}
}
};
}
+69
View File
@@ -0,0 +1,69 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import inspect from '../../jsutils/inspect';
import type { ValidationContext } from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import type { FieldNode } from '../../language/ast';
import { getNamedType, isLeafType } from '../../type/definition';
import type { ASTVisitor } from '../../language/visitor';
export function noSubselectionAllowedMessage(
fieldName: string,
type: string,
): string {
return (
`Field "${fieldName}" must not have a selection since ` +
`type "${type}" has no subfields.`
);
}
export function requiredSubselectionMessage(
fieldName: string,
type: string,
): string {
return (
`Field "${fieldName}" of type "${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.
*/
export function ScalarLeafs(context: ValidationContext): ASTVisitor {
return {
Field(node: FieldNode) {
const type = context.getType();
const selectionSet = node.selectionSet;
if (type) {
if (isLeafType(getNamedType(type))) {
if (selectionSet) {
context.reportError(
new GraphQLError(
noSubselectionAllowedMessage(node.name.value, inspect(type)),
[selectionSet],
),
);
}
} else if (!selectionSet) {
context.reportError(
new GraphQLError(
requiredSubselectionMessage(node.name.value, inspect(type)),
[node],
),
);
}
}
},
};
}
+42
View File
@@ -0,0 +1,42 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import inspect from '../../jsutils/inspect';
import { GraphQLError } from '../../error/GraphQLError';
import { getNamedType, isLeafType } from '../../type/definition';
export function noSubselectionAllowedMessage(fieldName, type) {
return "Field \"".concat(fieldName, "\" must not have a selection since ") + "type \"".concat(type, "\" has no subfields.");
}
export function requiredSubselectionMessage(fieldName, type) {
return "Field \"".concat(fieldName, "\" of type \"").concat(type, "\" must have a ") + "selection of subfields. Did you mean \"".concat(fieldName, " { ... }\"?");
}
/**
* Scalar leafs
*
* A GraphQL document is valid only if all leaf fields (fields without
* sub selections) are of scalar or enum types.
*/
export function ScalarLeafs(context) {
return {
Field: function Field(node) {
var type = context.getType();
var selectionSet = node.selectionSet;
if (type) {
if (isLeafType(getNamedType(type))) {
if (selectionSet) {
context.reportError(new GraphQLError(noSubselectionAllowedMessage(node.name.value, inspect(type)), [selectionSet]));
}
} else if (!selectionSet) {
context.reportError(new GraphQLError(requiredSubselectionMessage(node.name.value, inspect(type)), [node]));
}
}
}
};
}
@@ -0,0 +1,39 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.singleFieldOnlyMessage = singleFieldOnlyMessage;
exports.SingleFieldSubscriptions = SingleFieldSubscriptions;
var _GraphQLError = require("../../error/GraphQLError");
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
function singleFieldOnlyMessage(name) {
return (name ? "Subscription \"".concat(name, "\" ") : 'Anonymous Subscription ') + 'must select only one top level field.';
}
/**
* Subscriptions must only include one field.
*
* A GraphQL subscription is valid only if it contains a single root field.
*/
function SingleFieldSubscriptions(context) {
return {
OperationDefinition: function OperationDefinition(node) {
if (node.operation === 'subscription') {
if (node.selectionSet.selections.length !== 1) {
context.reportError(new _GraphQLError.GraphQLError(singleFieldOnlyMessage(node.name && node.name.value), node.selectionSet.selections.slice(1)));
}
}
}
};
}
@@ -0,0 +1,44 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type { ASTValidationContext } from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import type { OperationDefinitionNode } from '../../language/ast';
import type { ASTVisitor } from '../../language/visitor';
export function singleFieldOnlyMessage(name: ?string): string {
return (
(name ? `Subscription "${name}" ` : 'Anonymous Subscription ') +
'must select only one top level field.'
);
}
/**
* Subscriptions must only include one field.
*
* A GraphQL subscription is valid only if it contains a single root field.
*/
export function SingleFieldSubscriptions(
context: ASTValidationContext,
): ASTVisitor {
return {
OperationDefinition(node: OperationDefinitionNode) {
if (node.operation === 'subscription') {
if (node.selectionSet.selections.length !== 1) {
context.reportError(
new GraphQLError(
singleFieldOnlyMessage(node.name && node.name.value),
node.selectionSet.selections.slice(1),
),
);
}
}
},
};
}
@@ -0,0 +1,29 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
export function singleFieldOnlyMessage(name) {
return (name ? "Subscription \"".concat(name, "\" ") : 'Anonymous Subscription ') + 'must select only one top level field.';
}
/**
* Subscriptions must only include one field.
*
* A GraphQL subscription is valid only if it contains a single root field.
*/
export function SingleFieldSubscriptions(context) {
return {
OperationDefinition: function OperationDefinition(node) {
if (node.operation === 'subscription') {
if (node.selectionSet.selections.length !== 1) {
context.reportError(new GraphQLError(singleFieldOnlyMessage(node.name && node.name.value), node.selectionSet.selections.slice(1)));
}
}
}
};
}
+51
View File
@@ -0,0 +1,51 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.duplicateArgMessage = duplicateArgMessage;
exports.UniqueArgumentNames = UniqueArgumentNames;
var _GraphQLError = require("../../error/GraphQLError");
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
function duplicateArgMessage(argName) {
return "There can be only one argument named \"".concat(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 _GraphQLError.GraphQLError(duplicateArgMessage(argName), [knownArgNames[argName], node.name]));
} else {
knownArgNames[argName] = node.name;
}
return false;
}
};
}
@@ -0,0 +1,48 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type { ASTValidationContext } from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import type { ASTVisitor } from '../../language/visitor';
export function duplicateArgMessage(argName: string): string {
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.
*/
export function UniqueArgumentNames(context: ASTValidationContext): ASTVisitor {
let knownArgNames = Object.create(null);
return {
Field() {
knownArgNames = Object.create(null);
},
Directive() {
knownArgNames = Object.create(null);
},
Argument(node) {
const argName = node.name.value;
if (knownArgNames[argName]) {
context.reportError(
new GraphQLError(duplicateArgMessage(argName), [
knownArgNames[argName],
node.name,
]),
);
} else {
knownArgNames[argName] = node.name;
}
return false;
},
};
}
+41
View File
@@ -0,0 +1,41 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
export function duplicateArgMessage(argName) {
return "There can be only one argument named \"".concat(argName, "\".");
}
/**
* Unique argument names
*
* A GraphQL field or directive is only valid if all supplied arguments are
* uniquely named.
*/
export 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 GraphQLError(duplicateArgMessage(argName), [knownArgNames[argName], node.name]));
} else {
knownArgNames[argName] = node.name;
}
return false;
}
};
}
@@ -0,0 +1,73 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.duplicateDirectiveMessage = duplicateDirectiveMessage;
exports.UniqueDirectivesPerLocation = UniqueDirectivesPerLocation;
var _GraphQLError = require("../../error/GraphQLError");
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
function duplicateDirectiveMessage(directiveName) {
return "The directive \"".concat(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) {
// Flow can't refine that node.directives will only contain directives,
var directives = node.directives;
if (directives) {
var knownDirectives = Object.create(null);
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = directives[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var directive = _step.value;
var directiveName = directive.name.value;
if (knownDirectives[directiveName]) {
context.reportError(new _GraphQLError.GraphQLError(duplicateDirectiveMessage(directiveName), [knownDirectives[directiveName], directive]));
} else {
knownDirectives[directiveName] = directive;
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
}
}
};
}
@@ -0,0 +1,57 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type { ASTValidationContext } from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import type { DirectiveNode } from '../../language/ast';
import type { ASTVisitor } from '../../language/visitor';
export function duplicateDirectiveMessage(directiveName: string): string {
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.
*/
export function UniqueDirectivesPerLocation(
context: ASTValidationContext,
): ASTVisitor {
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(node) {
// Flow can't refine that node.directives will only contain directives,
// so we cast so the rest of the code is well typed.
const directives: ?$ReadOnlyArray<DirectiveNode> = (node: any).directives;
if (directives) {
const knownDirectives = Object.create(null);
for (const directive of directives) {
const directiveName = directive.name.value;
if (knownDirectives[directiveName]) {
context.reportError(
new GraphQLError(duplicateDirectiveMessage(directiveName), [
knownDirectives[directiveName],
directive,
]),
);
} else {
knownDirectives[directiveName] = directive;
}
}
}
},
};
}
@@ -0,0 +1,63 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
export function duplicateDirectiveMessage(directiveName) {
return "The directive \"".concat(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.
*/
export 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) {
// Flow can't refine that node.directives will only contain directives,
var directives = node.directives;
if (directives) {
var knownDirectives = Object.create(null);
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = directives[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var directive = _step.value;
var directiveName = directive.name.value;
if (knownDirectives[directiveName]) {
context.reportError(new GraphQLError(duplicateDirectiveMessage(directiveName), [knownDirectives[directiveName], directive]));
} else {
knownDirectives[directiveName] = directive;
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
}
}
};
}
+47
View File
@@ -0,0 +1,47 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.duplicateFragmentNameMessage = duplicateFragmentNameMessage;
exports.UniqueFragmentNames = UniqueFragmentNames;
var _GraphQLError = require("../../error/GraphQLError");
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
function duplicateFragmentNameMessage(fragName) {
return "There can be only one fragment named \"".concat(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 _GraphQLError.GraphQLError(duplicateFragmentNameMessage(fragmentName), [knownFragmentNames[fragmentName], node.name]));
} else {
knownFragmentNames[fragmentName] = node.name;
}
return false;
}
};
}
@@ -0,0 +1,42 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type { ASTValidationContext } from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import type { ASTVisitor } from '../../language/visitor';
export function duplicateFragmentNameMessage(fragName: string): string {
return `There can be only one fragment named "${fragName}".`;
}
/**
* Unique fragment names
*
* A GraphQL document is only valid if all defined fragments have unique names.
*/
export function UniqueFragmentNames(context: ASTValidationContext): ASTVisitor {
const knownFragmentNames = Object.create(null);
return {
OperationDefinition: () => false,
FragmentDefinition(node) {
const fragmentName = node.name.value;
if (knownFragmentNames[fragmentName]) {
context.reportError(
new GraphQLError(duplicateFragmentNameMessage(fragmentName), [
knownFragmentNames[fragmentName],
node.name,
]),
);
} else {
knownFragmentNames[fragmentName] = node.name;
}
return false;
},
};
}
+37
View File
@@ -0,0 +1,37 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
export function duplicateFragmentNameMessage(fragName) {
return "There can be only one fragment named \"".concat(fragName, "\".");
}
/**
* Unique fragment names
*
* A GraphQL document is only valid if all defined fragments have unique names.
*/
export 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 GraphQLError(duplicateFragmentNameMessage(fragmentName), [knownFragmentNames[fragmentName], node.name]));
} else {
knownFragmentNames[fragmentName] = node.name;
}
return false;
}
};
}
+55
View File
@@ -0,0 +1,55 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.duplicateInputFieldMessage = duplicateInputFieldMessage;
exports.UniqueInputFieldNames = UniqueInputFieldNames;
var _GraphQLError = require("../../error/GraphQLError");
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
function duplicateInputFieldMessage(fieldName) {
return "There can be only one input field named \"".concat(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 _GraphQLError.GraphQLError(duplicateInputFieldMessage(fieldName), [knownNames[fieldName], node.name]));
} else {
knownNames[fieldName] = node.name;
}
return false;
}
};
}
@@ -0,0 +1,55 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type { ASTValidationContext } from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import type { ASTVisitor } from '../../language/visitor';
export function duplicateInputFieldMessage(fieldName: string): string {
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.
*/
export function UniqueInputFieldNames(
context: ASTValidationContext,
): ASTVisitor {
const knownNameStack = [];
let knownNames = Object.create(null);
return {
ObjectValue: {
enter() {
knownNameStack.push(knownNames);
knownNames = Object.create(null);
},
leave() {
knownNames = knownNameStack.pop();
},
},
ObjectField(node) {
const fieldName = node.name.value;
if (knownNames[fieldName]) {
context.reportError(
new GraphQLError(duplicateInputFieldMessage(fieldName), [
knownNames[fieldName],
node.name,
]),
);
} else {
knownNames[fieldName] = node.name;
}
return false;
},
};
}
+45
View File
@@ -0,0 +1,45 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
export function duplicateInputFieldMessage(fieldName) {
return "There can be only one input field named \"".concat(fieldName, "\".");
}
/**
* Unique input field names
*
* A GraphQL input object value is only valid if all supplied fields are
* uniquely named.
*/
export 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 GraphQLError(duplicateInputFieldMessage(fieldName), [knownNames[fieldName], node.name]));
} else {
knownNames[fieldName] = node.name;
}
return false;
}
};
}
+49
View File
@@ -0,0 +1,49 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.duplicateOperationNameMessage = duplicateOperationNameMessage;
exports.UniqueOperationNames = UniqueOperationNames;
var _GraphQLError = require("../../error/GraphQLError");
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
function duplicateOperationNameMessage(operationName) {
return "There can be only one operation named \"".concat(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 _GraphQLError.GraphQLError(duplicateOperationNameMessage(operationName.value), [knownOperationNames[operationName.value], operationName]));
} else {
knownOperationNames[operationName.value] = operationName;
}
}
return false;
},
FragmentDefinition: function FragmentDefinition() {
return false;
}
};
}
@@ -0,0 +1,46 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type { ASTValidationContext } from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import type { ASTVisitor } from '../../language/visitor';
export function duplicateOperationNameMessage(operationName: string): string {
return `There can be only one operation named "${operationName}".`;
}
/**
* Unique operation names
*
* A GraphQL document is only valid if all defined operations have unique names.
*/
export function UniqueOperationNames(
context: ASTValidationContext,
): ASTVisitor {
const knownOperationNames = Object.create(null);
return {
OperationDefinition(node) {
const operationName = node.name;
if (operationName) {
if (knownOperationNames[operationName.value]) {
context.reportError(
new GraphQLError(
duplicateOperationNameMessage(operationName.value),
[knownOperationNames[operationName.value], operationName],
),
);
} else {
knownOperationNames[operationName.value] = operationName;
}
}
return false;
},
FragmentDefinition: () => false,
};
}
+39
View File
@@ -0,0 +1,39 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
export function duplicateOperationNameMessage(operationName) {
return "There can be only one operation named \"".concat(operationName, "\".");
}
/**
* Unique operation names
*
* A GraphQL document is only valid if all defined operations have unique names.
*/
export 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 GraphQLError(duplicateOperationNameMessage(operationName.value), [knownOperationNames[operationName.value], operationName]));
} else {
knownOperationNames[operationName.value] = operationName;
}
}
return false;
},
FragmentDefinition: function FragmentDefinition() {
return false;
}
};
}
+45
View File
@@ -0,0 +1,45 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.duplicateVariableMessage = duplicateVariableMessage;
exports.UniqueVariableNames = UniqueVariableNames;
var _GraphQLError = require("../../error/GraphQLError");
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
function duplicateVariableMessage(variableName) {
return "There can be only one variable named \"".concat(variableName, "\".");
}
/**
* Unique variable names
*
* A GraphQL operation is only valid if all its variables are uniquely named.
*/
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 _GraphQLError.GraphQLError(duplicateVariableMessage(variableName), [knownVariableNames[variableName], node.variable.name]));
} else {
knownVariableNames[variableName] = node.variable.name;
}
}
};
}
@@ -0,0 +1,44 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type { ASTValidationContext } from '../ValidationContext';
import type { VariableDefinitionNode } from '../../language/ast';
import { GraphQLError } from '../../error/GraphQLError';
import type { ASTVisitor } from '../../language/visitor';
export function duplicateVariableMessage(variableName: string): string {
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.
*/
export function UniqueVariableNames(context: ASTValidationContext): ASTVisitor {
let knownVariableNames = Object.create(null);
return {
OperationDefinition() {
knownVariableNames = Object.create(null);
},
VariableDefinition(node: VariableDefinitionNode) {
const variableName = node.variable.name.value;
if (knownVariableNames[variableName]) {
context.reportError(
new GraphQLError(duplicateVariableMessage(variableName), [
knownVariableNames[variableName],
node.variable.name,
]),
);
} else {
knownVariableNames[variableName] = node.variable.name;
}
},
};
}
+35
View File
@@ -0,0 +1,35 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
export function duplicateVariableMessage(variableName) {
return "There can be only one variable named \"".concat(variableName, "\".");
}
/**
* Unique variable names
*
* A GraphQL operation is only valid if all its variables are uniquely named.
*/
export 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 GraphQLError(duplicateVariableMessage(variableName), [knownVariableNames[variableName], node.variable.name]));
} else {
knownVariableNames[variableName] = node.variable.name;
}
}
};
}
+182
View File
@@ -0,0 +1,182 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.badValueMessage = badValueMessage;
exports.requiredFieldMessage = requiredFieldMessage;
exports.unknownFieldMessage = unknownFieldMessage;
exports.ValuesOfCorrectType = ValuesOfCorrectType;
var _GraphQLError = require("../../error/GraphQLError");
var _printer = require("../../language/printer");
var _definition = require("../../type/definition");
var _inspect = _interopRequireDefault(require("../../jsutils/inspect"));
var _isInvalid = _interopRequireDefault(require("../../jsutils/isInvalid"));
var _keyMap = _interopRequireDefault(require("../../jsutils/keyMap"));
var _orList = _interopRequireDefault(require("../../jsutils/orList"));
var _suggestionList = _interopRequireDefault(require("../../jsutils/suggestionList"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
function badValueMessage(typeName, valueName, message) {
return "Expected type ".concat(typeName, ", found ").concat(valueName) + (message ? "; ".concat(message) : '.');
}
function requiredFieldMessage(typeName, fieldName, fieldTypeName) {
return "Field ".concat(typeName, ".").concat(fieldName, " of required type ") + "".concat(fieldTypeName, " was not provided.");
}
function unknownFieldMessage(typeName, fieldName, message) {
return "Field \"".concat(fieldName, "\" is not defined by type ").concat(typeName) + (message ? "; ".concat(message) : '.');
}
/**
* Value literals of correct type
*
* A GraphQL document is only valid if all value literals are of the type
* expected at their position.
*/
function ValuesOfCorrectType(context) {
return {
NullValue: function NullValue(node) {
var type = context.getInputType();
if ((0, _definition.isNonNullType)(type)) {
context.reportError(new _GraphQLError.GraphQLError(badValueMessage((0, _inspect.default)(type), (0, _printer.print)(node)), node));
}
},
ListValue: function ListValue(node) {
// Note: TypeInfo will traverse into a list's item type, so look to the
// parent input type to check if it is a list.
var type = (0, _definition.getNullableType)(context.getParentInputType());
if (!(0, _definition.isListType)(type)) {
isValidScalar(context, node);
return false; // Don't traverse further.
}
},
ObjectValue: function ObjectValue(node) {
var type = (0, _definition.getNamedType)(context.getInputType());
if (!(0, _definition.isInputObjectType)(type)) {
isValidScalar(context, node);
return false; // Don't traverse further.
} // Ensure every required field exists.
var inputFields = type.getFields();
var fieldNodeMap = (0, _keyMap.default)(node.fields, function (field) {
return field.name.value;
});
var _arr = Object.keys(inputFields);
for (var _i = 0; _i < _arr.length; _i++) {
var fieldName = _arr[_i];
var fieldDef = inputFields[fieldName];
var fieldNode = fieldNodeMap[fieldName];
if (!fieldNode && (0, _definition.isRequiredInputField)(fieldDef)) {
var typeStr = (0, _inspect.default)(fieldDef.type);
context.reportError(new _GraphQLError.GraphQLError(requiredFieldMessage(type.name, fieldName, typeStr), node));
}
}
},
ObjectField: function ObjectField(node) {
var parentType = (0, _definition.getNamedType)(context.getParentInputType());
var fieldType = context.getInputType();
if (!fieldType && (0, _definition.isInputObjectType)(parentType)) {
var suggestions = (0, _suggestionList.default)(node.name.value, Object.keys(parentType.getFields()));
var didYouMean = suggestions.length !== 0 ? "Did you mean ".concat((0, _orList.default)(suggestions), "?") : undefined;
context.reportError(new _GraphQLError.GraphQLError(unknownFieldMessage(parentType.name, node.name.value, didYouMean), node));
}
},
EnumValue: function EnumValue(node) {
var type = (0, _definition.getNamedType)(context.getInputType());
if (!(0, _definition.isEnumType)(type)) {
isValidScalar(context, node);
} else if (!type.getValue(node.value)) {
context.reportError(new _GraphQLError.GraphQLError(badValueMessage(type.name, (0, _printer.print)(node), enumTypeSuggestion(type, node)), node));
}
},
IntValue: function IntValue(node) {
return isValidScalar(context, node);
},
FloatValue: function FloatValue(node) {
return isValidScalar(context, node);
},
StringValue: function StringValue(node) {
return isValidScalar(context, node);
},
BooleanValue: function BooleanValue(node) {
return isValidScalar(context, node);
}
};
}
/**
* Any value literal may be a valid representation of a Scalar, depending on
* that scalar type.
*/
function isValidScalar(context, node) {
// Report any error at the full type expected by the location.
var locationType = context.getInputType();
if (!locationType) {
return;
}
var type = (0, _definition.getNamedType)(locationType);
if (!(0, _definition.isScalarType)(type)) {
context.reportError(new _GraphQLError.GraphQLError(badValueMessage((0, _inspect.default)(locationType), (0, _printer.print)(node), enumTypeSuggestion(type, node)), node));
return;
} // Scalars determine if a literal value is valid via parseLiteral() which
// may throw or return an invalid value to indicate failure.
try {
var parseResult = type.parseLiteral(node, undefined
/* variables */
);
if ((0, _isInvalid.default)(parseResult)) {
context.reportError(new _GraphQLError.GraphQLError(badValueMessage((0, _inspect.default)(locationType), (0, _printer.print)(node)), node));
}
} catch (error) {
// Ensure a reference to the original error is maintained.
context.reportError(new _GraphQLError.GraphQLError(badValueMessage((0, _inspect.default)(locationType), (0, _printer.print)(node), error.message), node, undefined, undefined, undefined, error));
}
}
function enumTypeSuggestion(type, node) {
if ((0, _definition.isEnumType)(type)) {
var suggestions = (0, _suggestionList.default)((0, _printer.print)(node), type.getValues().map(function (value) {
return value.name;
}));
if (suggestions.length !== 0) {
return "Did you mean the enum value ".concat((0, _orList.default)(suggestions), "?");
}
}
}
@@ -0,0 +1,221 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type { ValidationContext } from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import type { ValueNode } from '../../language/ast';
import { print } from '../../language/printer';
import type { ASTVisitor } from '../../language/visitor';
import {
isScalarType,
isEnumType,
isInputObjectType,
isListType,
isNonNullType,
isRequiredInputField,
getNullableType,
getNamedType,
} from '../../type/definition';
import type { GraphQLType } from '../../type/definition';
import inspect from '../../jsutils/inspect';
import isInvalid from '../../jsutils/isInvalid';
import keyMap from '../../jsutils/keyMap';
import orList from '../../jsutils/orList';
import suggestionList from '../../jsutils/suggestionList';
export function badValueMessage(
typeName: string,
valueName: string,
message?: string,
): string {
return (
`Expected type ${typeName}, found ${valueName}` +
(message ? `; ${message}` : '.')
);
}
export function requiredFieldMessage(
typeName: string,
fieldName: string,
fieldTypeName: string,
): string {
return (
`Field ${typeName}.${fieldName} of required type ` +
`${fieldTypeName} was not provided.`
);
}
export function unknownFieldMessage(
typeName: string,
fieldName: string,
message?: string,
): string {
return (
`Field "${fieldName}" is not defined by type ${typeName}` +
(message ? `; ${message}` : '.')
);
}
/**
* Value literals of correct type
*
* A GraphQL document is only valid if all value literals are of the type
* expected at their position.
*/
export function ValuesOfCorrectType(context: ValidationContext): ASTVisitor {
return {
NullValue(node) {
const type = context.getInputType();
if (isNonNullType(type)) {
context.reportError(
new GraphQLError(badValueMessage(inspect(type), print(node)), node),
);
}
},
ListValue(node) {
// Note: TypeInfo will traverse into a list's item type, so look to the
// parent input type to check if it is a list.
const type = getNullableType(context.getParentInputType());
if (!isListType(type)) {
isValidScalar(context, node);
return false; // Don't traverse further.
}
},
ObjectValue(node) {
const type = getNamedType(context.getInputType());
if (!isInputObjectType(type)) {
isValidScalar(context, node);
return false; // Don't traverse further.
}
// Ensure every required field exists.
const inputFields = type.getFields();
const fieldNodeMap = keyMap(node.fields, field => field.name.value);
for (const fieldName of Object.keys(inputFields)) {
const fieldDef = inputFields[fieldName];
const fieldNode = fieldNodeMap[fieldName];
if (!fieldNode && isRequiredInputField(fieldDef)) {
const typeStr = inspect(fieldDef.type);
context.reportError(
new GraphQLError(
requiredFieldMessage(type.name, fieldName, typeStr),
node,
),
);
}
}
},
ObjectField(node) {
const parentType = getNamedType(context.getParentInputType());
const fieldType = context.getInputType();
if (!fieldType && isInputObjectType(parentType)) {
const suggestions = suggestionList(
node.name.value,
Object.keys(parentType.getFields()),
);
const didYouMean =
suggestions.length !== 0
? `Did you mean ${orList(suggestions)}?`
: undefined;
context.reportError(
new GraphQLError(
unknownFieldMessage(parentType.name, node.name.value, didYouMean),
node,
),
);
}
},
EnumValue(node) {
const type = getNamedType(context.getInputType());
if (!isEnumType(type)) {
isValidScalar(context, node);
} else if (!type.getValue(node.value)) {
context.reportError(
new GraphQLError(
badValueMessage(
type.name,
print(node),
enumTypeSuggestion(type, node),
),
node,
),
);
}
},
IntValue: node => isValidScalar(context, node),
FloatValue: node => isValidScalar(context, node),
StringValue: node => isValidScalar(context, node),
BooleanValue: node => isValidScalar(context, node),
};
}
/**
* Any value literal may be a valid representation of a Scalar, depending on
* that scalar type.
*/
function isValidScalar(context: ValidationContext, node: ValueNode): void {
// Report any error at the full type expected by the location.
const locationType = context.getInputType();
if (!locationType) {
return;
}
const type = getNamedType(locationType);
if (!isScalarType(type)) {
context.reportError(
new GraphQLError(
badValueMessage(
inspect(locationType),
print(node),
enumTypeSuggestion(type, node),
),
node,
),
);
return;
}
// Scalars determine if a literal value is valid via parseLiteral() which
// may throw or return an invalid value to indicate failure.
try {
const parseResult = type.parseLiteral(node, undefined /* variables */);
if (isInvalid(parseResult)) {
context.reportError(
new GraphQLError(
badValueMessage(inspect(locationType), print(node)),
node,
),
);
}
} catch (error) {
// Ensure a reference to the original error is maintained.
context.reportError(
new GraphQLError(
badValueMessage(inspect(locationType), print(node), error.message),
node,
undefined,
undefined,
undefined,
error,
),
);
}
}
function enumTypeSuggestion(type: GraphQLType, node: ValueNode): string | void {
if (isEnumType(type)) {
const suggestions = suggestionList(
print(node),
type.getValues().map(value => value.name),
);
if (suggestions.length !== 0) {
return `Did you mean the enum value ${orList(suggestions)}?`;
}
}
}
+158
View File
@@ -0,0 +1,158 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
import { print } from '../../language/printer';
import { isScalarType, isEnumType, isInputObjectType, isListType, isNonNullType, isRequiredInputField, getNullableType, getNamedType } from '../../type/definition';
import inspect from '../../jsutils/inspect';
import isInvalid from '../../jsutils/isInvalid';
import keyMap from '../../jsutils/keyMap';
import orList from '../../jsutils/orList';
import suggestionList from '../../jsutils/suggestionList';
export function badValueMessage(typeName, valueName, message) {
return "Expected type ".concat(typeName, ", found ").concat(valueName) + (message ? "; ".concat(message) : '.');
}
export function requiredFieldMessage(typeName, fieldName, fieldTypeName) {
return "Field ".concat(typeName, ".").concat(fieldName, " of required type ") + "".concat(fieldTypeName, " was not provided.");
}
export function unknownFieldMessage(typeName, fieldName, message) {
return "Field \"".concat(fieldName, "\" is not defined by type ").concat(typeName) + (message ? "; ".concat(message) : '.');
}
/**
* Value literals of correct type
*
* A GraphQL document is only valid if all value literals are of the type
* expected at their position.
*/
export function ValuesOfCorrectType(context) {
return {
NullValue: function NullValue(node) {
var type = context.getInputType();
if (isNonNullType(type)) {
context.reportError(new GraphQLError(badValueMessage(inspect(type), print(node)), node));
}
},
ListValue: function ListValue(node) {
// Note: TypeInfo will traverse into a list's item type, so look to the
// parent input type to check if it is a list.
var type = getNullableType(context.getParentInputType());
if (!isListType(type)) {
isValidScalar(context, node);
return false; // Don't traverse further.
}
},
ObjectValue: function ObjectValue(node) {
var type = getNamedType(context.getInputType());
if (!isInputObjectType(type)) {
isValidScalar(context, node);
return false; // Don't traverse further.
} // Ensure every required field exists.
var inputFields = type.getFields();
var fieldNodeMap = keyMap(node.fields, function (field) {
return field.name.value;
});
var _arr = Object.keys(inputFields);
for (var _i = 0; _i < _arr.length; _i++) {
var fieldName = _arr[_i];
var fieldDef = inputFields[fieldName];
var fieldNode = fieldNodeMap[fieldName];
if (!fieldNode && isRequiredInputField(fieldDef)) {
var typeStr = inspect(fieldDef.type);
context.reportError(new GraphQLError(requiredFieldMessage(type.name, fieldName, typeStr), node));
}
}
},
ObjectField: function ObjectField(node) {
var parentType = getNamedType(context.getParentInputType());
var fieldType = context.getInputType();
if (!fieldType && isInputObjectType(parentType)) {
var suggestions = suggestionList(node.name.value, Object.keys(parentType.getFields()));
var didYouMean = suggestions.length !== 0 ? "Did you mean ".concat(orList(suggestions), "?") : undefined;
context.reportError(new GraphQLError(unknownFieldMessage(parentType.name, node.name.value, didYouMean), node));
}
},
EnumValue: function EnumValue(node) {
var type = getNamedType(context.getInputType());
if (!isEnumType(type)) {
isValidScalar(context, node);
} else if (!type.getValue(node.value)) {
context.reportError(new GraphQLError(badValueMessage(type.name, print(node), enumTypeSuggestion(type, node)), node));
}
},
IntValue: function IntValue(node) {
return isValidScalar(context, node);
},
FloatValue: function FloatValue(node) {
return isValidScalar(context, node);
},
StringValue: function StringValue(node) {
return isValidScalar(context, node);
},
BooleanValue: function BooleanValue(node) {
return isValidScalar(context, node);
}
};
}
/**
* Any value literal may be a valid representation of a Scalar, depending on
* that scalar type.
*/
function isValidScalar(context, node) {
// Report any error at the full type expected by the location.
var locationType = context.getInputType();
if (!locationType) {
return;
}
var type = getNamedType(locationType);
if (!isScalarType(type)) {
context.reportError(new GraphQLError(badValueMessage(inspect(locationType), print(node), enumTypeSuggestion(type, node)), node));
return;
} // Scalars determine if a literal value is valid via parseLiteral() which
// may throw or return an invalid value to indicate failure.
try {
var parseResult = type.parseLiteral(node, undefined
/* variables */
);
if (isInvalid(parseResult)) {
context.reportError(new GraphQLError(badValueMessage(inspect(locationType), print(node)), node));
}
} catch (error) {
// Ensure a reference to the original error is maintained.
context.reportError(new GraphQLError(badValueMessage(inspect(locationType), print(node), error.message), node, undefined, undefined, undefined, error));
}
}
function enumTypeSuggestion(type, node) {
if (isEnumType(type)) {
var suggestions = suggestionList(print(node), type.getValues().map(function (value) {
return value.name;
}));
if (suggestions.length !== 0) {
return "Did you mean the enum value ".concat(orList(suggestions), "?");
}
}
}
+47
View File
@@ -0,0 +1,47 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.nonInputTypeOnVarMessage = nonInputTypeOnVarMessage;
exports.VariablesAreInputTypes = VariablesAreInputTypes;
var _GraphQLError = require("../../error/GraphQLError");
var _printer = require("../../language/printer");
var _definition = require("../../type/definition");
var _typeFromAST = require("../../utilities/typeFromAST");
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
function nonInputTypeOnVarMessage(variableName, typeName) {
return "Variable \"$".concat(variableName, "\" cannot be non-input type \"").concat(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).
*/
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 _GraphQLError.GraphQLError(nonInputTypeOnVarMessage(variableName, (0, _printer.print)(node.type)), [node.type]));
}
}
};
}
@@ -0,0 +1,48 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import type { ValidationContext } from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import type { VariableDefinitionNode } from '../../language/ast';
import { print } from '../../language/printer';
import type { ASTVisitor } from '../../language/visitor';
import { isInputType } from '../../type/definition';
import { typeFromAST } from '../../utilities/typeFromAST';
export function nonInputTypeOnVarMessage(
variableName: string,
typeName: string,
): string {
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).
*/
export function VariablesAreInputTypes(context: ValidationContext): ASTVisitor {
return {
VariableDefinition(node: VariableDefinitionNode): ?GraphQLError {
const type = typeFromAST(context.getSchema(), node.type);
// If the variable type is not an input type, return an error.
if (type && !isInputType(type)) {
const variableName = node.variable.name.value;
context.reportError(
new GraphQLError(
nonInputTypeOnVarMessage(variableName, print(node.type)),
[node.type],
),
);
}
},
};
}
@@ -0,0 +1,34 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import { GraphQLError } from '../../error/GraphQLError';
import { print } from '../../language/printer';
import { isInputType } from '../../type/definition';
import { typeFromAST } from '../../utilities/typeFromAST';
export function nonInputTypeOnVarMessage(variableName, typeName) {
return "Variable \"$".concat(variableName, "\" cannot be non-input type \"").concat(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).
*/
export function VariablesAreInputTypes(context) {
return {
VariableDefinition: function VariableDefinition(node) {
var type = typeFromAST(context.getSchema(), node.type); // If the variable type is not an input type, return an error.
if (type && !isInputType(type)) {
var variableName = node.variable.name.value;
context.reportError(new GraphQLError(nonInputTypeOnVarMessage(variableName, print(node.type)), [node.type]));
}
}
};
}
@@ -0,0 +1,117 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.badVarPosMessage = badVarPosMessage;
exports.VariablesInAllowedPosition = VariablesInAllowedPosition;
var _inspect = _interopRequireDefault(require("../../jsutils/inspect"));
var _GraphQLError = require("../../error/GraphQLError");
var _kinds = require("../../language/kinds");
var _definition = require("../../type/definition");
var _typeComparators = require("../../utilities/typeComparators");
var _typeFromAST = require("../../utilities/typeFromAST");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
function badVarPosMessage(varName, varType, expectedType) {
return "Variable \"$".concat(varName, "\" of type \"").concat(varType, "\" used in ") + "position expecting type \"".concat(expectedType, "\".");
}
/**
* Variables passed to field arguments conform to type
*/
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);
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = usages[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var _ref2 = _step.value;
var node = _ref2.node,
type = _ref2.type,
defaultValue = _ref2.defaultValue;
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 && !allowedVariableUsage(schema, varType, varDef.defaultValue, type, defaultValue)) {
context.reportError(new _GraphQLError.GraphQLError(badVarPosMessage(varName, (0, _inspect.default)(varType), (0, _inspect.default)(type)), [varDef, node]));
}
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
}
},
VariableDefinition: function VariableDefinition(node) {
varDefMap[node.variable.name.value] = node;
}
};
}
/**
* Returns true if the variable is allowed in the location it was found,
* which includes considering if default values exist for either the variable
* or the location at which it is located.
*/
function allowedVariableUsage(schema, varType, varDefaultValue, locationType, locationDefaultValue) {
if ((0, _definition.isNonNullType)(locationType) && !(0, _definition.isNonNullType)(varType)) {
var hasNonNullVariableDefaultValue = varDefaultValue && varDefaultValue.kind !== _kinds.Kind.NULL;
var hasLocationDefaultValue = locationDefaultValue !== undefined;
if (!hasNonNullVariableDefaultValue && !hasLocationDefaultValue) {
return false;
}
var nullableLocationType = locationType.ofType;
return (0, _typeComparators.isTypeSubTypeOf)(schema, varType, nullableLocationType);
}
return (0, _typeComparators.isTypeSubTypeOf)(schema, varType, locationType);
}
@@ -0,0 +1,110 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
*/
import inspect from '../../jsutils/inspect';
import type { ValidationContext } from '../ValidationContext';
import { GraphQLError } from '../../error/GraphQLError';
import { Kind } from '../../language/kinds';
import type { ValueNode } from '../../language/ast';
import type { ASTVisitor } from '../../language/visitor';
import { isNonNullType } from '../../type/definition';
import { isTypeSubTypeOf } from '../../utilities/typeComparators';
import { typeFromAST } from '../../utilities/typeFromAST';
import type { GraphQLType } from '../../type/definition';
import type { GraphQLSchema } from '../../type/schema';
export function badVarPosMessage(
varName: string,
varType: string,
expectedType: string,
): string {
return (
`Variable "$${varName}" of type "${varType}" used in ` +
`position expecting type "${expectedType}".`
);
}
/**
* Variables passed to field arguments conform to type
*/
export function VariablesInAllowedPosition(
context: ValidationContext,
): ASTVisitor {
let varDefMap = Object.create(null);
return {
OperationDefinition: {
enter() {
varDefMap = Object.create(null);
},
leave(operation) {
const usages = context.getRecursiveVariableUsages(operation);
for (const { node, type, defaultValue } of usages) {
const varName = node.name.value;
const 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).
const schema = context.getSchema();
const varType = typeFromAST(schema, varDef.type);
if (
varType &&
!allowedVariableUsage(
schema,
varType,
varDef.defaultValue,
type,
defaultValue,
)
) {
context.reportError(
new GraphQLError(
badVarPosMessage(varName, inspect(varType), inspect(type)),
[varDef, node],
),
);
}
}
}
},
},
VariableDefinition(node) {
varDefMap[node.variable.name.value] = node;
},
};
}
/**
* Returns true if the variable is allowed in the location it was found,
* which includes considering if default values exist for either the variable
* or the location at which it is located.
*/
function allowedVariableUsage(
schema: GraphQLSchema,
varType: GraphQLType,
varDefaultValue: ?ValueNode,
locationType: GraphQLType,
locationDefaultValue: ?mixed,
): boolean {
if (isNonNullType(locationType) && !isNonNullType(varType)) {
const hasNonNullVariableDefaultValue =
varDefaultValue && varDefaultValue.kind !== Kind.NULL;
const hasLocationDefaultValue = locationDefaultValue !== undefined;
if (!hasNonNullVariableDefaultValue && !hasLocationDefaultValue) {
return false;
}
const nullableLocationType = locationType.ofType;
return isTypeSubTypeOf(schema, varType, nullableLocationType);
}
return isTypeSubTypeOf(schema, varType, locationType);
}
@@ -0,0 +1,99 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* strict
*/
import inspect from '../../jsutils/inspect';
import { GraphQLError } from '../../error/GraphQLError';
import { Kind } from '../../language/kinds';
import { isNonNullType } from '../../type/definition';
import { isTypeSubTypeOf } from '../../utilities/typeComparators';
import { typeFromAST } from '../../utilities/typeFromAST';
export function badVarPosMessage(varName, varType, expectedType) {
return "Variable \"$".concat(varName, "\" of type \"").concat(varType, "\" used in ") + "position expecting type \"".concat(expectedType, "\".");
}
/**
* Variables passed to field arguments conform to type
*/
export 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);
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = usages[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var _ref2 = _step.value;
var node = _ref2.node,
type = _ref2.type,
defaultValue = _ref2.defaultValue;
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 = typeFromAST(schema, varDef.type);
if (varType && !allowedVariableUsage(schema, varType, varDef.defaultValue, type, defaultValue)) {
context.reportError(new GraphQLError(badVarPosMessage(varName, inspect(varType), inspect(type)), [varDef, node]));
}
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
}
},
VariableDefinition: function VariableDefinition(node) {
varDefMap[node.variable.name.value] = node;
}
};
}
/**
* Returns true if the variable is allowed in the location it was found,
* which includes considering if default values exist for either the variable
* or the location at which it is located.
*/
function allowedVariableUsage(schema, varType, varDefaultValue, locationType, locationDefaultValue) {
if (isNonNullType(locationType) && !isNonNullType(varType)) {
var hasNonNullVariableDefaultValue = varDefaultValue && varDefaultValue.kind !== Kind.NULL;
var hasLocationDefaultValue = locationDefaultValue !== undefined;
if (!hasNonNullVariableDefaultValue && !hasLocationDefaultValue) {
return false;
}
var nullableLocationType = locationType.ofType;
return isTypeSubTypeOf(schema, varType, nullableLocationType);
}
return isTypeSubTypeOf(schema, varType, locationType);
}