Sorting by JsonElement property

[AdamLawrenceDesign]

Hi, I’m trying to implement a custom sort on a JsonElement property in EF Core through GraphQL, using EF.Functions.JsonExtract. I’ve been able to create the custom sort input type but am facing issues with the sort expression not executing as expected. Here’s an overview of what I’ve done:

Filter Input
order: { data: { key: "Name", sort: ASC } }

Custom Input type

public class JsonSortInputType : InputObjectType<JsonSort>
{
    protected override void Configure(IInputObjectTypeDescriptor<JsonSort> descriptor)
    {
        descriptor.BindFieldsExplicitly();

        descriptor.Field(x => x.Key);
        descriptor.Field(x => x.Sort);
    }
}

Registering Input type and handler

 descriptor.Field(x => x.Data)
            .Type<ListType<JsonSortInputType>>()
            .Extend()
            .OnBeforeCreate(x => x.Handler = new JsonSortHandler<MyData>("Data"));

Handler

public sealed class JsonSortHandler<T>(string propertyName): SortFieldHandler<QueryableSortContext, QueryableSortOperation>
{
    public override bool TryHandleEnter(
        QueryableSortContext context,
        ISortField field,
        ObjectFieldNode node,
        [NotNullWhen(true)] out ISyntaxVisitorAction? action)
    {
        //  static used expression will be dynamic in proper implementation 
        Expression<Func<T, object>> expression = e => EF.Functions.JsonExtract<string>(EF.Property<string>(e, propertyName), $"$.Name");
        
        var lastFieldSelector = (QueryableFieldSelector)context.GetInstance();
        var nextSelector = Expression.Invoke(expression, lastFieldSelector.Selector);
        context.PushInstance(lastFieldSelector.WithSelector(nextSelector));
        
        action = SyntaxVisitor.Continue;
        return true;
    }

The handler is registered, but the expression doesn’t seem to have an effect. The query isn’t sorting as expected. I’ve confirmed that the JsonExtract method works when used directly, but I’m unsure why it doesn’t translate to the correct query when used in the custom handler.

Has anyone encountered this issue before? Is there something I’m missing in how I’m setting up the expression for dynamic sorting by a JSON property?

Any feedback would be greatly appreciated!

[AdamLawrenceDesign]

Figured out an implementation that worked for me, I needed create some operation handlers and enqueue them on the context.

Concrete that can later be enqueued

public sealed class AscendingSortOperation(Expression selector, ParameterExpression parameterExpression)
    : QueryableSortOperation(selector, parameterExpression)
{
    public override Expression CompileOrderBy(Expression expression) =>
        Expression.Call(
            expression.GetEnumerableKind(),
            nameof(Queryable.OrderBy),
            [ParameterExpression.Type, Selector.Type,],
            expression,
            Expression.Lambda(Selector, ParameterExpression));

    public override Expression CompileThenBy(Expression expression) =>
        Expression.Call(
            expression.GetEnumerableKind(),
            nameof(Queryable.ThenBy),
            [ParameterExpression.Type, Selector.Type,],
            expression,
            Expression.Lambda(Selector, ParameterExpression));
}

Custom Handler that enqueues my custom expressions

    public override bool TryHandleEnter(
        QueryableSortContext context,
        ISortField field,
        ObjectFieldNode node,
        [NotNullWhen(true)] out ISyntaxVisitorAction? action)
    {
        if (!(node.Value is ObjectValueNode objectValueNode &&
              JsonSortConverter.Convert(objectValueNode).FirstOrDefault() is { } sort))
        {
            action = SyntaxVisitor.SkipAndLeave;
            return true;
        }
        
        var parameter = Expression.Parameter(typeof(T), "x");
        var selector = Expression.Call(
            null, 
            typeof(PlatformDbContext).GetMethod("JsonExtract")!, 
            Expression.Property(parameter, propertyName), 
            Expression.Constant($"$.{sort.Path}")
        );
        QueryableSortOperation sortOperation = sort.Order == Order.Asc ? 
            new AscendingSortOperation(selector, parameter) :
            new DescendingSortOperation(selector, parameter);
        
        context.Operations.Enqueue(sortOperation);
        action = SyntaxVisitor.Continue;
        return true;
    }