private static ObjectValueNode Rewrite( ObjectValueNode node, IVariableValueCollection variableValues) { if (node.Fields.Count == 0) { return(node); } if (node.Fields.Count == 1) { if (TryRewriteField(node.Fields[0], variableValues, out ObjectFieldNode? rewritten)) { return(node.WithFields(new[] { rewritten })); } return(node); } ObjectFieldNode[]? rewrittenItems = null; for (int i = 0; i < node.Fields.Count; i++) { if (TryRewriteField(node.Fields[i], variableValues, out ObjectFieldNode? rewritten)) { if (rewrittenItems is null) { rewrittenItems = new ObjectFieldNode[node.Fields.Count]; for (int j = 0; j < node.Fields.Count; j++) { rewrittenItems[j] = node.Fields[j]; } } rewrittenItems[i] = rewritten; } else if (rewrittenItems is { })
private static EventDescription CreateEvent( IExecutionContext executionContext) { IReadOnlyCollection <FieldSelection> selections = executionContext .CollectFields( executionContext.Operation.RootType, executionContext.Operation.Definition.SelectionSet, null); if (selections.Count == 1) { FieldSelection selection = selections.Single(); var arguments = new List <ArgumentNode>(); IVariableValueCollection variables = executionContext.Variables; foreach (ArgumentNode argument in selection.Selection.Arguments) { if (argument.Value is VariableNode v) { IValueNode value = variables.GetVariable <IValueNode>(v.Name.Value); arguments.Add(argument.WithValue(value)); } else { arguments.Add(argument); } } return(new EventDescription(selection.Field.Name, arguments)); } else { throw new QueryException(CoreResources.Subscriptions_SingleRootField); } }
public IValueNode RewriteValue( IValueNode value, IType type, IVariableValueCollection variables, ITypeConversion typeConversion) { if (value is null) { throw new ArgumentNullException(nameof(value)); } if (type is null) { throw new ArgumentNullException(nameof(type)); } if (variables is null) { throw new ArgumentNullException(nameof(variables)); } if (typeConversion is null) { throw new ArgumentNullException(nameof(typeConversion)); } _variables = variables; _typeConversion = typeConversion; _type.Clear(); _type.Push(type); return(RewriteValue(value, null)); }
public IReadOnlyDictionary <NameString, ArgumentValue> CoerceArguments( IVariableValueCollection variables, ITypeConversion converter) { if (_hasArgumentErrors) { throw new QueryException(_args.Values.Select(t => t.Error)); } if (_vars == null) { return(_args); } var args = _args.ToDictionary(t => t.Key, t => t.Value); foreach (KeyValuePair <NameString, ArgumentVariableValue> var in _vars) { IError error = null; if (variables.TryGetVariable( var.Value.VariableName, out object value)) { value = var.Value.CoerceValue(value); } else { value = var.Value.DefaultValue; if (var.Value.Type.NamedType().IsLeafType() && value is IValueNode literal) { value = var.Value.Type.ParseLiteral(literal); } if (var.Value.Type.IsNonNullType() && (value is null || value is NullValueNode)) { error = ErrorBuilder.New() .SetMessage(string.Format( CultureInfo.InvariantCulture, TypeResources.ArgumentValueBuilder_NonNull, var.Key, TypeVisualizer.Visualize(var.Value.Type))) .AddLocation(Selection) .SetExtension(_argumentProperty, Path.New(var.Key)) .SetPath(_path) .Build(); } } if (error is null) { ValueKind kind = ValueKind.Unknown; if (value is IValueNode literal) { kind = literal.GetValueKind();
protected MaxComplexityWithMultipliersVisitorContext( ImmutableHashSet <string> fragmentPath, ImmutableList <IOutputField> fieldPath, MaxComplexityWithMultipliersVisitorContext context) : base(fragmentPath, fieldPath, context) { _variables = context._variables; }
internal protected MaxComplexityWithMultipliersVisitorContext( ISchema schema, IVariableValueCollection variables, ComplexityCalculation calculateComplexity) : base(schema, calculateComplexity) { _variables = variables; }
public static bool TryCoerceArguments( this IArgumentMap arguments, IVariableValueCollection variables, Action <IError> reportError, [NotNullWhen(true)] out IReadOnlyDictionary <NameString, ArgumentValue>?coercedArgs) { // if we have errors on the compiled execution plan we will report the errors and // signal that this resolver task has errors and shall end. if (arguments.HasErrors) { foreach (ArgumentValue argument in arguments.Values) { if (argument.HasError) { reportError(argument.Error !); } } coercedArgs = null; return(false); } if (arguments.IsFinal) { coercedArgs = arguments; return(true); } // if there are arguments that have variables and need variable replacement we will // rewrite the arguments that need variable replacement. var args = new Dictionary <NameString, ArgumentValue>(); foreach (ArgumentValue argument in arguments.Values) { if (argument.IsFinal) { args.Add(argument.Argument.Name, argument); } else { IValueNode literal = VariableRewriter.Rewrite( argument.ValueLiteral !, variables); args.Add(argument.Argument.Name, new ArgumentValue( argument.Argument, literal.TryGetValueKind(out ValueKind kind) ? kind : ValueKind.Unknown, argument.IsFinal, argument.IsImplicit, null, literal)); } } coercedArgs = args; return(true); }
private string CreateHtmlFromDocument(DocumentNode queryString, IVariableValueCollection variables) { StringBuilder htmlText = new(); if (_context.Document is not null) { var divWithBorder = "<div style=\"border: 1px solid black;align-items: flex-start;margin-left: 10%;margin-right: 15%; padding: 5px\">"; var lineArray = queryString !.ToString(true) .Split( new[] { Environment.NewLine }, StringSplitOptions.None ).ToList(); htmlText.AppendLine(divWithBorder); htmlText.AppendLine("<b>GraphQL Query</b>"); foreach (var s in lineArray) { var str = "<p>" + s.Replace(" ", " ") + "</p>"; htmlText.AppendLine(str); } htmlText.AppendLine("</div>"); if (_context.Variables is not null) { try { var variablesConcrete = _context.Variables !.ToList(); if (variablesConcrete.Count > 0) { htmlText.AppendLine(divWithBorder); htmlText.AppendLine("<b>Variables</b><table>"); foreach (var variableValue in variablesConcrete !) { htmlText.Append("<tr>"); htmlText.AppendFormat( $"<td> {variableValue.Name}</td><td>:</td><td>{variableValue.Value}</td><td>:</td><td>{variableValue.Type}</td>"); htmlText.Append("</tr>"); } htmlText.Append("</table></div>"); } } catch { // all input type records will land here. htmlText.AppendLine(" Formatting Variables Error. Continuing..."); } } htmlText.AppendLine(divWithBorder); htmlText.AppendFormat( $"Execution time inside query is {_queryTimer.Elapsed.TotalMilliseconds:0.#} milliseconds."); htmlText.AppendLine("</div>"); } return(htmlText.ToString()); }
private static ListValueNode Rewrite( ListValueNode node, ListType type, IVariableValueCollection variableValues) { if (node.Items.Count == 0) { return(node); } if (node.Items.Count == 1) { return(TryRewriteValue( node.Items[0], type.ElementType, NullValueNode.Default, variableValues, out IValueNode? rewritten) ? node.WithItems(new[] { rewritten }) : node); } IValueNode[]? rewrittenItems = null; for (var i = 0; i < node.Items.Count; i++) { if (TryRewriteValue( node.Items[i], type.ElementType, NullValueNode.Default, variableValues, out IValueNode? rewritten)) { if (rewrittenItems is null) { rewrittenItems = new IValueNode[node.Items.Count]; for (var j = 0; j < i; j++) { rewrittenItems[j] = node.Items[j]; } } rewrittenItems[i] = rewritten; } else if (rewrittenItems is not null) { rewrittenItems[i] = node.Items[i]; } } if (rewrittenItems is not null) { return(node.WithItems(rewrittenItems)); } return(node); }
public bool IsIncluded(IVariableValueCollection variableValues, bool allowInternals = false) { return(InclusionKind switch { SelectionInclusionKind.Always => true, SelectionInclusionKind.Conditional => EvaluateConditions(variableValues), SelectionInclusionKind.Internal => allowInternals, SelectionInclusionKind.InternalConditional => allowInternals && EvaluateConditions(variableValues), _ => throw new NotSupportedException() });
internal static StreamDirective?GetStreamDirective( this IReadOnlyList <DirectiveNode> directives, IVariableValueCollection variables) { DirectiveNode?directiveNode = GetDirective(directives, WellKnownDirectives.Stream); if (directiveNode is not null) { var @if = true; string?label = null; var initialCount = 0; foreach (ArgumentNode argument in directiveNode.Arguments) { switch (argument.Name.Value) { case WellKnownDirectives.IfArgument: @if = argument.Value switch { VariableNode variable => variables.GetVariable <bool>(variable.Name.Value), BooleanValueNode b => b.Value, _ => @if }; break; case WellKnownDirectives.LabelArgument: label = argument.Value switch { VariableNode variable => variables.GetVariable <string?>(variable.Name.Value), StringValueNode b => b.Value, _ => label }; break; case WellKnownDirectives.InitialCount: initialCount = argument.Value switch { VariableNode variable => variables.GetVariable <int>(variable.Name.Value), IntValueNode b => b.ToInt32(), _ => initialCount }; break; } } return(new StreamDirective(@if, initialCount, label)); } return(null); }
private static ObjectValueNode Rewrite( ObjectValueNode node, InputObjectType type, IVariableValueCollection variableValues) { if (node.Fields.Count == 0) { return(node); } if (node.Fields.Count == 1) { ObjectFieldNode value = node.Fields[0]; return(type.Fields.TryGetField(value.Name.Value, out InputField? field) && TryRewriteField(value, field, variableValues, out ObjectFieldNode? rewritten) ? node.WithFields(new[] { rewritten }) : node); } ObjectFieldNode[]? rewrittenItems = null; for (var i = 0; i < node.Fields.Count; i++) { ObjectFieldNode value = node.Fields[i]; if (type.Fields.TryGetField(value.Name.Value, out InputField? field) && TryRewriteField(value, field, variableValues, out ObjectFieldNode? rewritten)) { if (rewrittenItems is null) { rewrittenItems = new ObjectFieldNode[node.Fields.Count]; for (var j = 0; j < node.Fields.Count; j++) { rewrittenItems[j] = node.Fields[j]; } } rewrittenItems[i] = rewritten; } else if (rewrittenItems is not null) { rewrittenItems[i] = node.Fields[i]; } } if (rewrittenItems is not null) { return(node.WithFields(rewrittenItems)); } return(node); }
internal ComplexityContext( IOutputField fieldDefinition, FieldNode fieldSelection, ICollection <IOutputField> path, IVariableValueCollection variables, CostDirective cost) { FieldDefinition = fieldDefinition; FieldSelection = fieldSelection; Path = path; Variables = variables; Cost = cost; }
public bool IsVisible(IVariableValueCollection variables) { if (Parent != null && !Parent.IsVisible(variables)) { return(false); } if (Skip != null && IsTrue(variables, Skip)) { return(false); } return(Include == null || IsTrue(variables, Include)); }
public override bool TryActivate(IQueryPlanState state) { IVariableValueCollection variables = state.Context.Variables; foreach (ISelection?selection in _selections) { if (state.Selections.Contains(selection.Id) && selection.IsIncluded(variables)) { return(true); } } return(false); }
public Task InvokeAsync(IQueryContext context) { IVariableValueCollection variables = context.Operation.Variables; var dict = new Dictionary <string, IValueNode>(); foreach (string key in context.Request.VariableValues.Keys) { dict.Add(key, variables.GetVariable <IValueNode>(key)); } context.SetVariables(dict); return(_next.Invoke(context)); }
private static ObjectValueNode Rewrite( ObjectValueNode node, ListType type, IVariableValueCollection variableValues) { return(TryRewriteValue( node, type.ElementType, NullValueNode.Default, variableValues, out IValueNode? rewritten) && rewritten is ObjectValueNode rewrittenObj ? rewrittenObj : node); }
private static bool IsTrue( IVariableValueCollection variables, IValueNode value) { if (value is BooleanValueNode b) { return(b.Value); } if (value is VariableNode v) { return(variables.GetVariable <bool>(v.Name.Value)); } throw FieldVisibility_ValueNotSupported(value); }
public bool IsVisible(IVariableValueCollection variables) { if (_visibility == null || _visibility.Count == 0) { return(true); } for (int i = 0; i < _visibility.Count; i++) { if (!_visibility[i].IsVisible(variables)) { return(false); } } return(true); }
public Operation( DocumentNode query, OperationDefinitionNode definition, IVariableValueCollection variables, ObjectType rootType, object rootValue) { Document = query ?? throw new ArgumentNullException(nameof(query)); Definition = definition ?? throw new ArgumentNullException(nameof(definition)); Variables = variables ?? throw new ArgumentNullException(nameof(variables)); RootType = rootType ?? throw new ArgumentNullException(nameof(rootType)); RootValue = rootValue; }
private static bool TryGetMultiplierFromArgument( FieldNode field, IVariableValueCollection variables, string argumentName, out int value) { ArgumentNode argument = field.Arguments .FirstOrDefault(t => t.Name.Value == argumentName); if (argument == null) { value = default; return(false); } return(TryParseValue(argument.Value, variables, out value)); }
public void Initialize( IRequestContext requestContext, IServiceProvider scopedServices, IBatchDispatcher batchDispatcher, IPreparedOperation operation, object?rootValue, IVariableValueCollection variables) { _requestContext = requestContext; _executionContext.Initialize( batchDispatcher, requestContext.RequestAborted); Operation = operation; RootValue = rootValue; Variables = variables; Services = scopedServices; }
internal static DeferDirective?GetDeferDirective( this IReadOnlyList <DirectiveNode> directives, IVariableValueCollection variables) { DirectiveNode?directiveNode = GetDirective(directives, WellKnownDirectives.Defer); if (directiveNode is not null) { var @if = false; string?label = null; foreach (ArgumentNode argument in directiveNode.Arguments) { switch (argument.Name.Value) { case WellKnownDirectives.IfArgument: @if = argument.Value switch { VariableNode variable => variables.GetVariable <BooleanValueNode>( variable.Name.Value).Value, BooleanValueNode b => b.Value, _ => @if }; break; case WellKnownDirectives.LabelArgument: label = argument.Value switch { VariableNode variable => variables.GetVariable <string?>(variable.Name.Value), StringValueNode b => b.Value, _ => label }; break; } } return(new DeferDirective(@if, label)); } return(null); }
/// <summary> /// Rewrites <paramref name="node" /> and replaces all occurrences of /// <see cref="VariableNode" /> with concrete <see cref="IValueNode" /> /// from the <paramref name="variableValues" />. /// </summary> /// <param name="node"> /// The value that shall be rewritten. /// </param> /// <param name="variableValues"> /// The variable values. /// </param> /// <returns> /// Returns a <see cref="IValueNode" /> that has no variables. /// </returns> public static IValueNode Rewrite( IValueNode node, IVariableValueCollection variableValues) { if (node is null) { throw new System.ArgumentNullException(nameof(node)); } if (variableValues is null) { throw new System.ArgumentNullException(nameof(variableValues)); } if (TryRewriteValue(node, variableValues, out IValueNode? rewritten)) { return(rewritten); } return(node); }
private static bool TryRewriteField( ObjectFieldNode original, InputField field, IVariableValueCollection variableValues, [NotNullWhen(true)] out ObjectFieldNode?rewritten) { if (TryRewriteValue( original.Value, field.Type, field.DefaultValue ?? NullValueNode.Default, variableValues, out IValueNode? rewrittenValue)) { rewritten = original.WithValue(rewrittenValue); return(true); } rewritten = null; return(false); }
private static bool TryParseValue( IValueNode valueNode, IVariableValueCollection variables, out int value) { if (valueNode is VariableNode variable) { return(variables.TryGetVariable( variable.Name.Value, out value)); } else if (valueNode is IntValueNode literal) { return(int.TryParse( literal.Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out value)); } value = default; return(false); }
/// <summary> /// Creates a new instance of <see cref="ComplexityContext" /> /// </summary> public ComplexityContext( IOutputField field, FieldNode selection, CostDirective?cost, int fieldDepth, int nodeDepth, int childComplexity, int defaultComplexity, IVariableValueCollection valueCollection, InputParser inputParser) { Field = field; Selection = selection; Complexity = cost?.Complexity ?? defaultComplexity; ChildComplexity = childComplexity; Multipliers = cost?.Multipliers ?? Array.Empty <MultiplierPathString>(); DefaultMultiplier = cost?.DefaultMultiplier; FieldDepth = fieldDepth; NodeDepth = nodeDepth; _valueCollection = valueCollection; _inputParser = inputParser; }
public static int Calculate( IOutputField field, FieldNode selection, CostDirective costDirective, int fieldDepth, int nodeDepth, int childComplexity, IVariableValueCollection variables, InputParser inputParser, ComplexityAnalyzerSettings analyzerSettings) { return(analyzerSettings.Calculation.Invoke( new ComplexityContext( field, selection, costDirective, fieldDepth, nodeDepth, childComplexity, analyzerSettings.DefaultComplexity, variables, inputParser))); }
private static bool IsTrue( IVariableValueCollection variables, IValueNode value) { if (value is BooleanValueNode b) { return(b.Value); } if (value is VariableNode v) { return(variables.GetVariable <bool>(v.Name.Value)); } // TODO: Resources throw new QueryException( ErrorBuilder.New() .SetMessage( "The skip/include if-argument " + "value has to be a 'Boolean'.") .AddLocation(value) .Build()); }
public string?GetLabel(IVariableValueCollection variables) => Directives.GetDeferDirective(variables)?.Label;