128 lines
4.0 KiB
JavaScript
128 lines
4.0 KiB
JavaScript
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.duplicateDirectiveMessage = duplicateDirectiveMessage;
|
|
exports.UniqueDirectivesPerLocation = UniqueDirectivesPerLocation;
|
|
|
|
var _GraphQLError = require("../../error/GraphQLError");
|
|
|
|
var _kinds = require("../../language/kinds");
|
|
|
|
var _directives = require("../../type/directives");
|
|
|
|
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 non-repeatable directives at
|
|
* a given location are uniquely named.
|
|
*/
|
|
|
|
|
|
function UniqueDirectivesPerLocation(context) {
|
|
var uniqueDirectiveMap = 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;
|
|
uniqueDirectiveMap[directive.name] = !directive.isRepeatable;
|
|
}
|
|
} 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) {
|
|
uniqueDirectiveMap[def.name.value] = !def.repeatable;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_didIteratorError2 = true;
|
|
_iteratorError2 = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
|
|
_iterator2.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError2) {
|
|
throw _iteratorError2;
|
|
}
|
|
}
|
|
}
|
|
|
|
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,
|
|
// so we cast so the rest of the code is well typed.
|
|
var directives = node.directives;
|
|
|
|
if (directives) {
|
|
var knownDirectives = Object.create(null);
|
|
var _iteratorNormalCompletion3 = true;
|
|
var _didIteratorError3 = false;
|
|
var _iteratorError3 = undefined;
|
|
|
|
try {
|
|
for (var _iterator3 = directives[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
|
|
var directive = _step3.value;
|
|
var directiveName = directive.name.value;
|
|
|
|
if (uniqueDirectiveMap[directiveName]) {
|
|
if (knownDirectives[directiveName]) {
|
|
context.reportError(new _GraphQLError.GraphQLError(duplicateDirectiveMessage(directiveName), [knownDirectives[directiveName], directive]));
|
|
} else {
|
|
knownDirectives[directiveName] = directive;
|
|
}
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_didIteratorError3 = true;
|
|
_iteratorError3 = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
|
|
_iterator3.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError3) {
|
|
throw _iteratorError3;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|