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);
}
