Case insensitive custom filter operation

[martinRocks]

Product

Hot Chocolate

Version

16.0.2

Link to minimal reproduction

in dev right now

Steps to reproduce

I love this project, however, using HotChocolate.AspNetCore version 16.0.2, the documentation located here (https://chillicream.com/docs/hotchocolate/v16/fetching-data/integrations/extending-filtering/) does not compile. I have changed the code to be like below, but it just doesn't work. Help.

What is expected?

The sample code on the web page should work.

What is actually happening?

Right now, the sample code does not compile.

Relevant log output

Additional context

No response

This does NOT work, but it complies.

    protected override void Configure(IFilterConventionDescriptor descriptor)
    {
        descriptor.AddDefaults();
        descriptor.Provider(
            new QueryableFilterProvider(
                x => x
                    .AddDefaultFieldHandlers()
                    .AddFieldHandler(y => new QueryableStringInvariantEqualsHandler(y.InputParser))));
    }
}`

[tobias-tengler]

@martinRocks Could you define what doesn't work mean? Does it fail at startup? Does the filtering no longer take effect? etc.

[martinRocks]

@martinRocks Could you define what doesn't work mean? Does it fail at startup? Does the filtering no longer take effect? etc.

With my fix in play, when I make a query with a mixed case, the sql that is created does NOT have any case modifiers. Also, the returned data is empty. Without my fix in play, the app doesn't compile. Does that help?

[tobias-tengler]

I just tried it with v15 and v16 and both don't work with this exact setup. Did it work for you on v15?
The custom handler needs to be registered before the AddDefaultFieldHandlers(). Otherwise the default handler will always match and the custom handler is never called.
I'm going to update the documentation to reflect this :)

[martinRocks]

I didn't try it in version 15.

[tobias-tengler]

Ah okay, so you are starting with v16. In that case, regardless of this working or not, I would recommend that you do not use these filtering APIs. They lead to bad schema design. In most cases you will end up with a much better design if you just use regular arguments.
We're also going to emphasize that these broad filter APIs are not a good idea with the new docs we're working on.

[martinRocks]

I'm not super sure, but I think by "regular arguments" you mean just requiring parameters in the methods. Doesn't that remove the dynamic-ness that is the most awesome part of hot chocolate. In the example, line 31 is a caseless filter on Name. What if I don't what to limit based on field. Also, using the example in the docs and your help, I have equals being case insensitive. Writing one for the contains operator is a bit harder it seems. Is there an example for each operator somewhere?

[tobias-tengler]

We unfortunately don't have examples for every operator.

In my experience, when building a product, your consumer has a specific need and you build an API for that.
Very rarely do the auto-generated filters match well with that. You expose a broad API surface and its harder to optimize / evolve the API going forward.
But if you like it then go for it. As maintainers we just want to see people succeed with our product, so I feel obligated to point out the flaws.

[martinRocks]

THANK YOU for all the help. Again, I love your product and will be using it a lot. I just made the classes for strings to make them caseless. For anyone else, that needs it.

public sealed class ContainsHandler : QueryableStringOperationHandler
{
    public ContainsHandler(InputParser inputParser) : base(inputParser)
    {
    }

    private static readonly MethodInfo ToLower = typeof(string)
        .GetMethods()
        .Single(x => x.Name == nameof(string.ToLower) && x.GetParameters().Length == 0);

    private static readonly MethodInfo? Contains = typeof(string)
        .GetMethod(nameof(string.Contains), [typeof(string)]);

    protected override int Operation => DefaultFilterOperations.Contains;

    public override Expression HandleOperation(QueryableFilterContext context, IFilterOperationField field, IValueNode value, object? parsedValue)
    {
        var property = context.GetInstance();
        if (parsedValue is string str)
        {
            if (Contains != null)
            {
                return Expression.Call(
                    Expression.Call(property, ToLower),
                    Contains,
                    Expression.Constant(str.ToLower())
                );
            }
        }

        throw new InvalidOperationException();
    }
}

public sealed class EndsWithHandler : QueryableStringOperationHandler
{
    public EndsWithHandler(InputParser inputParser) : base(inputParser)
    {
    }

    private static readonly MethodInfo ToLower = typeof(string)
        .GetMethods()
        .Single(x => x.Name == nameof(string.ToLower) && x.GetParameters().Length == 0);

    private static readonly MethodInfo EndsWith =
        typeof(string).GetMethod(nameof(string.EndsWith), [typeof(string)])
        ?? throw new InvalidOperationException("String.EndsWith(string) method not found.");

    protected override int Operation => DefaultFilterOperations.EndsWith;

    public override Expression HandleOperation(QueryableFilterContext context, IFilterOperationField field, IValueNode value, object? parsedValue)
    {
        var property = context.GetInstance();

        if (parsedValue is string str)
        {
            return Expression.Call(
                Expression.Call(property, ToLower),
                EndsWith,
                Expression.Constant(str.ToLower())
            );
        }

        throw new InvalidOperationException("The provided filter value must be a valid string.");
    }
}

public sealed class EqualsHandler : QueryableStringOperationHandler
{
    public EqualsHandler(InputParser inputParser) : base(inputParser)
    {
    }

    private static readonly MethodInfo ToLower = typeof(string)
        .GetMethods()
        .Single(x => x.Name == nameof(string.ToLower) && x.GetParameters().Length == 0);

    protected override int Operation => DefaultFilterOperations.Equals;

    return parsedValue switch
{
    null => Expression.Equal(property, Expression.Constant(null)),
    string str => Expression.Equal(Expression.Call(property, ToLower), Expression.Constant(str.ToLower())),
    _ => throw new InvalidOperationException()
};
}

public sealed class InHandler : QueryableStringOperationHandler
{
    public InHandler(InputParser inputParser) : base(inputParser)
    {
    }

    private static readonly MethodInfo ToLower = typeof(string)
        .GetMethods()
        .Single(x => x.Name == nameof(string.ToLower) && x.GetParameters().Length == 0);

    private static readonly MethodInfo EnumerableContains = typeof(Enumerable)
        .GetMethods()
        .First(x => x.Name == nameof(Enumerable.Contains) && x.GetParameters().Length == 2)
        .MakeGenericMethod(typeof(string));

    protected override int Operation => DefaultFilterOperations.In;

    public override Expression HandleOperation(QueryableFilterContext context, IFilterOperationField field, IValueNode value, object? parsedValue)
    {
        var property = context.GetInstance();
        if (parsedValue is IEnumerable<string> values)
        {
            var lowerValues = values
                .Select(v => v.ToLower())
                .ToList();

            return Expression.Call(
                null,
                EnumerableContains,
                Expression.Constant(lowerValues),
                Expression.Call(property, ToLower)
            );
        }

        throw new InvalidOperationException();
    }
}

public sealed class NotContainsHandler : QueryableStringOperationHandler
{
    public NotContainsHandler(InputParser inputParser) : base(inputParser)
    {
    }

    private static readonly MethodInfo ToLower = typeof(string)
        .GetMethods()
        .Single(x => x.Name == nameof(string.ToLower) && x.GetParameters().Length == 0);

    private static readonly MethodInfo Contains =
        typeof(string).GetMethod(nameof(string.Contains), [typeof(string)])
        ?? throw new InvalidOperationException("String.Contains(string) method not found.");

    protected override int Operation => DefaultFilterOperations.NotContains;

    public override Expression HandleOperation(QueryableFilterContext context, IFilterOperationField field, IValueNode value, object? parsedValue)
    {
        var property = context.GetInstance();
        if (parsedValue is string str)
        {
            return Expression.Not(
                Expression.Call(
                    Expression.Call(property, ToLower),
                    Contains,
                    Expression.Constant(str.ToLower())
                )
            );
        }

        throw new InvalidOperationException();
    }
}

public sealed class NotEndsWithHandler : QueryableStringOperationHandler
{
    public NotEndsWithHandler(InputParser inputParser) : base(inputParser)
    {
    }

    private static readonly MethodInfo ToLower = typeof(string)
        .GetMethods()
        .Single(x => x.Name == nameof(string.ToLower) && x.GetParameters().Length == 0);

    private static readonly MethodInfo EndsWith =
        typeof(string).GetMethod(nameof(string.EndsWith), [typeof(string)])
        ?? throw new InvalidOperationException("String.EndsWith(string) method not found.");

    protected override int Operation => DefaultFilterOperations.NotEndsWith;

    public override Expression HandleOperation(QueryableFilterContext context, IFilterOperationField field, IValueNode value, object? parsedValue)
    {
        var property = context.GetInstance();

        if (parsedValue is string str)
        {
            return Expression.Not(
                Expression.Call(
                    Expression.Call(property, ToLower),
                    EndsWith,
                    Expression.Constant(str.ToLower())
                )
            );
        }

        throw new InvalidOperationException("The provided filter value must be a valid string.");
    }
}

public sealed class NotEqualsHandler : QueryableStringOperationHandler
{
    public NotEqualsHandler(InputParser inputParser) : base(inputParser)
    {
    }

    private static readonly MethodInfo ToLower = typeof(string)
        .GetMethods()
        .Single(x => x.Name == nameof(string.ToLower) && x.GetParameters().Length == 0);

    protected override int Operation => DefaultFilterOperations.NotEquals;

    public override Expression HandleOperation(QueryableFilterContext context, IFilterOperationField field, IValueNode value, object? parsedValue)
    {
        var property = context.GetInstance();
       return parsedValue switch
{
    null => Expression.NotEqual(property, Expression.Constant(null)),
    string str => Expression.NotEqual(Expression.Call(property, ToLower), Expression.Constant(str.ToLower())),
    _ => throw new InvalidOperationException()
};
    }
}

public sealed class NotInHandler : QueryableStringOperationHandler
{
    public NotInHandler(InputParser inputParser) : base(inputParser)
    {
    }

    private static readonly MethodInfo ToLower = typeof(string)
        .GetMethods()
        .Single(x => x.Name == nameof(string.ToLower) && x.GetParameters().Length == 0);

    private static readonly MethodInfo EnumerableContains = typeof(Enumerable)
        .GetMethods()
        .First(x => x.Name == nameof(Enumerable.Contains) && x.GetParameters().Length == 2)
        .MakeGenericMethod(typeof(string));

    protected override int Operation => DefaultFilterOperations.NotIn;

    public override Expression HandleOperation(QueryableFilterContext context, IFilterOperationField field, IValueNode value, object? parsedValue)
    {
        var property = context.GetInstance();

        if (parsedValue is IEnumerable<string> values)
        {
            var lowerValues = values
                .Select(v => v.ToLower())
                .ToList();

            return Expression.Not(
                Expression.Call(
                    null,
                    EnumerableContains,
                    Expression.Constant(lowerValues),
                    Expression.Call(property, ToLower)
                )
            );
        }

        throw new InvalidOperationException("The provided filter value must be a collection of strings.");
    }
}

public sealed class NotStartWithHandler : QueryableStringOperationHandler
{
    public NotStartWithHandler(InputParser inputParser) : base(inputParser)
    {
    }

    private static readonly MethodInfo ToLower = typeof(string)
        .GetMethods()
        .Single(x => x.Name == nameof(string.ToLower) && x.GetParameters().Length == 0);

    private static readonly MethodInfo StartsWith =
        typeof(string).GetMethod(nameof(string.StartsWith), [typeof(string)])
        ?? throw new InvalidOperationException("String.StartsWith(string) method not found.");

    protected override int Operation => DefaultFilterOperations.NotStartsWith;

    public override Expression HandleOperation(QueryableFilterContext context, IFilterOperationField field, IValueNode value, object? parsedValue)
    {
        var property = context.GetInstance();

        if (parsedValue is string str)
        {
            return Expression.Not(
                Expression.Call(
                    Expression.Call(property, ToLower),
                    StartsWith,
                    Expression.Constant(str.ToLower())
                )
            );
        }

        throw new InvalidOperationException("The provided filter value must be a valid string.");
    }
}

public sealed class StartsWithHandler : QueryableStringOperationHandler
{
    public StartsWithHandler(InputParser inputParser) : base(inputParser)
    {
    }

    private static readonly MethodInfo ToLower = typeof(string)
        .GetMethods()
        .Single(x => x.Name == nameof(string.ToLower) && x.GetParameters().Length == 0);

    private static readonly MethodInfo StartsWith =
        typeof(string).GetMethod(nameof(string.StartsWith), [typeof(string)])
        ?? throw new InvalidOperationException("String.StartsWith(string) method not found.");

    protected override int Operation => DefaultFilterOperations.StartsWith;

    public override Expression HandleOperation(QueryableFilterContext context, IFilterOperationField field, IValueNode value, object? parsedValue)
    {
        var property = context.GetInstance();

        if (parsedValue is string str)
        {
            return Expression.Call(
                Expression.Call(property, ToLower),
                StartsWith,
                Expression.Constant(str.ToLower())
            );
        }

        throw new InvalidOperationException("The provided filter value must be a valid string.");
    }
}

public sealed class CustomFilteringConvention : FilterConvention
{
    protected override void Configure(IFilterConventionDescriptor descriptor)
    {
        descriptor.AddDefaults();
        descriptor.Provider(
            new QueryableFilterProvider(x => x
                .AddFieldHandler(y => new EqualsHandler(y.InputParser))
                .AddFieldHandler(y => new NotEqualsHandler(y.InputParser))
                .AddFieldHandler(y => new ContainsHandler(y.InputParser))
                .AddFieldHandler(y => new NotContainsHandler(y.InputParser))
                .AddFieldHandler(y => new InHandler(y.InputParser))
                .AddFieldHandler(y => new NotInHandler(y.InputParser))
                .AddFieldHandler(y => new StartsWithHandler(y.InputParser))
                .AddFieldHandler(y => new NotStartWithHandler(y.InputParser))
                .AddFieldHandler(y => new EndsWithHandler(y.InputParser))
                .AddFieldHandler(y => new NotEndsWithHandler(y.InputParser))
                .AddDefaultFieldHandlers()));
    }
}