public static OperationDefinition GetOperation(ExecutableDocument document, string operationName) { var operations = document.OperationDefinitions; if (operations == null) { throw new DocumentException($"Document does not contain operations"); } if (string.IsNullOrEmpty(operationName)) { if (operations.Count == 1) { return(operations.Single()); } throw new DocumentException( "Multiple operations found. Please provide OperationName"); } var operation = operations.SingleOrDefault(op => op.Name.Value == operationName); if (operation == null) { throw new DocumentException( $"Could not find operation with name {operationName}"); } return(operation); }
public async Task EndParseDocumentAsync(ExecutableDocument document) { foreach (var extension in _scopes) { await extension.EndParseDocumentAsync(document); } }
public void Setup() { _schema = Utils.InitializeSchema().Result; _query = Utils.InitializeQuery(); _mutation = Utils.InitializeMutation(); _subscription = Utils.InitializeSubscription(); }
public void Visit(ExecutableDocument document) { // enter foreach (var visitor in _options.ExecutableDocument) { visitor.Enter(document); } // children if (document.FragmentDefinitions != null) { foreach (var definition in document.FragmentDefinitions) { Visit(definition); } } if (document.OperationDefinitions != null) { foreach (var definition in document.OperationDefinitions) { Visit(definition); } } // leave foreach (var visitor in _options.ExecutableDocument) { visitor.Leave(document); } }
public override void Visit(ExecutableDocument document) { Tracker.EnterDocument?.Invoke(document); base.Visit(document); Tracker.LeaveDocument?.Invoke(document); }
private void VisitExecutableDocument(ExecutableDocument node) { EnterNode(node); Visit(node.FragmentDefinitions); Visit(node.OperationDefinitions); ExitNode(node); }
public void Deconstruct(out ISchema schema, out ExecutableDocument document, out OperationDefinition operation, out object initialValue, out IReadOnlyDictionary <string, object?> coercedVariableValues) { schema = Schema; document = Document; operation = OperationDefinition; initialValue = InitialValue; coercedVariableValues = CoercedVariableValues; }
public void FromString() { /* Given */ /* When */ ExecutableDocument original = "{ field1 field2 }"; /* Then */ Assert.NotNull(original.OperationDefinitions); Assert.Single(original.OperationDefinitions); }
public void FromBytes() { /* Given */ /* When */ ExecutableDocument original = Encoding.UTF8.GetBytes("{ field1 field2 }") .AsReadOnlySpan(); /* Then */ Assert.NotNull(original.OperationDefinitions); Assert.Single(original.OperationDefinitions); }
public RulesWalker( IEnumerable <CombineRule> rules, ISchema schema, ExecutableDocument document, IReadOnlyDictionary <string, object?>?variableValues = null) { Schema = schema; Document = document; VariableValues = variableValues; CreateVisitors(rules); }
public void Setup() { _schema = Utils.InitializeSchema(); _query = Utils.InitializeQuery(); _defaultRulesMap = ExecutionRules.All.ToList(); _comparisonRules = new List <CombineRule> { ExecutionRules.R5211OperationNameUniqueness() }; _query2 = @"query Q1 { field1, field2, field3 { field1 field2 }} query Q2 { field1 }"; }
public void OverrideToString() { /* Given */ var expected = "{ field1 field2 }"; ExecutableDocument original = expected; /* When */ var actual = original.ToString(); /* Then */ Assert.Equal(expected, actual); }
public static ValueTask <ValidationResult> DefaultValidate( IEnumerable <CombineRule> rules, ISchema schema, ExecutableDocument document, IReadOnlyDictionary <string, object> variableValues = null) { var result = Validator.Validate( rules, schema, document, variableValues); return(new ValueTask <ValidationResult>(result)); }
public static ValidationResult Validate( IEnumerable <CombineRule> rules, ISchema schema, ExecutableDocument document, IReadOnlyDictionary <string, object> variableValues = null) { var visitor = new RulesWalker( rules, schema, document, variableValues); return(visitor.Validate()); }
public void Leave(ExecutableDocument node) { while (_known.TryPop(out var name)) { if (_known.Contains(name)) { throw new InvalidOperationException(); } } /*context.Error(ValidationErrorCodes.R5211OperationNameUniqueness, * "Each named operation definition must be unique within a " + * "document when referred to by its name. " + * $"Operation: '{operationName}'", * definition);*/ }
public void ExecutableDocument_EnterAndLeave() { /* Given */ ExecutableDocument document = @""; var visitor = Substitute.For <VisitAllBase>(); var sut = new ReadOnlyExecutionDocumentWalker( new ExecutionDocumentWalkerOptions().Add(visitor)); /* When */ sut.Visit(document); /* Then */ visitor.Received().Enter(document); visitor.Received().Leave(document); }
public QueryContext( Func <Exception, ExecutionError> formatError, ExecutableDocument document, OperationDefinition operation, ISchema schema, IReadOnlyDictionary <string, object?> coercedVariableValues, object initialValue, ExtensionsRunner extensionsRunner) { FormatError = formatError ?? throw new ArgumentNullException(nameof(formatError)); Document = document ?? throw new ArgumentNullException(nameof(document)); OperationDefinition = operation ?? throw new ArgumentNullException(nameof(operation)); Schema = schema ?? throw new ArgumentNullException(nameof(schema)); CoercedVariableValues = coercedVariableValues; InitialValue = initialValue; ExtensionsRunner = extensionsRunner; }
public ExecutorContext(ISchema schema, ExecutableDocument document, ExtensionsRunner extensionsRunner, IExecutionStrategy strategy, OperationDefinition operation, IDictionary <string, FragmentDefinition>?fragments, IReadOnlyDictionary <string, object?> coercedVariableValues) { Schema = schema ?? throw new ArgumentNullException(nameof(schema)); Document = document ?? throw new ArgumentNullException(nameof(document)); ExtensionsRunner = extensionsRunner ?? throw new ArgumentNullException(nameof(extensionsRunner)); Strategy = strategy ?? throw new ArgumentNullException(nameof(strategy)); Operation = operation; Fragments = fragments ?? new Dictionary <string, FragmentDefinition>(); CoercedVariableValues = coercedVariableValues; _errors = new List <Exception>(); }
private string PrintDocument(ExecutableDocument node) { var nodes = new List <INode>(); if (node.OperationDefinitions != null) { nodes.AddRange(node.OperationDefinitions); } if (node.FragmentDefinitions != null) { nodes.AddRange(node.FragmentDefinitions); } var definitions = nodes.Select(Print); return(Join(definitions, $"{Environment.NewLine}")); }
public virtual void Visit(ExecutableDocument ast) { if (ast.FragmentDefinitions != null) { foreach (var definition in ast.FragmentDefinitions) { BeginVisitNode(definition); } } if (ast.OperationDefinitions != null) { foreach (var definition in ast.OperationDefinitions) { BeginVisitNode(definition); } } }
private ValidationResult Validate( ExecutableDocument document, CombineRule rule, Dictionary <string, object> variables = null) { if (document == null) { throw new ArgumentNullException(nameof(document)); } if (rule == null) { throw new ArgumentNullException(nameof(rule)); } return(Validator.Validate( new[] { rule }, Schema, document, variables)); }
public void Enter(ExecutableDocument node) { }
protected virtual void ExitExecutableDocument(TContext context, ExecutableDocument executableDocument) { }
public static IReadOnlyDictionary <string, List <FieldSelection> > CollectFields( ISchema schema, ExecutableDocument document, ObjectType objectType, SelectionSet selectionSet, IReadOnlyDictionary <string, object?> coercedVariableValues, List <string>?visitedFragments = null) { visitedFragments ??= new List <string>(); var fragments = document.FragmentDefinitions; var groupedFields = new Dictionary <string, List <FieldSelection> >(); foreach (var selection in selectionSet.Selections) { var directives = GetDirectives(selection).ToList(); var skipDirective = directives.FirstOrDefault(d => d.Name == "skip"); //todo: skip to constant if (SkipSelection(skipDirective, coercedVariableValues, schema, objectType, selection)) { continue; } var includeDirective = directives.FirstOrDefault(d => d.Name == "include"); //todo: include to constant if (!IncludeSelection(includeDirective, coercedVariableValues, schema, objectType, selection)) { continue; } if (selection is FieldSelection fieldSelection) { var name = fieldSelection.AliasOrName; if (!groupedFields.ContainsKey(name)) { groupedFields[name] = new List <FieldSelection>(); } groupedFields[name].Add(fieldSelection); } if (selection is FragmentSpread fragmentSpread) { var fragmentSpreadName = fragmentSpread.FragmentName; if (visitedFragments.Contains(fragmentSpreadName)) { continue; } visitedFragments.Add(fragmentSpreadName); var fragment = fragments.SingleOrDefault(f => f.FragmentName == fragmentSpreadName); if (fragment == null) { continue; } var fragmentTypeAst = fragment.TypeCondition; var fragmentType = TypeFromAst(schema, fragmentTypeAst); if (!DoesFragmentTypeApply(objectType, fragmentType)) { continue; } var fragmentSelectionSet = fragment.SelectionSet; var fragmentGroupedFieldSet = CollectFields( schema, document, objectType, fragmentSelectionSet, coercedVariableValues, visitedFragments); foreach (var fragmentGroup in fragmentGroupedFieldSet) { var responseKey = fragmentGroup.Key; if (!groupedFields.ContainsKey(responseKey)) { groupedFields[responseKey] = new List <FieldSelection>(); } groupedFields[responseKey].AddRange(fragmentGroup.Value); } } if (selection is InlineFragment inlineFragment) { var fragmentTypeAst = inlineFragment.TypeCondition; var fragmentType = TypeFromAst(schema, fragmentTypeAst); if (fragmentType != null && !DoesFragmentTypeApply(objectType, fragmentType)) { continue; } var fragmentSelectionSet = inlineFragment.SelectionSet; var fragmentGroupedFieldSet = CollectFields( schema, document, objectType, fragmentSelectionSet, coercedVariableValues, visitedFragments); foreach (var fragmentGroup in fragmentGroupedFieldSet) { var responseKey = fragmentGroup.Key; if (!groupedFields.ContainsKey(responseKey)) { groupedFields[responseKey] = new List <FieldSelection>(); } groupedFields[responseKey].AddRange(fragmentGroup.Value); } } } return(groupedFields); }
public ExecutionDocumentWalkerOptions Add(object visitor) { if (visitor is IVisit <ExecutableDocument> ed) { ExecutableDocument.Add(ed); } if (visitor is IVisit <FragmentDefinition> fd) { FragmentDefinition.Add(fd); } if (visitor is IVisit <OperationDefinition> od) { OperationDefinition.Add(od); } if (visitor is IVisit <SelectionSet> ss) { SelectionSet.Add(ss); } if (visitor is IVisit <ISelection> s) { Selection.Add(s); } if (visitor is IVisit <FieldSelection> fs) { FieldSelection.Add(fs); } if (visitor is IVisit <InlineFragment> ift) { InlineFragment.Add(ift); } if (visitor is IVisit <FragmentSpread> fgs) { FragmentSpread.Add(fgs); } if (visitor is IVisit <Argument> arg) { Argument.Add(arg); } if (visitor is IVisit <NamedType> nt) { NamedType.Add(nt); } if (visitor is IVisit <VariableDefinition> vd) { VariableDefinition.Add(vd); } if (visitor is IVisit <DefaultValue> dv) { DefaultValue.Add(dv); } if (visitor is IVisit <Value> v) { Value.Add(v); } if (visitor is IVisit <Directive> d) { Directive.Add(d); } if (visitor is IVisit <TypeBase> t) { Type.Add(t); } return(this); }