private IEnumerable <StatementSyntax> GenerateReadMethodBody()
{
var fields = _schema.GetInputFields(_inputObjectType);
foreach (var fieldDefinition in fields)
{
var fieldName = fieldDefinition.Key.ToFieldResolverName();
var rawFieldName = fieldDefinition.Key;
var fieldTypeName = CodeModel.SelectFieldTypeName(_schema, _inputObjectType, fieldDefinition);
yield return(ExpressionStatement(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
IdentifierName(fieldName),
InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("source"),
GenericName(
Identifier("GetValue"))
.WithTypeArgumentList(
TypeArgumentList(
SingletonSeparatedList(
ParseTypeName(fieldTypeName))))))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(rawFieldName)))))))));
}
}
private IEnumerable <MemberDeclarationSyntax> GenerateFields()
{
yield return(CodeModel.TypenameProperty(_inputObjectType.Name));
var fields = _schema.GetInputFields(_inputObjectType);
foreach (var fieldDefinition in fields)
{
var fieldName = fieldDefinition.Key.ToFieldResolverName();
var fieldTypeName = CodeModel.SelectFieldTypeName(_schema, _inputObjectType, fieldDefinition);
yield return(PropertyDeclaration(
IdentifierName(fieldTypeName),
Identifier(fieldName))
.WithModifiers(
TokenList(
Token(SyntaxKind.PublicKeyword)))
.WithLeadingTrivia(CodeModel.ToXmlComment(fieldDefinition.Value.Description))
.WithAccessorList(
AccessorList(
List(
new[]
{
AccessorDeclaration(
SyntaxKind.GetAccessorDeclaration)
.WithSemicolonToken(
Token(SyntaxKind.SemicolonToken)),
AccessorDeclaration(
SyntaxKind.SetAccessorDeclaration)
.WithSemicolonToken(
Token(SyntaxKind.SemicolonToken))
}))));
}
yield return(GenerateRead());
}
private MemberDeclarationSyntax GenerateProperty(KeyValuePair <string, IField> field)
{
var propertyName = field.Key.ToFieldResolverName();
var typeName = CodeModel.SelectFieldTypeName(_schema, _interfaceType, field);
return(PropertyDeclaration(
IdentifierName(typeName),
Identifier(propertyName))
.WithModifiers(
TokenList(
Token(SyntaxKind.PublicKeyword)))
.WithLeadingTrivia(CodeModel.ToXmlComment(field.Value.Description))
.WithAccessorList(
AccessorList(
List(
new[]
{
AccessorDeclaration(
SyntaxKind.GetAccessorDeclaration)
.WithSemicolonToken(
Token(SyntaxKind.SemicolonToken)),
/*AccessorDeclaration(
* SyntaxKind.SetAccessorDeclaration)
* .WithSemicolonToken(
* Token(SyntaxKind.SemicolonToken))*/
}))));
}
private MethodDeclarationSyntax WithPropertyFieldMethod(
string methodName,
ObjectType objectType,
KeyValuePair <string, IField> field)
{
var resultTypeName = CodeModel.SelectFieldTypeName(_schema, _objectType, field);
return(MethodDeclaration(
GenericName(
Identifier(nameof(ValueTask)))
.WithTypeArgumentList(
TypeArgumentList(
SingletonSeparatedList <TypeSyntax>(
IdentifierName(resultTypeName)))),
Identifier(methodName))
.WithModifiers(
TokenList(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.VirtualKeyword)))
.WithParameterList(
ParameterList(
SeparatedList <ParameterSyntax>(
new SyntaxNodeOrToken[]
{
Parameter(
Identifier("objectValue"))
.WithType(
IdentifierName("T")),
Token(SyntaxKind.CommaToken),
Parameter(
Identifier("context"))
.WithType(
IdentifierName(nameof(IResolverContext)))
})))
.WithBody(
Block(
SingletonList <StatementSyntax>(
ReturnStatement(
ObjectCreationExpression(
GenericName(
Identifier(nameof(ValueTask)))
.WithTypeArgumentList(
TypeArgumentList(
SingletonSeparatedList <TypeSyntax>(
IdentifierName(resultTypeName)))))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("objectValue"),
IdentifierName(methodName)))))))))));
}
private MethodDeclarationSyntax WithAbstractFieldMethod(
string methodName,
ObjectType objectType,
KeyValuePair <string, IField> field)
{
var resultTypeName = CodeModel.SelectFieldTypeName(_schema, _objectType, field);
return(MethodDeclaration(
GenericName(
Identifier(nameof(ValueTask)))
.WithTypeArgumentList(
TypeArgumentList(
SingletonSeparatedList <TypeSyntax>(
IdentifierName(resultTypeName)))),
Identifier(methodName))
.WithModifiers(
TokenList(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.AbstractKeyword)))
.WithParameterList(
ParameterList(
SeparatedList <ParameterSyntax>(
WithParameters(objectType, field))))
.WithSemicolonToken(
Token(SyntaxKind.SemicolonToken)));
}
public string SelectFieldType(KeyValuePair <string, IField> field)
{
return(CodeModel.SelectFieldTypeName(_schema, _objectType, field));
}
