feat: can support primitive lists

pdevito3 · pdevito3 · commit 828c9db38764 · 2023-07-23T22:33:11.000-04:00
diff --git a/QueryKit.UnitTests/FilterParserTests.cs b/QueryKit.UnitTests/FilterParserTests.cs
@@ -763,5 +763,41 @@ public void collection_has_operator_greater_than_equal()
         filterExpression.ToString().Should()
             .Be(""""x => (x.Ingredients.Count() >= 0)"""");
     }
+    
+    [Fact]
+    public void primitive_collection_has()
+    {
+        var input = """Tags ^$ "winner" """;
+        var filterExpression = FilterParser.ParseFilter<Recipe>(input);
+        filterExpression.ToString().Should()
+            .Be(""""x => x.Tags.Any(z => (z == "winner"))"""");
+    }
+    
+    [Fact]
+    public void primitive_collection_does_not_have()
+    {
+        var input = """Tags !^$ "winner" """;
+        var filterExpression = FilterParser.ParseFilter<Recipe>(input);
+        filterExpression.ToString().Should()
+            .Be(""""x => x.Tags.Any(z => (z != "winner"))"""");
+    }
+    
+    [Fact]
+    public void primitive_collection_has_case_insensitive()
+    {
+        var input = """Tags ^$* "winner" """;
+        var filterExpression = FilterParser.ParseFilter<Recipe>(input);
+        filterExpression.ToString().Should()
+            .Be(""""x => x.Tags.Any(z => (z.ToLower() == "winner".ToLower()))"""");
+    }
+    
+    [Fact]
+    public void primitive_collection_does_not_have_case_insensitive()
+    {
+        var input = """Tags !^$* "winner" """;
+        var filterExpression = FilterParser.ParseFilter<Recipe>(input);
+        filterExpression.ToString().Should()
+            .Be(""""x => x.Tags.Any(z => (z.ToLower() != "winner".ToLower()))"""");
+    }
 }
     
diff --git a/QueryKit.WebApiTestProject/Database/RecipeConfiguration.cs b/QueryKit.WebApiTestProject/Database/RecipeConfiguration.cs
@@ -11,11 +11,13 @@ public sealed class RecipeConfiguration : IEntityTypeConfiguration<Recipe>
     /// </summary>
     public void Configure(EntityTypeBuilder<Recipe> builder)
     {
+        builder.Property(x => x.Tags).HasColumnType("text[]");
+
         // example for a simple 1:1 value object
         // builder.Property(x => x.Percent)
         //     .HasConversion(x => x.Value, x => new Percent(x))
         //     .HasColumnName("percent");
-        
+
         // example for a more complex value object
         // builder.OwnsOne(x => x.PhysicalAddress, opts =>
         // {
diff --git a/QueryKit.WebApiTestProject/Entities/Recipes/Recipe.cs b/QueryKit.WebApiTestProject/Entities/Recipes/Recipe.cs
@@ -30,6 +30,8 @@ private set
     public DateOnly? DateOfOrigin { get; private set; }
 
     public bool HaveMadeItMyself { get; private set; }
+    
+    public List<string> Tags { get; set; } = new();
 
     [JsonIgnore, IgnoreDataMember]
     public Author Author { get; private set; }
@@ -78,6 +80,12 @@ public Recipe SetIngredients(List<Ingredient> ingredients)
         _ingredients = ingredients;
         return this;
     }
+    
+    public Recipe SetTags(List<string> tags)
+    {
+        Tags = tags;
+        return this;
+    }
 
     protected Recipe() { } // For EF + Mocking
 }
diff --git a/QueryKit.WebApiTestProject/Migrations/20230724020352_BaseTestingMigration.Designer.cs b/QueryKit.WebApiTestProject/Migrations/20230724020352_BaseTestingMigration.Designer.cs
diff --git a/QueryKit.WebApiTestProject/Migrations/20230724020352_BaseTestingMigration.cs b/QueryKit.WebApiTestProject/Migrations/20230724020352_BaseTestingMigration.cs
@@ -1,4 +1,5 @@
 ﻿using System;
+using System.Collections.Generic;
 using Microsoft.EntityFrameworkCore.Migrations;
 
 #nullable disable
@@ -51,7 +52,8 @@ protected override void Up(MigrationBuilder migrationBuilder)
                     directions = table.Column<string>(type: "text", nullable: false),
                     rating = table.Column<int>(type: "integer", nullable: true),
                     date_of_origin = table.Column<DateOnly>(type: "date", nullable: true),
-                    have_made_it_myself = table.Column<bool>(type: "boolean", nullable: false)
+                    have_made_it_myself = table.Column<bool>(type: "boolean", nullable: false),
+                    tags = table.Column<List<string>>(type: "text[]", nullable: false)
                 },
                 constraints: table =>
                 {
diff --git a/QueryKit.WebApiTestProject/Migrations/TestingDbContextModelSnapshot.cs b/QueryKit.WebApiTestProject/Migrations/TestingDbContextModelSnapshot.cs
@@ -1,5 +1,6 @@
 ﻿// <auto-generated />
 using System;
+using System.Collections.Generic;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
@@ -141,6 +142,11 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("integer")
                         .HasColumnName("rating");
 
+                    b.Property<List<string>>("Tags")
+                        .IsRequired()
+                        .HasColumnType("text[]")
+                        .HasColumnName("tags");
+
                     b.Property<string>("Title")
                         .IsRequired()
                         .HasColumnType("text")
diff --git a/QueryKit/Configuration/QueryKitConfiguration.cs b/QueryKit/Configuration/QueryKitConfiguration.cs
@@ -29,6 +29,8 @@ public interface IQueryKitConfiguration
     public string HasCountLessThanOperator { get; set; }
     public string HasCountGreaterThanOrEqualOperator { get; set; }
     public string HasCountLessThanOrEqualOperator { get; set; }
+    public string HasOperator { get; set; }
+    public string DoesNotHaveOperator { get; set; }
 }
 
 public class QueryKitConfiguration : IQueryKitConfiguration
@@ -55,6 +57,8 @@ public class QueryKitConfiguration : IQueryKitConfiguration
     public string HasCountLessThanOperator { get; set; }
     public string HasCountGreaterThanOrEqualOperator { get; set; }
     public string HasCountLessThanOrEqualOperator { get; set; }
+    public string HasOperator { get; set; }
+    public string DoesNotHaveOperator { get; set; }
     public string CaseInsensitiveAppendix { get; set; }
     public string AndOperator { get; set; }
     public string OrOperator { get; set; }
@@ -94,5 +98,7 @@ public QueryKitConfiguration(Action<QueryKitSettings> configureSettings)
         HasCountLessThanOperator = settings.HasCountLessThanOperator;
         HasCountGreaterThanOrEqualOperator = settings.HasCountGreaterThanOrEqualOperator;
         HasCountLessThanOrEqualOperator = settings.HasCountLessThanOrEqualOperator;
+        HasOperator = settings.HasOperator;
+        DoesNotHaveOperator = settings.DoesNotHaveOperator;
     }
 }
diff --git a/QueryKit/Configuration/QueryKitSettings.cs b/QueryKit/Configuration/QueryKitSettings.cs
@@ -27,6 +27,8 @@ public class QueryKitSettings
     public string HasCountLessThanOperator { get; set; } = ComparisonOperator.HasCountLessThanOperator().Operator();
     public string HasCountGreaterThanOrEqualOperator { get; set; } = ComparisonOperator.HasCountGreaterThanOrEqualOperator().Operator();
     public string HasCountLessThanOrEqualOperator { get; set; } = ComparisonOperator.HasCountLessThanOrEqualOperator().Operator();
+    public string HasOperator { get; set; } = ComparisonOperator.HasOperator().Operator();
+    public string DoesNotHaveOperator { get; set; } = ComparisonOperator.DoesNotHaveOperator().Operator();
     public string AndOperator { get; set; } = LogicalOperator.AndOperator.Operator();
     public string OrOperator { get; set; } = LogicalOperator.OrOperator.Operator();
     public string CaseInsensitiveAppendix { get; set; } = ComparisonOperator.CaseSensitiveAppendix.ToString();
diff --git a/QueryKit/FilterParser.cs b/QueryKit/FilterParser.cs
@@ -67,6 +67,8 @@ from rest in Parse.LetterOrDigit.XOr(Parse.Char('_')).Many()
                     .Or(Parse.String(ComparisonOperator.HasCountLessThanOrEqualOperator().Operator()).Text())
                     .Or(Parse.String(ComparisonOperator.HasCountGreaterThanOperator().Operator()).Text())
                     .Or(Parse.String(ComparisonOperator.HasCountLessThanOperator().Operator()).Text())
+                    .Or(Parse.String(ComparisonOperator.HasOperator().Operator()).Text())
+                    .Or(Parse.String(ComparisonOperator.DoesNotHaveOperator().Operator()).Text())
                     .SelectMany(op => Parse.Char(ComparisonOperator.CaseSensitiveAppendix).Optional(), (op, caseInsensitive) => new { op, caseInsensitive, hasHash })
                     .Select(x => ComparisonOperator.GetByOperatorString(x.op, x.caseInsensitive.IsDefined, x.hasHash)));
 
diff --git a/QueryKit/Operators/ComparisonOperator.cs b/QueryKit/Operators/ComparisonOperator.cs
@@ -30,6 +30,8 @@ public abstract class ComparisonOperator : SmartEnum<ComparisonOperator>
     public static ComparisonOperator CaseSensitiveHasCountLessThanOperator = new HasCountLessThanType();
     public static ComparisonOperator CaseSensitiveHasCountGreaterThanOrEqualOperator = new HasCountGreaterThanOrEqualType();
     public static ComparisonOperator CaseSensitiveHasCountLessThanOrEqualOperator = new HasCountLessThanOrEqualType();
+    public static ComparisonOperator CaseSensitiveHasOperator = new HasType();
+    public static ComparisonOperator CaseSensitiveDoesNotHaveOperator = new DoesNotHaveType();
     
     public static ComparisonOperator EqualsOperator(bool caseInsensitive = false, bool usesAll = false) => new EqualsType(caseInsensitive);
     public static ComparisonOperator NotEqualsOperator(bool caseInsensitive = false, bool usesAll = false) => new NotEqualsType(caseInsensitive);
@@ -52,6 +54,8 @@ public abstract class ComparisonOperator : SmartEnum<ComparisonOperator>
     public static ComparisonOperator HasCountLessThanOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountLessThanType(caseInsensitive);
     public static ComparisonOperator HasCountGreaterThanOrEqualOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountGreaterThanOrEqualType(caseInsensitive);
     public static ComparisonOperator HasCountLessThanOrEqualOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountLessThanOrEqualType(caseInsensitive);
+    public static ComparisonOperator HasOperator(bool caseInsensitive = false, bool usesAll = false) => new HasType(caseInsensitive);
+    public static ComparisonOperator DoesNotHaveOperator(bool caseInsensitive = false, bool usesAll = false) => new DoesNotHaveType(caseInsensitive);
 
     
     public static ComparisonOperator GetByOperatorString(string op, bool caseInsensitive = false, bool usesAll = false)
@@ -148,6 +152,14 @@ public static ComparisonOperator GetByOperatorString(string op, bool caseInsensi
         {
             newOperator = new HasCountLessThanOrEqualType(caseInsensitive, usesAll);
         }
+        if (comparisonOperator is HasType)
+        {
+            newOperator = new HasType(caseInsensitive, usesAll);
+        }
+        if (comparisonOperator is DoesNotHaveType)
+        {
+            newOperator = new DoesNotHaveType(caseInsensitive, usesAll);
+        }
         
         return newOperator == null 
             ? throw new Exception($"Operator {op} is not supported")
@@ -628,6 +640,49 @@ public override Expression GetExpression<T>(Expression left, Expression right, T
         }
     }
 
+    private class HasType : ComparisonOperator
+    {
+        public HasType(bool caseInsensitive = false, bool usesAll = false) : base("^$", 21, caseInsensitive, usesAll)
+        {
+        }
+
+        public override string Operator() => CaseInsensitive ? $"{Name}{CaseSensitiveAppendix}" : Name;
+        public override Expression GetExpression<T>(Expression left, Expression right, Type? dbContextType)
+        {
+            if (left.Type.IsGenericType && 
+                (left.Type.GetGenericTypeDefinition() == typeof(List<>) || 
+                 left.Type.GetGenericTypeDefinition() == typeof(ICollection<>) ||
+                 left.Type.GetGenericTypeDefinition() == typeof(IList<>) ||
+                 typeof(IEnumerable<>).IsAssignableFrom(left.Type.GetGenericTypeDefinition())))
+            {
+                return GetCollectionExpression(left, right, Expression.Equal, UsesAll);
+            }
+
+            throw new Exception("DoesNotHaveType is only supported for collections");
+        }
+    }
+
+    private class DoesNotHaveType : ComparisonOperator
+    {
+        public DoesNotHaveType(bool caseInsensitive = false, bool usesAll = false) : base("!^$", 22, caseInsensitive, usesAll)
+        {
+        }
+
+        public override string Operator() => CaseInsensitive ? $"{Name}{CaseSensitiveAppendix}" : Name;
+        public override Expression GetExpression<T>(Expression left, Expression right, Type? dbContextType)
+        {
+            if (left.Type.IsGenericType && 
+                (left.Type.GetGenericTypeDefinition() == typeof(List<>) || 
+                 left.Type.GetGenericTypeDefinition() == typeof(ICollection<>) ||
+                 left.Type.GetGenericTypeDefinition() == typeof(IList<>) ||
+                 typeof(IEnumerable<>).IsAssignableFrom(left.Type.GetGenericTypeDefinition())))
+            {
+                return GetCollectionExpression(left, right, Expression.NotEqual, UsesAll);
+            }
+            
+            throw new Exception("DoesNotHaveType is only supported for collections");
+        }
+    }
 
     internal class ComparisonAliasMatch
     {
@@ -734,6 +789,16 @@ internal static List<ComparisonAliasMatch> GetAliasMatches(IQueryKitConfiguratio
             matches.Add(new ComparisonAliasMatch { Alias = aliases.HasCountLessThanOrEqualOperator, Operator = HasCountLessThanOrEqualOperator().Operator() });
             matches.Add(new ComparisonAliasMatch { Alias = $"{aliases.HasCountLessThanOrEqualOperator}{caseInsensitiveAppendix}", Operator = $"{HasCountLessThanOrEqualOperator(true).Operator()}" });
         }
+        if(aliases.HasOperator != HasOperator().Operator())
+        {
+            matches.Add(new ComparisonAliasMatch { Alias = aliases.HasOperator, Operator = HasOperator().Operator() });
+            matches.Add(new ComparisonAliasMatch { Alias = $"{aliases.HasOperator}{caseInsensitiveAppendix}", Operator = $"{HasOperator(true).Operator()}" });
+        }
+        if(aliases.DoesNotHaveOperator != DoesNotHaveOperator().Operator())
+        {
+            matches.Add(new ComparisonAliasMatch { Alias = aliases.DoesNotHaveOperator, Operator = DoesNotHaveOperator().Operator() });
+            matches.Add(new ComparisonAliasMatch { Alias = $"{aliases.DoesNotHaveOperator}{caseInsensitiveAppendix}", Operator = $"{DoesNotHaveOperator(true).Operator()}" });
+        }
 
         return matches;
     }
@@ -792,7 +857,7 @@ private Expression GetCollectionExpression(Expression left, Expression right, st
             : Expression.Call(anyMethod, left, anyLambda);
     }
 
-    public Expression GetCountExpression(Expression left, Expression right, string methodName)
+    private Expression GetCountExpression(Expression left, Expression right, string methodName)
     {
         var leftAsEnumerableType = left.Type.GetInterface(nameof(IEnumerable));
         if (leftAsEnumerableType == null)
diff --git a/README.md b/README.md
@@ -113,7 +113,8 @@ There's a wide variety of comparison operators that use the same base syntax as
 | Does Not Contain      | !@=      | !@=*                      | N/A            |
 | Sounds Like           | ~~       | N/A                       | N/A            |
 | Does Not Sound Like   | !~       | N/A                       | N/A            |
-
+| Has                   | ^$       | ^$*                       | N/A            |
+| Does Not Have         | !^$      | !^$*                      | N/A            |
 
 > `Sounds Like` and `Does Not Sound Like` requires a soundex configuration on your DbContext. For more info see [the docs below](#soundex)
 
@@ -171,6 +172,14 @@ var input = """"Ingredients.Stock %>= 1"""";
 
 > 🚧 At the moment, nested collections like `Ingredients.Suppliers.Rating > 4` is still under active development
 
+If you want to filter a primitve collection like `List<string>` you can use the `Has` or `DoesNotHave` operator (can be case insensitive with the appended `*`):
+
+```csharp
+var input = """Tags ^$ "winner" """;
+// or
+var input = """Tags !^$ "winner" """;
+```
+
 If you want to filter on the count of a collection, you can prefix some of the operators with a `#`. For example, if i wanted to get all recipes that have more than 0 ingredients:
 
 ```csharp
