Make the following 2 methods public

[cmenzi]

Hello

We are doing some integration testing against Sql Server and EF core, where we also measure index performance of some the columns.

In order to prepare the tests in a generic way for all our LIST endpoints which support filtering and ordering, we like to use the following methods:

• IEnumerable<ParsedOrdering> GridifyExtensions::ParseOrderings(this string orderings)
  • https://github.com/alirezanet/Gridify/blob/master/src/Gridify/GridifyExtensions.cs#L350
• IEnumerable<ISyntaxNode> GridifyExtensions::Descendants(this ISyntaxNode root)
  • https://github.com/alirezanet/Gridify/blob/master/src/Gridify/GridifyExtensions.cs#L200

Both, parameters and return values are already public. Would it therefore be issue, to also make this 2 methods public?

Or maybe introduce a IEnumerable<FieldExpressionSyntax> ParseFilterings(this string filter). Also here FieldExpressionSyntax is already public.

I can call it via reflection, but it does not feel rights ;-)

[alirezanet]

Hi @cmenzi,
Yeah, it might be possible (though we should move it to a separate class) but I'm not sure if is a good idea. I'm using Gridify in multiple projects with integration tests and never felt the need to expose the output of these methods, since they're not meant to be consumed directly by the user. I'm curious—why do you need it? if you need low level API access the SyntaxTree output should work and if you need high level expression usually it is better to use the GetOrderingExpressions and GetFilteringExpression ...

[cmenzi]

Yeah, using the GetOrderingExpressions and GetFilteringExpression was also my first approach, but it's difficult to get the MemberName and Type out of it, without writing a custom expression visitor.

My use case is that we created our own abstraction from Gridify where we can control per member if filtering and/or ordering is supported

    public class QueryMapper<T> : GridifyMapper<T>, IQueryMapper<T>
    {
        private static readonly FieldExpressionComparer FieldExpressionComparer = new();

#pragma warning disable S3011 // Reflection should not be used to increase accessibility of classes, methods, or fields
        private static readonly MethodInfo ParseOrderingsMethod = typeof(GridifyExtensions)
            .GetMethod("ParseOrderings", BindingFlags.NonPublic | BindingFlags.Static)!;
        private static readonly MethodInfo DescendantsMethod = typeof(GridifyExtensions)
            .GetMethod("Descendants", BindingFlags.NonPublic | BindingFlags.Static)!;
#pragma warning restore S3011

        private readonly Dictionary<string, QueryMember> _queryMembers = new();

        public IGridifyMapper<T> AddMap(
            string from,
            Expression<Func<T, object?>> to, Func<string, object>? convertor = null!,
            bool overrideIfExists = true,
            bool filtering = true,
            bool ordering = true)
        {
            var mapper =  base.AddMap(from, to, convertor, overrideIfExists);
            _queryMembers[from] = new QueryMember(from, filtering, ordering);
            return mapper;
        }

        public IReadOnlyList<QueryMember> GetSupportedMembers()
        {
            return GetCurrentMaps()
                .Select(x => x.From)
                .Select(x =>
                {
                    if (_queryMembers.TryGetValue(x, out var queryMember))
                    {
                        return queryMember;
                    }

                    return new QueryMember(x, true, true);
                }).ToList();
        }

        public bool IsFilteringSupported(string filter)
        {
            var members = GetFilteringMembers(filter);
            return members
                .All(member => GetSupportedMembers().Where(x => x.Filtering).Any(y => y.From == member));
        }

        public bool IsOrderingSupported(string orderBy)
        {
            var members = GetOrderingMembers(orderBy);
            return members
                .All(member => GetSupportedMembers().Where(x => x.Ordering).Any(y => y.From == member));
        }

        private IEnumerable<string> GetFilteringMembers(string filter)
        {
            if (string.IsNullOrWhiteSpace(filter))
            {
                return []; 
            }

            return GetSyntaxNodes(filter)
               .OfType<FieldExpressionSyntax>()
               .Distinct(FieldExpressionComparer)
               .Select(x => x.FieldToken.Text);
        }

        private IEnumerable<string> GetOrderingMembers(string orderBy)
        {
            if (string.IsNullOrWhiteSpace(orderBy))
            {
                return [];
            }

            return GetParsedOrderings(orderBy)
                .Select(x => x.MemberName);
        }

        private IEnumerable<ParsedOrdering> GetParsedOrderings(string orderBy)
        {
            // REF: https://github.com/alirezanet/Gridify/blob/master/src/Gridify/GridifyExtensions.cs#L350
            // INFO: https://github.com/alirezanet/Gridify/discussions/259
            var result = (IEnumerable<ParsedOrdering>?)ParseOrderingsMethod.Invoke(null, [orderBy]) ?? [];
            return result;
        }

        private IEnumerable<ISyntaxNode> GetSyntaxNodes(string filter)
        {
            var parser = new Parser(filter, GridifyGlobalConfiguration.CustomOperators.Operators);
            var syntaxTree = parser.Parse();

            // REF: https://github.com/alirezanet/Gridify/blob/master/src/Gridify/GridifyExtensions.cs#L200
            // INFO: https://github.com/alirezanet/Gridify/discussions/259
            var result = (IEnumerable<ISyntaxNode>?) DescendantsMethod.Invoke(null, [syntaxTree.Root]) ?? [];
            return result;
        }
    }

For example we don't like to allow to filter by Id - there is usually GetById endpoint - but when listing, you should still be able to order by Id.

We can then also use our own IsFilteringSupported and IsOrderingSupported to valid the a query request and give a good error message.

We are also using it to generate OpenAPI docs, when we can the document each member, if filtering or ordering is supported.

The usage of it looks like this:

 public static partial class ListUsersMapper
 {
       public static IQueryMapper<User> QueryMapper { get; } = (IQueryMapper<User>)new QueryMapper<User>()
            .AddMap("id", x => x.Id, filtering: false)
            .AddMap("mail", x => Convert.ToString(x.EmailAddress), x => EmailAddress.Create(x).Value)
            .AddMap("displayName", x => Convert.ToString(x.DisplayName), x => DisplayName.Create(x).Value)
            .AddMap("givenName", x => x.GivenName)
            .AddMap("surname", x => x.Surname)
            ;
     
     // ...
}

[alirezanet]

Yeah, it makes sense I'll try to move these two methods to the Syntax namespace in the next version so you can use it.
or Feel free to send a PR if you want to speed up the process. as a reminder, I created this issue #260