protected override void VisitVariableDefinition( VariableDefinitionNode node, object context) { VisitedVariableDefinition = true; base.VisitVariableDefinition(node, context); }
private static void CheckForInvalidValueType( VariableDefinitionNode variableDefinition, Variable variable) { bool invalid = false; if (variable.Value != null) { invalid = variable.Value is IValueNode literal ? !variable.Type.IsInstanceOfType(literal) : !variable.Type.IsInstanceOfType(variable.Value); } if (invalid) { throw new QueryException(ErrorBuilder.New() .SetMessage(string.Format( CultureInfo.InvariantCulture, TypeResources.VariableValueBuilder_InvalidValue, variable.Name)) .SetCode(ErrorCodes.Execution.InvalidType) .SetExtension("variable_name", variable.Name) .AddLocation(variableDefinition) .Build()); } }
public static GraphQLException VariableValueInvalidType( VariableDefinitionNode variableDefinition, Exception?exception = null) { IErrorBuilder errorBuilder = ErrorBuilder.New() .SetMessage( "Variable `{0}` got an invalid value.", variableDefinition.Variable.Name.Value) .SetCode(ErrorCodes.Execution.InvalidType) .SetExtension("variable", variableDefinition.Variable.Name.Value) .AddLocation(variableDefinition); switch (exception) { case ScalarSerializationException ex: errorBuilder.SetExtension("scalarError", ex.Message); break; case InputObjectSerializationException ex: errorBuilder.SetExtension("inputObjectError", ex.Message); break; default: errorBuilder.SetException(exception); break; } return(new GraphQLException(errorBuilder.Build())); }
protected override ISyntaxVisitorAction Enter( VariableDefinitionNode node, IDocumentValidatorContext context) { ValidateDirectiveAreUniquePerLocation(node, context); return(Continue); }
private Variable CreateVariable(VariableDefinitionNode variableDefinition) { var variableName = variableDefinition.Variable.Name.Value; IType variableType = GetType(variableDefinition.Type); if (variableType is IInputType type) { object defaultValue = null; if (!variableDefinition.DefaultValue.IsNull()) { defaultValue = variableType.NamedType().IsLeafType() ? type.ParseLiteral(variableDefinition.DefaultValue) : variableDefinition.DefaultValue; } return(new Variable(variableName, type, defaultValue)); } throw new QueryException(ErrorBuilder.New() .SetMessage(string.Format( CultureInfo.InvariantCulture, TypeResources.VariableValueBuilder_InputType, variableName, TypeVisualizer.Visualize(variableType))) .SetCode(ErrorCodes.Execution.MustBeInputType) .AddLocation(variableDefinition) .Build()); }
protected override ISyntaxVisitorAction Enter( VariableDefinitionNode node, IDocumentValidatorContext context) { base.Enter(node, context); var variableName = node.Variable.Name.Value; context.Unused.Add(variableName); context.Declared.Add(variableName); if (context.Schema.TryGetType( node.Type.NamedType().Name.Value, out INamedType type) && !type.IsInputType()) { context.Errors.Add(context.VariableNotInputType(node, variableName)); } if (!context.Names.Add(variableName)) { context.Errors.Add(context.VariableNameNotUnique(node, variableName)); } return(Skip); }
protected override ISyntaxVisitorAction Enter( VariableDefinitionNode node, IDocumentValidatorContext context) { context.Variables[node.Variable.Name.Value] = node; return(Continue); }
protected void VarDefinitionNode(SymbolResolverVisitor visitor, VariableDefinitionNode vardecl) { foreach (var definition in vardecl.Definitions) { // Get the identifier name var variableName = definition.Left.Value; var storage = SymbolHelper.GetStorage(vardecl.Information.Mutability); // Check if the symbol is already defined if (visitor.SymbolTable.HasVariableSymbol(variableName)) { throw new SymbolException($"Symbol {variableName} is already defined."); } // If it is a variable definition, visit the right-hand side expression var rhsSymbol = definition.Right?.Visit(visitor); IVariable lhsSymbol = null; if (rhsSymbol == null) { // Create the new symbol for the variable var typeInfo = SymbolHelper.GetTypeSymbol(visitor.SymbolTable, visitor.Inferrer, vardecl.Information.Type); lhsSymbol = visitor.SymbolTable.AddNewVariableSymbol(variableName, typeInfo, Access.Public, storage); } else { visitor.SymbolTable.AddNewVariableSymbol(variableName, rhsSymbol.GetTypeSymbol(), Access.Public, storage); } } }
public IValueNode Convert(object from, IInputType type, VariableDefinitionNode variable) { if (from == null) { throw new ArgumentNullException(nameof(from)); } if (type is null) { throw new ArgumentNullException(nameof(type)); } if (variable is null) { throw new ArgumentNullException(nameof(variable)); } var context = new ConverterContext { InputType = type, Node = variable, Name = "$" + variable.Variable.Name.Value }; Visit(from, context); return((IValueNode)context.Object); }
protected IType VarDefinitionNode(TypeInferrerVisitor visitor, VariableDefinitionNode vardecl) { foreach (var definition in vardecl.Definitions) { // Symbol should be already resolved here var leftSymbol = visitor.SymbolTable.GetVariableSymbol(definition.Left.Value); // If the rhs is null, continue, is just a declaration if (definition.Right == null) { continue; } // If it is a variable definition, get the right-hand side type info var rhsTypeSymbol = definition.Right?.Visit(visitor); // If the symbol is an anonymous type, the rhs type is a must if (leftSymbol.TypeSymbol is Anonymous && rhsTypeSymbol == null) { throw new SymbolException($"Implicitly-typed variable '{leftSymbol.Name}' needs to be initialized"); } // Get the most general type that encloses both types var generalType = visitor.Inferrer.FindMostGeneralType(leftSymbol.TypeSymbol, rhsTypeSymbol); // Update lhs and rhs (if present) visitor.Inferrer.Unify(visitor.SymbolTable, generalType, leftSymbol); } return(null); }
private static object Normalize( VariableDefinitionNode variableDefinition, Variable variable, object rawValue) { object value = rawValue; if (value is null || value is NullValueNode) { return(null); } if (value is IValueNode literal) { CheckForInvalidValueType( variableDefinition, variable, literal); value = variable.Type.ParseLiteral(literal); } if (variable.Type.TryDeserialize(value, out object deserialized)) { return(deserialized); } return(value); }
protected override ISyntaxVisitorAction Leave( VariableDefinitionNode node, IDocumentValidatorContext context) { context.Types.Pop(); return(base.Enter(node, context)); }
private Variable CoerceVariableValue( VariableDefinitionNode variableDefinition, IReadOnlyDictionary <string, object> variableValues, Variable variable) { var value = variableValues.TryGetValue( variable.Name, out var rawValue) ? Normalize(variableDefinition, variable, rawValue) : variable.DefaultValue; variable = variable.WithValue(value); if (variable.Type.IsNonNullType() && variable.Value is null) { throw new QueryException(ErrorBuilder.New() .SetMessage(string.Format( CultureInfo.InvariantCulture, TypeResources.VariableValueBuilder_NonNull, variable.Name, TypeVisualizer.Visualize(variable.Type))) .AddLocation(variableDefinition) .Build()); } InputTypeNonNullCheck.CheckForNullValueViolation( variable.Type, variable.Value, _converter, message => ErrorBuilder.New() .SetMessage(message) .AddLocation(variableDefinition) .Build()); CheckForInvalidValueType(variableDefinition, variable); return(variable); }
public static GraphQLException VariableValueInvalidType( VariableDefinitionNode variableDefinition, Exception?exception = null) { var underlyingError = exception is SerializationException serializationException ? serializationException.Message : null; IErrorBuilder errorBuilder = ErrorBuilder.New() .SetMessage( ThrowHelper_VariableValueInvalidType_Message, variableDefinition.Variable.Name.Value) .SetCode(ErrorCodes.Execution.InvalidType) .SetExtension("variable", variableDefinition.Variable.Name.Value) .AddLocation(variableDefinition); if (exception is not null) { errorBuilder.SetException(exception); } if (underlyingError is not null) { errorBuilder.SetExtension(nameof(underlyingError), underlyingError); } return(new GraphQLException(errorBuilder.Build())); }
protected override ISyntaxVisitorAction Enter( VariableDefinitionNode node, IDocumentValidatorContext context) { context.UnusedVariables.Add(node.Variable.Name.Value); context.DeclaredVariables.Add(node.Variable.Name.Value); return(Skip); }
protected override VariableDefinitionNode RewriteVariableDefinition( VariableDefinitionNode node, bool context) { return(IsAutoGenerated && _globalVariableNames.Contains(node.Variable.Name.Value) ? node : node.WithVariable(node.Variable.WithName( node.Variable.Name.CreateNewName(_requestPrefix)))); }
public void CoerceVariableValues( ISchema schema, IReadOnlyList <VariableDefinitionNode> variableDefinitions, IReadOnlyDictionary <string, object?> values, IDictionary <string, VariableValueOrLiteral> coercedValues) { if (schema is null) { throw new ArgumentNullException(nameof(schema)); } if (variableDefinitions is null) { throw new ArgumentNullException(nameof(variableDefinitions)); } if (values is null) { throw new ArgumentNullException(nameof(values)); } if (coercedValues is null) { throw new ArgumentNullException(nameof(coercedValues)); } for (var i = 0; i < variableDefinitions.Count; i++) { VariableDefinitionNode variableDefinition = variableDefinitions[i]; var variableName = variableDefinition.Variable.Name.Value; IInputType variableType = AssertInputType(schema, variableDefinition); VariableValueOrLiteral coercedVariable; var hasValue = values.TryGetValue(variableName, out var value); if (!hasValue && variableDefinition.DefaultValue is { } defaultValue) { value = defaultValue.Kind is SyntaxKind.NullValue ? null : defaultValue; hasValue = true; } if (!hasValue || value is null || value is NullValueNode) { if (variableType.IsNonNullType()) { throw ThrowHelper.NonNullVariableIsNull(variableDefinition); } // if we do not have any value we will not create an entry to the // coerced variables. if (!hasValue) { continue; } coercedVariable = new(variableType, null, NullValueNode.Default); }
protected override void VisitVariableDefinition( VariableDefinitionNode node, object?context) { if (_schema.TryGetType(node.Type.NamedType().Name.Value, out INamedType type) && type is IInputType inputType) { VisitInputType(inputType); } }
private IValueNode RewriteVariable( OperationDefinitionNode operation, string name, object value) { VariableDefinitionNode variableDefinition = operation.VariableDefinitions.FirstOrDefault(t => string.Equals(t.Variable.Name.Value, name, StringComparison.Ordinal)); if (variableDefinition is { } &&
public ArgumentModel( string name, IInputType type, VariableDefinitionNode variable, IValueNode?defaultValue) { Name = name; Type = type; Variable = variable; DefaultValue = defaultValue; }
/// <summary> /// Initializes a new instance of <see cref="ArgumentModel" /> /// </summary> /// <param name="name">The name of the argument.</param> /// <param name="type">The GraphQL schema type of the argument.</param> /// <param name="variable">The variable declaration from the query syntax tree.</param> /// <param name="defaultValue">The default value.</param> public ArgumentModel( NameString name, IInputType type, VariableDefinitionNode variable, IValueNode?defaultValue) { Name = name.EnsureNotEmpty(nameof(name)); Type = type ?? throw new ArgumentNullException(nameof(type)); Variable = variable ?? throw new ArgumentNullException(nameof(variable)); DefaultValue = defaultValue; }
public RemoteQueryBuilder AddVariable( VariableDefinitionNode variable) { if (variable == null) { throw new ArgumentNullException(nameof(variable)); } _variables.Add(variable); return(this); }
protected override void VisitVariableDefinition( VariableDefinitionNode node, object?context) { if (_schema !.TryGetType( node.Type.NamedType().Name.Value, out INamedType type) && type.IsEnumType()) { _enumTypes.Add(type); } }
public static GraphQLException NonNullVariableIsNull( VariableDefinitionNode variableDefinition) { return(new( ErrorBuilder.New() .SetMessage( ThrowHelper_NonNullVariableIsNull_Message, variableDefinition.Variable.Name.Value) .SetCode(ErrorCodes.Execution.NonNullViolation) .SetExtension("variable", variableDefinition.Variable.Name.Value) .AddLocation(variableDefinition) .Build())); }
protected override void VisitVariableDefinition( VariableDefinitionNode node, TContext context) { VisitVariable(node.Variable, context); VisitType(node.Type, context); if (node.DefaultValue != null) { VisitValue(node.DefaultValue, context); } }
public static GraphQLException NonNullVariableIsNull( VariableDefinitionNode variableDefinition) { return(new GraphQLException( ErrorBuilder.New() .SetMessage( "Variable `{0}` is required.", variableDefinition.Variable.Name.Value) .SetCode(ErrorCodes.Execution.NonNullViolation) .SetExtension("variable", variableDefinition.Variable.Name.Value) .AddLocation(variableDefinition) .Build())); }
private static object Normalize( VariableDefinitionNode variableDefinition, Variable variable, object rawValue) { object value = rawValue; if (value is null || value is NullValueNode) { return(null); } if (value is IValueNode literal) { CheckForInvalidValueType(variableDefinition, variable, literal); if (variable.Type.NamedType().IsLeafType()) { return(variable.Type.ParseLiteral(literal)); } return(literal); } if (variable.Type.NamedType().IsLeafType()) { if (variable.Type.TryDeserialize(value, out object deserialized)) { return(deserialized); } else { throw new QueryException(ErrorBuilder.New() .SetMessage(string.Format( CultureInfo.InvariantCulture, TypeResources.VariableValueBuilder_InvalidValue, variable.Name)) .SetCode(ErrorCodes.Execution.InvalidType) .SetExtension("variable_name", variable.Name) .AddLocation(variableDefinition) .Build()); } } if (!(value is IReadOnlyDictionary <string, object>) && variable.Type.TryDeserialize(value, out object obj)) { return(obj); } return(DictionaryToObjectValueConverter.Default.Convert( value, variable.Type, variableDefinition)); }
public static GraphQLException VariableIsNotAnInputType( VariableDefinitionNode variableDefinition) { return(new( ErrorBuilder.New() .SetMessage( ThrowHelper_VariableIsNotAnInputType_Message, variableDefinition.Variable.Name.Value) .SetCode(ErrorCodes.Execution.MustBeInputType) .SetExtension("variable", variableDefinition.Variable.Name.Value) .SetExtension("type", variableDefinition.Type.ToString() !) .AddLocation(variableDefinition) .Build())); }
public static IError VariableNameNotUnique( this IDocumentValidatorContext context, VariableDefinitionNode node, string variableName) { return(ErrorBuilder.New() .SetMessage(Resources.ErrorHelper_VariableNameNotUnique) .AddLocation(node) .SetPath(context.CreateErrorPath()) .SetExtension("variable", variableName) .SetExtension("variableType", node.Type.ToString()) .SpecifiedBy("sec-Variable-Uniqueness") .Build()); }
protected override ISyntaxVisitorAction Enter( VariableDefinitionNode node, IDocumentValidatorContext context) { if (context.Schema.TryGetType( node.Type.NamedType().Name.Value, out INamedType variableType)) { context.Types.Push(variableType); return(base.Enter(node, context)); } context.UnexpectedErrorsDetected = true; return(Skip); }
public virtual Value evaluate(Context cx, VariableDefinitionNode node) { output("<VariableDefinitionNode position=\"" + node.pos() + "\">"); indent_Renamed_Field++; if (node.attrs != null) { node.attrs.evaluate(cx, this); } if (node.list != null) { node.list.evaluate(cx, this); } indent_Renamed_Field--; output("</VariableDefinitionNode>"); return null; }