protected override void EnterInputObjectDefinition(PrinterContext context,
InputObjectDefinition inputObjectDefinition)
{
context.Append(' ');
context.AppendDescription(inputObjectDefinition.Description);
context.Append("input ");
context.Append(inputObjectDefinition.Name);
context.Append(" ");
}
private void VisitInputObjectDefinition(InputObjectDefinition node)
{
EnterNode(node);
Visit(node.Directives);
Visit(node.Fields);
ExitNode(node);
}
public void WithName()
{
/* Given */
InputObjectDefinition original = @"input Obj";
/* When */
var modified = original
.WithName("Renamed");
/* Then */
Assert.Equal("Obj", original.Name);
Assert.Equal("Renamed", modified.Name);
}
public void FromString()
{
/* Given */
/* When */
InputObjectDefinition original =
@"input Obj {
field1: String
}";
/* Then */
Assert.Equal("Obj", original.Name);
Assert.NotNull(original.Fields);
}
public void WithDescription()
{
/* Given */
InputObjectDefinition original = @"input Obj";
/* When */
var modified = original
.WithDescription("Description");
/* Then */
Assert.Null(original.Description);
Assert.Equal("Description", modified.Description);
}
public void FromBytes()
{
/* Given */
/* When */
InputObjectDefinition original =
Encoding.UTF8.GetBytes(@"input Obj {
field1: String
}").AsReadOnlySpan();
/* Then */
Assert.Equal("Obj", original.Name);
Assert.NotNull(original.Fields);
}
public static TypeDefinition Extend(
this TypeDefinition typeDefinition,
params TypeExtension[] typeExtensions)
{
return(typeDefinition switch
{
EnumDefinition enumDefinition => Extend(enumDefinition, typeExtensions),
InputObjectDefinition inputObjectDefinition => Extend(inputObjectDefinition, typeExtensions),
InterfaceDefinition interfaceDefinition => Extend(interfaceDefinition, typeExtensions),
ObjectDefinition objectDefinition => Extend(objectDefinition, typeExtensions),
ScalarDefinition scalarDefinition => Extend(scalarDefinition, typeExtensions),
UnionDefinition unionDefinition => Extend(unionDefinition, typeExtensions),
_ => throw new ArgumentOutOfRangeException(nameof(typeDefinition))
});
private string PrintInputObjectTypeDefinition(InputObjectDefinition node)
{
var name = PrintName(node.Name);
var directives = node.Directives?.Select(PrintDirective);
var fields = node.Fields?.Select(PrintInputValueDefinition);
return(Join(new[]
{
"input",
name,
Join(directives, " "),
Block(fields) ?? "{ }"
},
" "));
}
public void WithFields()
{
/* Given */
InputObjectDefinition original = @"input Obj";
/* When */
var modified = original
.WithFields(new List <InputValueDefinition>
{
"field: Float!"
});
/* Then */
Assert.Null(original.Fields);
Assert.NotNull(modified.Fields);
Assert.NotEmpty(modified.Fields);
}
public void WithDirectives()
{
/* Given */
InputObjectDefinition original = @"input Obj";
/* When */
var modified = original
.WithDirectives(new List <Directive>
{
"@a"
});
/* Then */
Assert.Null(original.Directives);
Assert.NotNull(modified.Directives);
var a = Assert.Single(modified.Directives);
Assert.Equal("a", a?.Name);
}
public void WithFields_Modify()
{
/* Given */
InputObjectDefinition original = @"input Obj { field: String }";
/* When */
var modified = original
.WithFields(original
.Fields?
.Select(originalField => originalField
.WithDescription("Description"))
.ToList()
);
/* Then */
Assert.NotNull(modified.Fields);
var field = Assert.Single(modified.Fields);
Assert.Equal("Description", field?.Description);
}
public static object?CoerceValue(
ISchema schema,
object?value,
TypeBase valueType)
{
switch (valueType)
{
case NonNullType NonNullType:
return(CoerceNonNullTypeValue(
schema,
value,
NonNullType));
case ListType list:
return(CoerceListValues(
schema,
list.OfType,
value));
}
if (valueType is not NamedType namedValueType)
{
throw new ValueCoercionException(
$"Unexpected valueType {valueType}. Cannot coerce value.",
value,
valueType);
}
var valueTypeDefinition = schema.GetRequiredNamedType <TypeDefinition>(namedValueType.Name);
return(valueTypeDefinition switch
{
ScalarDefinition scalar => CoerceScalarValue(schema, value, scalar),
EnumDefinition enumDefinition => CoerceEnumValue(value, enumDefinition),
InputObjectDefinition input => CoerceInputValue(
schema,
value,
input),
_ => throw new ArgumentOutOfRangeException($"Type of the '{valueType} is not supported by value coercion")
});
public static InputObjectDefinition WithDescription(this InputObjectDefinition definition,
in StringValue?description)
public virtual TResult VisitInputObjectDefinition(InputObjectDefinition node)
{
return(DefaultVisit(node));
}
protected virtual void ExitInputObjectDefinition(TContext context, InputObjectDefinition inputObjectDefinition)
{
}
