How to get requested GraphQL fields in C#?

Question

I'm working on a GraphQL -> SQL parser that includes some joins, so it makes a performance difference whether a certain field is requested. Is there a way to find that out?

I'm learning about object types, so I think it might have something to do with setting a resolver on it. But a resolver works at the level of the field that's being requested independently of other things. Whereas I'm trying to figure out on the top-most Query level which fields have been requested in the GraphQL query. That will shape the SQL query.

public class QueryType : ObjectType<Query>
{
    protected override void Configure(IObjectTypeDescriptor<Query> descriptor)
    {
        descriptor
            .Field(f => f.GetACUMonthlySummary(default!, default!, default!, default!, default!, default!))
            .Type<ListType<ACUMonthlySummaryType>>();
    }
}

I saw related questions for js, but didn't find any examples specifically in C# and HotChocolate, which is what we're using.

Answer 1

Say for example(A simple one) you have a class called employee and it has FirstName and LastName properties. You may want want the GraphQL endpoint to expose a FullName field for the employee that will internally concatenate the first and last name. Note that FirstName and LastName values exist as columns of the Employee database table but the FullName field will be derived.

public class EmployeeType : ObjectType<Employee> {
    protected override void Configure(IObjectTypeDescriptor<Employee> descriptor) {
        descriptor.Field(@"FullName")
            .Type<StringType>()
            .ResolveWith<Resolvers>( p => p.GetFullName(default!, default!) )
            .UseDbContext<AppDbContext>()
            .Description(@"Full name of the employee");
    }

    private class Resolvers {
        
        public string GetFullName([Parent] Employee e, [ScopedService] AppDbContext context) {
            return e.FirstName + " " + e.LastName;
        }
    }
}

I'm pretty sure you'd have to annotate the Employee using the ParentAttribute.

Learn more about this in the resolver documentation

Answer 2

I'm not sure if this is recommended, so I appreciate feedback, but I found the following way to list all selected nodes:

1. Inject IResolverContext context (using HotChocolate.Resolvers) as one of the parameters in the query.
2. context.Selection.SyntaxNode.SelectionSet.Selections gives an IEnumerable<ISelectionNode>. That contains exactly the fields the user has selected.

Answer 3

Just add IResolverContext parameter on query method if you are using Annotation based approach.

 public async Task<Form> GetForm(long id, string organisationId, [Service] IFormRepository formRepository,
    IResolverContext context)
{
    //context.Selection.SyntaxNode.SelectionSet.Selections
    var form = await formRepository.GetFormById(id, organisationId);
    return new Form
    {
        Id = form.Id,
        Name = form.Name,
        ShortUrl = form.ShortUrl,
        PublishStatus = form.PublishStatus,
        Description = form.Description,
        OrganisationId = form.OrganizationId
    };
}

Get fields by using context.Selection.SyntaxNode.SelectionSet.Selections

Answer 4

The other answers work to get one layer down to get the fields, but do not work when you want to include the property names of the children. IE: if your query is

query myQuery{ myQuery(id: "123"){ id name embeddedDoc{ embeddedDocId embeddedDocName } } }

If you want to receive the following: id name embeddedDoc embeddedDocId embeddedDocName

OR filter on the passed in properties, you can use the following extension methods:

public static class HotChocolateExtensions
    {
    public static bool ContainsSelection(this IResolverContext resolverContext, PropertyInfo propertyInfo)
    {
        return resolverContext.ContainsSelection($"{propertyInfo.Name[..1].ToLower()}{propertyInfo.Name[1..]}");
    }
    public static bool ContainsSelection(this IResolverContext resolverContext, string selection)
    {
        return resolverContext.GetQuerySelections().Contains(selection);
    }
    public static IEnumerable<string> GetQuerySelections(this IResolverContext resolverContext)
    {
        var fields = resolverContext.Selection.SelectionSet?.Selections.Where(x => x.Kind == HotChocolate.Language.SyntaxKind.Field) ?? [];
        return fields.GetQuerySelections();
    }
    private static IEnumerable<string> GetQuerySelections(this IEnumerable<ISelectionNode> selectionNodes)
    {
        List<string> querySelections = new List<string>();
        foreach (var selectionNode in selectionNodes)
        {
            if (((dynamic)selectionNode).SelectionSet is not null)
            {
                querySelections.Add(selectionNode.ToString().Split(' ')[0]);
                IReadOnlyList<ISelectionNode>? subSelectionNodes = ((dynamic)selectionNode).SelectionSet?.Selections;
            
                querySelections.AddRange(GetQuerySelections(subSelectionNodes?.Where(x => x.Kind == HotChocolate.Language.SyntaxKind.Field) ?? []));
           }
            else
            {
                querySelections.Add(selectionNode.ToString());
            }
         }
         return querySelections;
     }
}

Usage:

public bool FooQuery(IResolverContext resolverContext)
{
     return resolverContext.ContainsSelection(typeof(MyModel).GetProperty(nameof(MyModel.Id))!)
}