feat: can use QueryKit on Enumerables

Author: pdevito3

QueryKit.UnitTests/EnumerableFilteringTests.cs

@@ -0,0 +1,26 @@
+namespace QueryKit.UnitTests;
+
+using FluentAssertions;
+using QueryKit.WebApiTestProject.Entities.Recipes;
+using SharedTestingHelper.Fakes.Recipes;
+
+public class EnumerableFilteringTests()
+{
+    [Fact]
+    public async Task can_filter_enumerable()
+    {
+        // Arrange
+        var recipeOne = new FakeRecipeBuilder().Build();
+        var recipeTwo = new FakeRecipeBuilder().Build();
+        var listOfRecipes = new List<Recipe> { recipeOne, recipeTwo };
+        
+        var input = $"""{nameof(Recipe.Title)} == "{recipeOne.Title}" """;
+        
+        // Act
+        var filteredRecipes = listOfRecipes.ApplyQueryKitFilter(input).ToList();
+
+        // Assert
+        filteredRecipes.Count.Should().Be(1);
+        filteredRecipes[0].Id.Should().Be(recipeOne.Id);
+    }
+}

QueryKit.UnitTests/EnumerableSortingTests.cs

@@ -0,0 +1,48 @@
+namespace QueryKit.UnitTests;
+
+using FluentAssertions;
+using QueryKit.WebApiTestProject.Entities;
+using SharedTestingHelper.Fakes;
+
+public class EnumerableSortingTests
+{
+    [Fact]
+    public async Task can_sort_items_with_mixed_order_directions()
+    {
+        // Arrange
+        var personOne = new FakeTestingPersonBuilder()
+            .WithTitle("alpha")
+            .WithAge(10)
+            .WithBirthMonth(BirthMonthEnum.January)
+            .Build();
+        var personTwo = new FakeTestingPersonBuilder()
+            .WithTitle("beta")
+            .WithAge(100)
+            .WithBirthMonth(BirthMonthEnum.February)
+            .Build();
+        var personThree = new FakeTestingPersonBuilder()
+            .WithTitle("beta")
+            .WithAge(50)
+            .WithBirthMonth(BirthMonthEnum.March)
+            .Build();
+        var personFour = new FakeTestingPersonBuilder()
+            .WithTitle("beta")
+            .WithAge(20)
+            .WithBirthMonth(BirthMonthEnum.April)
+            .Build();
+        List<TestingPerson> peopleList = [personOne, personTwo, personThree, personFour];
+
+        var input = $"Title desc, Age asc, BirthMonth desc";
+
+        // Act
+        var appliedQueryable = peopleList.ApplyQueryKitSort(input);
+        var people = appliedQueryable.ToList();
+
+        // Assert
+        people.Count.Should().Be(4);
+        people[0].Id.Should().Be(personFour.Id);
+        people[1].Id.Should().Be(personThree.Id);
+        people[2].Id.Should().Be(personTwo.Id);
+        people[3].Id.Should().Be(personOne.Id);
+    }
+}

QueryKit/QueryableExtensions.cs QueryKit/QueryKitExtensions.csQueryKit/QueryableExtensions.cs renamed to QueryKit/QueryKitExtensions.cs

@@ -2,7 +2,7 @@ namespace QueryKit;
 
 using Configuration;
 
-public static class QueryableExtensions
+public static class QueryKitExtensions
 {
     public static IQueryable<TEntity> ApplyQueryKit<TEntity>(this IQueryable<TEntity> source, QueryKitData queryKitData)
         where TEntity : class
@@ -61,4 +61,65 @@ public static IOrderedQueryable<T> ApplyQueryKitSort<T>(this IQueryable<T> query
 
         return queryable.OrderBy(x => x);
     }
+    
+    public static IEnumerable<TEntity> ApplyQueryKit<TEntity>(
+        this IEnumerable<TEntity> source,
+        QueryKitData queryKitData)
+        where TEntity : class
+    {
+        var applied = source;
+        if (!string.IsNullOrWhiteSpace(queryKitData.Filters))
+        {
+            applied = applied.ApplyQueryKitFilter(queryKitData.Filters, queryKitData.Configuration);
+        }
+
+        if (!string.IsNullOrWhiteSpace(queryKitData.SortOrder))
+        {
+            applied = applied.ApplyQueryKitSort(queryKitData.SortOrder, queryKitData.Configuration);
+        }
+
+        return applied;
+    }
+
+    public static IEnumerable<TEntity> ApplyQueryKitFilter<TEntity>(
+        this IEnumerable<TEntity> source,
+        string filter,
+        IQueryKitConfiguration? config = null)
+        where TEntity : class
+    {
+        if (string.IsNullOrWhiteSpace(filter))
+            return source;
+
+        var expression = FilterParser.ParseFilter<TEntity>(filter, config);
+        var predicate  = expression.Compile();
+        return source.Where(predicate);
+    }
+
+    public static IOrderedEnumerable<T> ApplyQueryKitSort<T>(
+        this IEnumerable<T> source,
+        string sortExpression,
+        IQueryKitConfiguration? config = null)
+    {
+        var sortInfos = SortParser.ParseSort<T>(sortExpression, config);
+
+        if (sortInfos.Count == 0 || sortInfos[0].Expression is null)
+            return source.OrderBy(x => x);
+
+        var first = sortInfos[0];
+        var ordered = first.IsAscending
+            ? source.OrderBy(first.Expression!.Compile())
+            : source.OrderByDescending(first.Expression!.Compile());
+        
+        for (var i = 1; i < sortInfos.Count; i++)
+        {
+            var info = sortInfos[i];
+            if (info.Expression is null) continue;
+
+            ordered = info.IsAscending
+                ? ordered.ThenBy(info.Expression.Compile())
+                : ordered.ThenByDescending(info.Expression.Compile());
+        }
+
+        return ordered;
+    }
 }

README.md

@@ -694,6 +694,19 @@ var people = _dbContext.People
   	.ToList();
 ```
 
+## Using QueryKit on Enumerables
+Since QueryKit is really just a parser for expressions, you can use it on any `IEnumerable<T>` as well. Just be sure to use the `ApplyQueryKitFilter` and `ApplyQueryKitSort` methods off of the enumerable.
+
+For example
+```csharp
+var recipeOne = new FakeRecipeBuilder().Build();
+var recipeTwo = new FakeRecipeBuilder().Build();
+var listOfRecipes = new List<Recipe> { recipeOne, recipeTwo };
+
+var input = $"""{nameof(Recipe.Title)} == "{recipeOne.Title}" """;
+
+var filteredRecipes = listOfRecipes.ApplyQueryKitFilter(input).ToList();
+````
 
 
 ## Error Handling