How can we add a custom field for sorting?

[gojanpaolo]

We're trying to add a custom field for sorting like so:

class FooSortInputType : SortInputType<Foo>
{
    protected override void Configure(ISortInputTypeDescriptor<Foo> descriptor)
    {
        descriptor.Field("bar");
    }
}

But we can't figure out how to properly set it up.

We tried:

descriptor.Field("bar")
    .Type<DefaultSortEnumType>() // we also tried other types like BooleanType, BarSortInputType, etc
    .Extend()
    .OnBeforeCreate(_ => _.Handler = new BarHandler()); // BarHandler inherits QueryableDefaultSortFieldHandler

But we're getting:

For the field bar of type FooSortInput was no field handler found.

---

Ultimately, we'd like to extend the sorting feature that would allow us to handle the following query:

foos(order: { bar(id: "baz"): ASC } })

[PascalSenn]

Hi @gojanpaolo

This is not valid graphql. Input objects cannot have arguments

foos(order: { bar(id: "baz"): ASC } }) 

This PR will fix your problem:
https://github.com/ChilliCream/hotchocolate/pull/3222/files

What you can do meanwhile is exactly the same thing as in filtering :)

            builder.AddConvention(
                new SortConventionExtension(
                    x => x.AddProviderExtension(
                        new QueryableSortProviderExtension(x =>
                            x.AddFieldHandler(new BarHandler())))))

[gojanpaolo]

Thanks for the response!

I see... is the following alternative query valid and can be implemented in HC?

foos(order: { bar: { id: "baz", sort: ASC } }

[PascalSenn]

yes that would be valid. You will have to declare another input object for this

    public class FooBarSortInputType : SortInputType
    {
        protected override void Configure(ISortInputTypeDescriptor descriptor)
        {
            descriptor.Name("FooBarSortInput");
            
            descriptor.Field("id").Type<NonNullType<StringType>>();
            
            descriptor.Field("sort").Type<DefaultSortEnumType>();
        }
    }

you can then do

escriptor.Field("bar")
    .Type<FooBarSortInput>() 

And the handler would look something like this:

    
        public class FoobarSortHandler
        : SortFieldHandler<QueryableSortContext, QueryableSortOperation>
    {
        public override bool CanHandle(
            ITypeCompletionContext context,
            ISortInputTypeDefinition typeDefinition,
            ISortFieldDefinition fieldDefinition) =>
            typeDefinition is SortInputTypeDefinition { Name: { Value: "FooBarSortInput" } };

        public override bool TryHandleEnter(
            QueryableSortContext context,
            ISortField field,
            ObjectFieldNode node,
            [NotNullWhen(true)] out ISyntaxVisitorAction? action)
        {
            //...........
            action = SyntaxVisitor.Continue;
            return true;
        }

        public override bool TryHandleLeave(
            QueryableSortContext context,
            ISortField field,
            ObjectFieldNode node,
            [NotNullWhen(true)] out ISyntaxVisitorAction? action)
        {
            //...........
            action = SyntaxVisitor.Continue;
            return true;
        }
    }

[gojanpaolo]

@PascalSenn I tried following your example but I'm still getting the same error.

I created a sample project here: https://github.com/gojanpaolo/hc-3209

The error For the field bar of type FooSortInput was no field handler found happens when reloading the schema using Banana Cake Pop.

Here's most of the code

using HotChocolate.Configuration;
using HotChocolate.Data;
using HotChocolate.Data.Sorting;
using HotChocolate.Data.Sorting.Expressions;
using HotChocolate.Types;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace WebApplication
{
    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
            services
                .AddGraphQLServer()
                .AddSorting<CustomSortConvention>()
                .AddQueryType<Query>()
                .AddType<FooSortInputType>()
                .AddType<FooBarSortInputType>();
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
                app.UseDeveloperExceptionPage();

            app.UseHttpsRedirection();

            app.UseRouting();

            app.UseEndpoints(_ => _.MapGraphQL());
        }
    }

    public class Query
    {
        public Foo GetFoo() => default;
    }

    public class Foo
    {
        public int Id { get; set; }
    }

    public class FooSortInputType : SortInputType<Foo>
    {
        protected override void Configure(ISortInputTypeDescriptor<Foo> descriptor)
        {
            descriptor
                .Field("bar")
                .Type<FooBarSortInputType>();
        }
    }

    public class CustomSortConvention : SortConvention
    {
        protected override void Configure(ISortConventionDescriptor descriptor)
        {
            descriptor.AddDefaults();

            descriptor
                .AddProviderExtension(
                    new QueryableSortProviderExtension(_ => _
                        .AddFieldHandler(new FooBarSortHandler())));
        }
    }

    public class FooBarSortInputType : SortInputType
    {
        protected override void Configure(ISortInputTypeDescriptor descriptor)
        {
            descriptor.Name("FooBarSortInput");
            descriptor.Field("id").Type<NonNullType<StringType>>();
            descriptor.Field("sort").Type<DefaultSortEnumType>();
        }
    }

    public class FooBarSortHandler : SortFieldHandler<QueryableSortContext, QueryableSortOperation>
    {
        public override bool CanHandle(
            ITypeCompletionContext context,
            ISortInputTypeDefinition typeDefinition,
            ISortFieldDefinition fieldDefinition) =>
            typeDefinition is SortInputTypeDefinition { Name: { Value: "FooBarSortInput" } };
    }
}

[gojanpaolo]

I think I got it.. Basically, we also need to handle when the fieldDefinition is for FooBarSortInputType

public class FooBarSortHandler : SortFieldHandler<QueryableSortContext, QueryableSortOperation>
{
    public override bool CanHandle(
        ITypeCompletionContext context,
        ISortInputTypeDefinition typeDefinition,
        ISortFieldDefinition fieldDefinition) =>
        typeDefinition is SortInputTypeDefinition { Name: { Value: "FooBarSortInput" } }
        || (fieldDefinition is SortFieldDefinition sortFieldDefinition
            && sortFieldDefinition.Type is ExtendedTypeReference extendedTypeReference
            && extendedTypeReference.Type.Type == typeof(FooBarSortInputType));
}

[gojanpaolo]

@PascalSenn I'm sorry for bothering you again but I'm currently stuck on the following:

I updated the TryHandleEnter implementation like so

public override bool TryHandleEnter(QueryableSortContext context, ISortField field, ObjectFieldNode node, [NotNullWhen(true)] out ISyntaxVisitorAction action)
{
    if (field.Name == "id")
    {
        // in our actual code, this has some complex logic that ultimately returns a bool and we sort by `true/1` and `false/0`
        Expression<Func<Foo, bool>> expression = _ => true;
        var lastFieldSelector = (QueryableFieldSelector)context.GetInstance();
        var nextSelector = Expression.Invoke(expression, lastFieldSelector.Selector);
        context.PushInstance(lastFieldSelector.WithSelector(nextSelector));
    }

    action = SyntaxVisitor.Continue;
    return true;
}

That allowed us to run the following query successfully:

query {
  foo(
    order: {
      bar: { id: "" }
    }
  ) {
    id
  }
}

But as soon as we add another field to sort it by:

query {
  foo(
    order: {
      bar: { id: "" }
      name: ASC
    }
  ) {
    id
  }
}

...we get the following error

"message": "Property 'System.String Name' is not defined for type 'System.Boolean' (Parameter 'property')",

I pushed the latest repro code here: https://github.com/gojanpaolo/hc-3209

I tried playing with the context.PushInstance, PopInstance in leave, RunTimeTypes, etc but I just can't get it to work.

Basically, this is the logic we're trying to replicate:

foos
.OrderBy(_ => true)  // in our actual code, this has some complex logic that ultimately returns a bool
.ThenBy(_ => _.Name)

Do you happen to know how to solve this? Thank you!