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;
