public InputValueContext(InputValueDefinition arg, GraphQLGenerationOptions options, Document document, string propertyName)
{
this.arg = arg;
this.options = options;
this.document = document;
this.PropertyName = propertyName;
}
public void FromString()
{
/* Given */
/* When */
InputValueDefinition original = "field: ENUM";
/* Then */
Assert.Equal("field", original.Name);
Assert.IsType <NamedType>(original.Type);
}
public void FromBytes()
{
/* Given */
/* When */
InputValueDefinition original = Encoding.UTF8.GetBytes("field: ENUM")
.AsReadOnlySpan();
/* Then */
Assert.Equal("field", original.Name);
Assert.IsType <NamedType>(original.Type);
}
public void WithDescription()
{
/* Given */
InputValueDefinition original = "field: ENUM!";
/* When */
var modified = original
.WithDescription("Description");
/* Then */
Assert.Equal("Description", modified.Description);
}
public void WithName()
{
/* Given */
InputValueDefinition original = "field: ENUM!";
/* When */
var modified = original
.WithName("b");
/* Then */
Assert.Equal("field", original.Name);
Assert.Equal("b", modified.Name);
}
private void VisitInputValueDefinition(InputValueDefinition node)
{
EnterNode(node);
Visit(node.Type);
if (node.DefaultValue != null)
{
Visit(node.DefaultValue);
}
Visit(node.Directives);
ExitNode(node);
}
public void WithType()
{
/* Given */
InputValueDefinition original = @"field: Int";
/* When */
var modified = original
.WithType("String!");
/* Then */
var nonNull = Assert.IsType <NonNullType>(modified.Type);
var named = Assert.IsType <NamedType>(nonNull.OfType);
Assert.Equal("String", named.Name);
}
private string PrintInputValueDefinition(InputValueDefinition node)
{
var name = PrintName(node.Name);
var type = Print(node.Type);
var directives = node.Directives?.Select(PrintDirective);
var defaultValue = Print(node.DefaultValue);
return(Join(new[]
{
$"{name}: {type}",
Wrap("= ", defaultValue),
Join(directives, " ")
},
" "));
}
protected override void ExitInputValueDefinition(PrinterContext context, InputValueDefinition inputValueDefinition)
{
if (context.Parent is ArgumentsDefinition)
{
if (context.CurrentArray?.Count > 1 && !context.CurrentArray.IsLast)
{
context.Append(", ");
}
}
if (context.Parent is InputFieldsDefinition)
{
if (context.CurrentArray?.Count > 1 && !context.CurrentArray.IsLast)
{
context.Append(" ");
}
}
}
public void WithDirectives()
{
/* Given */
InputValueDefinition original = @"field: Int";
/* When */
var modified = original
.WithDirectives(new List <Directive>
{
"@a",
});
/* Then */
Assert.NotNull(modified.Directives);
var a = Assert.Single(modified.Directives);
Assert.Equal("a", a?.Name);
}
public static object?CoerceArgumentValue(
ISchema schema,
IReadOnlyDictionary <string, object?>?coercedVariableValues,
string argumentName,
InputValueDefinition argumentDefinition,
Argument?argument)
{
var argumentType = argumentDefinition.Type;
var defaultValue = argumentDefinition.DefaultValue?.Value;
var argumentValue = argument?.Value;
var hasValue = argumentValue != null;
object?value = null;
if (argumentValue is Variable variable)
{
if (coercedVariableValues == null)
{
hasValue = false;
}
else
{
string variableName = variable.Name;
hasValue = coercedVariableValues.ContainsKey(variableName);
if (hasValue)
{
value = coercedVariableValues[variableName];
}
}
}
else
{
value = argumentValue;
}
if (argumentType is NonNullType && (!hasValue || value == null))
{
throw new ValueCoercionException(
$"Argument '{argumentName}' is non-null but no value could be coerced",
null,
argumentType);
}
if (hasValue)
{
if (value == null)
{
return(null);
}
if (argumentValue is Variable)
{
return(value);
}
var coercedValue = Values.CoerceValue(
schema,
value,
argumentType);
return(coercedValue);
}
return(Values.CoerceValue(
schema,
defaultValue,
argumentType));
}
protected override void EnterInputValueDefinition(PrinterContext context, InputValueDefinition inputValueDefinition)
{
context.AppendDescription(inputValueDefinition.Description);
context.Append(inputValueDefinition.Name);
context.Append(": ");
}
public virtual TResult VisitInputValueDefinition(InputValueDefinition node)
{
return(DefaultVisit(node));
}
protected virtual void ExitInputValueDefinition(TContext context, InputValueDefinition inputValueDefinition)
{
}
public static InputValueDefinition WithDescription(this InputValueDefinition definition,
in StringValue?description)
