| function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; } |
| |
| import { Kind } from "../language/kinds.mjs"; |
| import { visit } from "../language/visitor.mjs"; |
| import { TypeInfo, visitWithTypeInfo } from "../utilities/TypeInfo.mjs"; |
| |
| /** |
| * An instance of this class is passed as the "this" context to all validators, |
| * allowing access to commonly useful contextual information from within a |
| * validation rule. |
| */ |
| export var ASTValidationContext = |
| /*#__PURE__*/ |
| function () { |
| function ASTValidationContext(ast, onError) { |
| this._ast = ast; |
| this._fragments = undefined; |
| this._fragmentSpreads = new Map(); |
| this._recursivelyReferencedFragments = new Map(); |
| this._onError = onError; |
| } |
| |
| var _proto = ASTValidationContext.prototype; |
| |
| _proto.reportError = function reportError(error) { |
| this._onError(error); |
| }; |
| |
| _proto.getDocument = function getDocument() { |
| return this._ast; |
| }; |
| |
| _proto.getFragment = function getFragment(name) { |
| var fragments = this._fragments; |
| |
| if (!fragments) { |
| this._fragments = fragments = this.getDocument().definitions.reduce(function (frags, statement) { |
| if (statement.kind === Kind.FRAGMENT_DEFINITION) { |
| frags[statement.name.value] = statement; |
| } |
| |
| return frags; |
| }, Object.create(null)); |
| } |
| |
| return fragments[name]; |
| }; |
| |
| _proto.getFragmentSpreads = function getFragmentSpreads(node) { |
| var spreads = this._fragmentSpreads.get(node); |
| |
| if (!spreads) { |
| spreads = []; |
| var setsToVisit = [node]; |
| |
| while (setsToVisit.length !== 0) { |
| var set = setsToVisit.pop(); |
| |
| for (var _i2 = 0, _set$selections2 = set.selections; _i2 < _set$selections2.length; _i2++) { |
| var selection = _set$selections2[_i2]; |
| |
| if (selection.kind === Kind.FRAGMENT_SPREAD) { |
| spreads.push(selection); |
| } else if (selection.selectionSet) { |
| setsToVisit.push(selection.selectionSet); |
| } |
| } |
| } |
| |
| this._fragmentSpreads.set(node, spreads); |
| } |
| |
| return spreads; |
| }; |
| |
| _proto.getRecursivelyReferencedFragments = function getRecursivelyReferencedFragments(operation) { |
| var fragments = this._recursivelyReferencedFragments.get(operation); |
| |
| if (!fragments) { |
| fragments = []; |
| var collectedNames = Object.create(null); |
| var nodesToVisit = [operation.selectionSet]; |
| |
| while (nodesToVisit.length !== 0) { |
| var node = nodesToVisit.pop(); |
| |
| for (var _i4 = 0, _this$getFragmentSpre2 = this.getFragmentSpreads(node); _i4 < _this$getFragmentSpre2.length; _i4++) { |
| var spread = _this$getFragmentSpre2[_i4]; |
| var fragName = spread.name.value; |
| |
| if (collectedNames[fragName] !== true) { |
| collectedNames[fragName] = true; |
| var fragment = this.getFragment(fragName); |
| |
| if (fragment) { |
| fragments.push(fragment); |
| nodesToVisit.push(fragment.selectionSet); |
| } |
| } |
| } |
| } |
| |
| this._recursivelyReferencedFragments.set(operation, fragments); |
| } |
| |
| return fragments; |
| }; |
| |
| return ASTValidationContext; |
| }(); |
| export var SDLValidationContext = |
| /*#__PURE__*/ |
| function (_ASTValidationContext) { |
| _inheritsLoose(SDLValidationContext, _ASTValidationContext); |
| |
| function SDLValidationContext(ast, schema, onError) { |
| var _this; |
| |
| _this = _ASTValidationContext.call(this, ast, onError) || this; |
| _this._schema = schema; |
| return _this; |
| } |
| |
| var _proto2 = SDLValidationContext.prototype; |
| |
| _proto2.getSchema = function getSchema() { |
| return this._schema; |
| }; |
| |
| return SDLValidationContext; |
| }(ASTValidationContext); |
| export var ValidationContext = |
| /*#__PURE__*/ |
| function (_ASTValidationContext2) { |
| _inheritsLoose(ValidationContext, _ASTValidationContext2); |
| |
| function ValidationContext(schema, ast, typeInfo, onError) { |
| var _this2; |
| |
| _this2 = _ASTValidationContext2.call(this, ast, onError) || this; |
| _this2._schema = schema; |
| _this2._typeInfo = typeInfo; |
| _this2._variableUsages = new Map(); |
| _this2._recursiveVariableUsages = new Map(); |
| return _this2; |
| } |
| |
| var _proto3 = ValidationContext.prototype; |
| |
| _proto3.getSchema = function getSchema() { |
| return this._schema; |
| }; |
| |
| _proto3.getVariableUsages = function getVariableUsages(node) { |
| var usages = this._variableUsages.get(node); |
| |
| if (!usages) { |
| var newUsages = []; |
| var typeInfo = new TypeInfo(this._schema); |
| visit(node, visitWithTypeInfo(typeInfo, { |
| VariableDefinition: function VariableDefinition() { |
| return false; |
| }, |
| Variable: function Variable(variable) { |
| newUsages.push({ |
| node: variable, |
| type: typeInfo.getInputType(), |
| defaultValue: typeInfo.getDefaultValue() |
| }); |
| } |
| })); |
| usages = newUsages; |
| |
| this._variableUsages.set(node, usages); |
| } |
| |
| return usages; |
| }; |
| |
| _proto3.getRecursiveVariableUsages = function getRecursiveVariableUsages(operation) { |
| var usages = this._recursiveVariableUsages.get(operation); |
| |
| if (!usages) { |
| usages = this.getVariableUsages(operation); |
| |
| for (var _i6 = 0, _this$getRecursivelyR2 = this.getRecursivelyReferencedFragments(operation); _i6 < _this$getRecursivelyR2.length; _i6++) { |
| var frag = _this$getRecursivelyR2[_i6]; |
| usages = usages.concat(this.getVariableUsages(frag)); |
| } |
| |
| this._recursiveVariableUsages.set(operation, usages); |
| } |
| |
| return usages; |
| }; |
| |
| _proto3.getType = function getType() { |
| return this._typeInfo.getType(); |
| }; |
| |
| _proto3.getParentType = function getParentType() { |
| return this._typeInfo.getParentType(); |
| }; |
| |
| _proto3.getInputType = function getInputType() { |
| return this._typeInfo.getInputType(); |
| }; |
| |
| _proto3.getParentInputType = function getParentInputType() { |
| return this._typeInfo.getParentInputType(); |
| }; |
| |
| _proto3.getFieldDef = function getFieldDef() { |
| return this._typeInfo.getFieldDef(); |
| }; |
| |
| _proto3.getDirective = function getDirective() { |
| return this._typeInfo.getDirective(); |
| }; |
| |
| _proto3.getArgument = function getArgument() { |
| return this._typeInfo.getArgument(); |
| }; |
| |
| return ValidationContext; |
| }(ASTValidationContext); |