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