public AuthorizeDirective( SerializationInfo info, StreamingContext context) { var node = info.GetValue( nameof(DirectiveNode), typeof(DirectiveNode)) as DirectiveNode; if (node == null) { Roles = (string[])info.GetValue( nameof(Roles), typeof(string[])); } else { ArgumentNode rolesArgument = node.Arguments .FirstOrDefault(t => t.Name.Value == "roles"); Roles = (rolesArgument != null && rolesArgument.Value is ListValueNode lv) ? lv.Items.OfType <StringValueNode>() .Select(t => t.Value?.Trim()) .Where(s => !string.IsNullOrEmpty(s)) .ToArray() : Array.Empty <string>(); } }
private static EventDescription CreateEventDescription(String _eventName, String _argumentTag, String _argumentValue) { ArgumentNode argumentNode = new ArgumentNode(_argumentTag, _argumentValue); EventDescription eventDescription = new EventDescription(_eventName, argumentNode); return(eventDescription); }
protected override ISyntaxVisitorAction Enter( ArgumentNode node, IDocumentValidatorContext context) { if (context.Directives.TryPeek(out DirectiveType directive)) { if (directive.Arguments.TryGetField(node.Name.Value, out Argument? argument)) { context.InputFields.Push(argument); context.Types.Push(argument.Type); return(Continue); } context.UnexpectedErrorsDetected = true; return(Skip); } if (context.OutputFields.TryPeek(out IOutputField field)) { if (field.Arguments.TryGetField(node.Name.Value, out IInputField? argument)) { context.InputFields.Push(argument); context.Types.Push(argument.Type); return(Continue); } context.UnexpectedErrorsDetected = true; return(Skip); } context.UnexpectedErrorsDetected = true; return(Skip); }
public static string DeprecationReason( this Language.IHasDirectives syntaxNode) { DirectiveNode directive = syntaxNode.Directives.FirstOrDefault(t => t.Name.Value == WellKnownDirectives.Deprecated); if (directive == null) { return(null); } ArgumentNode argument = directive.Arguments.FirstOrDefault(t => t.Name.Value == WellKnownDirectives.DeprecationReasonArgument); if (argument == null) { return(null); } if (argument.Value is StringValueNode s) { return(s.Value); } return(null); }
public static IValueNode IncludeValue( this IEnumerable <DirectiveNode> directives) { DirectiveNode directive = directives.GetIncludeDirective(); if (directive == null) { return(null); } ArgumentNode argumentNode = directive.Arguments.SingleOrDefault(); if (argumentNode == null) { throw new QueryException( ErrorBuilder.New() .SetMessage(string.Format( CultureInfo.InvariantCulture, CoreResources .DirectiveCollectionExtensions_NotValid, directive.Name.Value)) .Build()); } return(argumentNode.Value); }
public static NameString GetOriginalName( this INamedSyntaxNode typeDefinition, NameString schemaName) { if (typeDefinition == null) { throw new ArgumentNullException(nameof(typeDefinition)); } schemaName.EnsureNotEmpty(nameof(schemaName)); DirectiveNode sourceDirective = typeDefinition.Directives .FirstOrDefault(t => HasSourceDirective(t, schemaName)); if (sourceDirective != null) { ArgumentNode argument = sourceDirective.Arguments.First(t => DirectiveFieldNames.Source_Name.Equals(t.Name.Value)); if (argument.Value is StringValueNode value) { return(value.Value); } } return(typeDefinition.Name.Value); }
private static DirectiveNode CreateExecutionInfo(ISelection selection) { var arguments = new ArgumentNode[selection.IsInternal ? 4 : 3]; arguments[0] = new ArgumentNode("id", new IntValueNode(selection.Id)); arguments[1] = new ArgumentNode("kind", new EnumValueNode(selection.Strategy)); if (selection.Field.Type.IsListType()) { if (selection.Field.Type.NamedType().IsLeafType()) { arguments[2] = new ArgumentNode("type", new EnumValueNode("LEAF_LIST")); } else { arguments[2] = new ArgumentNode("type", new EnumValueNode("COMPOSITE_LIST")); } } else if (selection.Field.Type.IsCompositeType()) { arguments[2] = new ArgumentNode("type", new EnumValueNode("COMPOSITE")); } else if (selection.Field.Type.IsLeafType()) { arguments[2] = new ArgumentNode("type", new EnumValueNode("LEAF")); } if (selection.IsInternal) { arguments[3] = new ArgumentNode("internal", BooleanValueNode.True); } return(new DirectiveNode("__execute", arguments)); }
public AbstractProperty(ArgumentNode node, T parent) { Name = node.Name; Node = node; Parent = parent; DataType = new AbstractDataType(node.ArgType); }
private CostDirective( SerializationInfo info, StreamingContext context) { var node = info.GetValue( nameof(DirectiveNode), typeof(DirectiveNode)) as DirectiveNode; if (node is null) { _complexity = info.GetInt32(nameof(Complexity)); _defaultMultiplier = info.GetInt32(nameof(DefaultMultiplier)); _multipliers = ((string[])info .GetValue(nameof(Multipliers), typeof(string[]))) .Where(s => !string.IsNullOrEmpty(s)) .Select(s => new MultiplierPathString(s)) .ToArray(); } else { ArgumentNode complexityArgument = node.Arguments .FirstOrDefault(t => t.Name.Value == "complexity"); ArgumentNode multipliersArgument = node.Arguments .FirstOrDefault(t => t.Name.Value == "multipliers"); ArgumentNode defaultMultiplierArgument = node.Arguments .FirstOrDefault(t => t.Name.Value == "defaultMultiplier"); _complexity = complexityArgument is { Value : IntValueNode iv }
protected static void AddElement( TProgram program, ArgumentNode node, SymbolNode rootNode, HashSet <SymbolNode> visited) { if (program == null) { return; } // creates child symbol node if needed and updates count var numChildren = program.Children?.Count ?? 0; if (!node.Children.ContainsKey(program.Label)) { node.Children.Add(program.Label, new SymbolNode(program.Label, numChildren, rootNode)); } var symbolNode = node.Children[program.Label]; if (!visited.Contains(symbolNode)) { symbolNode.Value++; visited.Add(symbolNode); } // recurses through children if (program.Children == null || program.Children.Count == 0) { return; } for (var i = 0; i < program.Children.Count; i++) { AddElement((TProgram)program.Children[i], symbolNode.Children[i], rootNode, visited); } }
public static int DefaultCalculation( IOutputField field, FieldNode selection, CostDirective?cost, int fieldDepth, int nodeDepth, Func <string, object?> getVariable, IMaxComplexityOptionsAccessor options) { if (cost is null) { return(options.DefaultComplexity); } if (options.UseComplexityMultipliers) { if (cost.Multipliers.Count == 0) { return(cost.Complexity); } int complexity = 0; for (int i = 0; i < cost.Multipliers.Count; i++) { MultiplierPathString multiplier = cost.Multipliers[i]; ArgumentNode argument = selection.Arguments.FirstOrDefault(t => t.Name.Value.Equals(multiplier.Value)); if (argument is { } && argument.Value is { })
public static string GetSchemaName(this FieldNode field) { DirectiveNode directive = field.Directives .SingleOrDefault(t => IsSchemaDirective(t)); if (directive == null) { throw new ArgumentException( "The specified field is not annotated."); } ArgumentNode argument = directive.Arguments .SingleOrDefault(t => t.IsNameArgument()); if (argument == null) { throw new ArgumentException( "The schema directive has to have a name argument."); } if (argument.Value is StringValueNode value) { return(value.Value); } throw new ArgumentException( "The schema directive name attribute " + "has to be a string value."); }
private static bool?EvaluateDirective( this DirectiveNode directive, VariableCollection variables) { if (directive == null) { return(null); } ArgumentNode argumentNode = directive.Arguments.SingleOrDefault(); if (argumentNode == null) { throw new QueryException(new QueryError( $"The {directive.Name.Value} attribute is not valid.")); } if (argumentNode.Value is BooleanValueNode b) { return(b.Value); } if (argumentNode.Value is VariableNode v) { return(variables.GetVariable <bool>(v.Name.Value)); } throw new QueryException(new QueryError( $"The {directive.Name.Value} if-argument value has to be a 'Boolean'.")); }
private bool AreFieldArgumentsEqual( ArgumentNode argumentA, ArgumentNode argumentB) { return(argumentA.Name.Value == argumentB.Name.Value && argumentA.Value.Equals(argumentB.Value)); }
private static bool TryGetMultiplierFromObject( FieldNode field, IVariableValueCollection variables, string multiplierPath, out int value) { var path = new Queue <string>(multiplierPath.Split('.')); string name = path.Dequeue(); ArgumentNode argument = field.Arguments .FirstOrDefault(t => t.Name.Value == name); if (argument == null) { value = default; return(false); } IValueNode current = argument.Value; while (current is ObjectValueNode) { if (current is ObjectValueNode obj) { current = ResolveObjectField(obj, path); } } return(TryParseValue(current, variables, out value)); }
protected override ArgumentNode RewriteArgument( ArgumentNode node, Context context) { ArgumentNode current = node; if (context.OutputField != null && context.OutputField.Arguments.TryGetField(current.Name.Value, out IInputField inputField)) { Context cloned = context.Clone(); cloned.InputField = inputField; cloned.InputType = inputField.Type; if (inputField.TryGetSourceDirective(context.Schema, out SourceDirective sourceDirective) && !sourceDirective.Name.Equals(current.Name.Value)) { current = current.WithName( new NameNode(sourceDirective.Name)); } return(base.RewriteArgument(current, cloned)); } return(base.RewriteArgument(current, context)); }
protected override void VisitArgument( ArgumentNode node, TContext context) { VisitName(node.Name, context); VisitValue(node.Value, context); }
protected override ISyntaxVisitorAction Leave( ArgumentNode node, IDocumentValidatorContext context) { context.InputFields.Pop(); context.Types.Pop(); return(Continue); }
protected override void ResolveChildren( ArgumentNode node, IList <SyntaxNodeInfo> children) { ResolveChildren( nameof(node.Value), node.Value, children); }
public static IError ArgumentValueIsInvalid( ArgumentNode argument, string responseName, GraphQLException exception) { return(ErrorBuilder.FromError(exception.Errors[0]) .AddLocation(argument) .SetExtension("responseName", responseName) .Build()); }
public static IError ArgumentValueIsInvalid( ArgumentNode argument, string responseName, ScalarSerializationException exception) { return(ErrorBuilder.New() .SetMessage(exception.Message) .AddLocation(argument) .SetExtension("responseName", responseName) .Build()); }
public VisitorAction Leave( ArgumentNode node, ISyntaxNode parent, IReadOnlyList <object> path, IReadOnlyList <ISyntaxNode> ancestors) { if (_action.Pop() == VisitorAction.Continue) { _type.Pop(); } return(VisitorAction.Continue); }
public static IError ArgumentNotUnique( this IDocumentValidatorContext context, ArgumentNode node, IOutputField?field = null, DirectiveType?directive = null) { IErrorBuilder builder = ErrorBuilder.New() .SetMessage(Resources.ErrorHelper_ArgumentNotUnique) .AddLocation(node) .SetPath(context.CreateErrorPath()); if (field is { })
public VariableUsage( IInputField inputField, ArgumentNode argument, VariableNode variable) { InputField = inputField ?? throw new ArgumentNullException(nameof(inputField)); Argument = argument ?? throw new ArgumentNullException(nameof(argument)); Variable = variable ?? throw new ArgumentNullException(nameof(variable)); }
private static bool HasSourceDirective( DirectiveNode directive, NameString schemaName) { if (DirectiveNames.Source.Equals(directive.Name.Value)) { ArgumentNode argument = directive.Arguments.FirstOrDefault(t => DirectiveFieldNames.Source_Schema.Equals(t.Name.Value)); return(argument != null && argument.Value is StringValueNode sv && schemaName.Equals(sv.Value)); } return(false); }
public static IError ArgumentNonNullError( ArgumentNode argument, string responseName, ArgumentNonNullValidator.ValidationResult validationResult) { return(ErrorBuilder.New() .SetMessage( "Detected a non-null violation in argument `{0}`.", argument.Name.Value) .AddLocation(argument) .SetExtension("responseName", responseName) .SetExtension("errorPath", validationResult.Path) .Build()); }
public void AddCommand(string commandstring) { CommandStrings.Add(commandstring); ArgumentNode an = new ArgumentNode(commandstring); if (an.Key != null) { Commands.Add(an.Key, an); } else { throw new ArgumentException("Outermost command must have a name"); } }
public static IError ArgumentNonNullError( ArgumentNode argument, string responseName, ArgumentNonNullValidator.ValidationResult validationResult) { return(ErrorBuilder.New() .SetMessage( ErrorHelper_ArgumentNonNullError_Message, argument.Name.Value) .AddLocation(argument) .SetExtension("responseName", responseName) .SetExtension("errorPath", validationResult.Path) .Build()); }
public static IError ArgumentValueIsNotCompatible( this IDocumentValidatorContext context, ArgumentNode node, IInputType locationType, IValueNode valueNode) { return(ErrorBuilder.New() .SetMessage(Resources.ErrorHelper_ArgumentValueIsNotCompatible) .AddLocation(valueNode) .SetPath(context.CreateErrorPath()) .SetExtension("argument", node.Name.Value) .SetExtension("argumentValue", valueNode.ToString()) .SetExtension("locationType", locationType.Print()) .SpecifiedBy("sec-Values-of-Correct-Type") .Build()); }
private static IValueNode GetIfArgumentValue(DirectiveNode directive) { if (directive.Arguments.Count == 1) { ArgumentNode argument = directive.Arguments[0]; if (string.Equals( argument.Name.Value, WellKnownDirectives.IfArgument, StringComparison.Ordinal)) { return(argument.Value); } } throw ThrowHelper.MissingIfArgument(directive); }