From 1cc2561dd9762b8e0e2c052fc0431aeb267a134c Mon Sep 17 00:00:00 2001
From: Paul DeVito <pdevito3@gmail.com>
Date: Tue, 29 Sep 2026 22:42:46 +0300
Subject: [PATCH 01/13] test(integration): turn off config reload in the test
 fixture

WebApplication.CreateBuilder watches appsettings files for changes. On macOS the FileSystemWatcher start can hang, and then the integration run hangs before the first test. The tests never change these files at run time, so the fixture turns off config reload.
---
 QueryKit.IntegrationTests/TestFixture.cs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/QueryKit.IntegrationTests/TestFixture.cs b/QueryKit.IntegrationTests/TestFixture.cs
index 1f97f3c..567fb72 100644
--- a/QueryKit.IntegrationTests/TestFixture.cs
+++ b/QueryKit.IntegrationTests/TestFixture.cs
@@ -28,7 +28,9 @@ public async Task InitializeAsync()
     {
         var builder = WebApplication.CreateBuilder(new WebApplicationOptions
         {
-            EnvironmentName = Consts.Testing.IntegrationTestingEnvName
+            EnvironmentName = Consts.Testing.IntegrationTestingEnvName,
+            // the file watcher for config reload can hang on start on macOS
+            Args = ["--hostBuilder:reloadConfigOnChange=false"]
         });
 
         _dbContainer = new PostgreSqlBuilder("postgres:15.1").Build();

From 05d1775bd710a2f8b4a6817582fb8d15e91c5b0e Mon Sep 17 00:00:00 2001
From: Paul DeVito <pdevito3@gmail.com>
Date: Tue, 29 Sep 2026 22:06:54 +0300
Subject: [PATCH 02/13] test(filter): query only its own recipes in the
 property-to-property test

can_filter_with_property_to_property_child_properties filtered all recipes with Author.Name == Title. Other tests write recipes with random titles and random author names to the same database. When one pair matched, the test got two rows and failed. The test now queries only the two recipes that it inserts.
---
 QueryKit.IntegrationTests/Tests/DatabaseFilteringTests.cs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/QueryKit.IntegrationTests/Tests/DatabaseFilteringTests.cs b/QueryKit.IntegrationTests/Tests/DatabaseFilteringTests.cs
index b126188..8846e2c 100644
--- a/QueryKit.IntegrationTests/Tests/DatabaseFilteringTests.cs
+++ b/QueryKit.IntegrationTests/Tests/DatabaseFilteringTests.cs
@@ -1973,7 +1973,8 @@ public async Task can_filter_with_property_to_property_child_properties()
         
         // Act
         var queryableRecipes = testingServiceScope.DbContext().Recipes
-            .Include(x => x.Author);
+            .Include(x => x.Author)
+            .Where(x => x.Id == fakeRecipe.Id || x.Id == differentRecipe.Id);
         var appliedQueryable = queryableRecipes.ApplyQueryKitFilter(input);
         var recipes = await appliedQueryable.ToListAsync();
 

From c99b17c9d8643ad3c66af66562523372b37561b5 Mon Sep 17 00:00:00 2001
From: Paul DeVito <pdevito3@gmail.com>
Date: Tue, 29 Sep 2026 21:43:56 +0300
Subject: [PATCH 03/13] test(verify-querykit): add fixtures and a culture flag
 to the harness

The parser and conversion checks need more seed data and settings. Each recipe now has a Sku, a Serving text with commas, and a ServeTime with fractional seconds. The custom-operation preset adds sku_is, and a new hidden-price preset maps a prevented Price property to cost. The --culture flag runs the driver in a different thread culture, and the output JSON records the culture and the time zone.
---
 .agents/skills/verify-querykit/SKILL.md       |  3 ++-
 .../skills/verify-querykit/features/README.md | 12 +++++------
 .../verify-querykit/harness/Driver/Configs.cs | 10 +++++++++-
 .../verify-querykit/harness/Driver/Model.cs   | 20 ++++++++++++++-----
 .../verify-querykit/harness/Driver/Program.cs | 17 ++++++++++++++--
 5 files changed, 47 insertions(+), 15 deletions(-)

diff --git a/.agents/skills/verify-querykit/SKILL.md b/.agents/skills/verify-querykit/SKILL.md
index ce7aaa4..6f60c6e 100644
--- a/.agents/skills/verify-querykit/SKILL.md
+++ b/.agents/skills/verify-querykit/SKILL.md
@@ -78,13 +78,14 @@ If the doctor fails and `qk rebuild` does not correct it, run `qk down` and then
 ## Drive
 
 ```bash
-.agents/skills/verify-querykit/qk run <label> [--filter '<f>'] [--sort '<s>'] [--config <preset>] [--target memory|postgres|both] [--aggregate]
+.agents/skills/verify-querykit/qk run <label> [--filter '<f>'] [--sort '<s>'] [--config <preset>] [--target memory|postgres|both] [--aggregate] [--culture <name>]
 ```
 
 - `<label>` names the evidence files. Use letters, digits, `.`, `_`, and `-` only. Use a label that tells the feature, for example `filtering-in-operator`.
 - `--filter` calls `ApplyQueryKitFilter`. `--sort` calls `ApplyQueryKitSort` after the filter.
 - `--aggregate` calls `ApplyQueryKit(new QueryKitData { Filters, SortOrder, Configuration })` instead.
 - `--config` selects a `QueryKitConfiguration` preset. The default is `none`. Run `qk configs` to list the presets. The presets are in `harness/Driver/Configs.cs`.
+- `--culture` sets the thread culture of the driver, for example `de-DE`. The default is the culture of the machine.
 - `--target` defaults to `both`. Use `both` for a proof. A difference between the two targets is a finding.
 
 Put the filter in single quotes in the shell, because QueryKit strings use double quotes:
diff --git a/.agents/skills/verify-querykit/features/README.md b/.agents/skills/verify-querykit/features/README.md
index 3cce104..d0a8fdb 100644
--- a/.agents/skills/verify-querykit/features/README.md
+++ b/.agents/skills/verify-querykit/features/README.md
@@ -14,12 +14,12 @@ In the commands below, `qk` means `.agents/skills/verify-querykit/qk`.
 
 The driver model is `Recipe`. Every recipe has one `Author` and zero or more `Ingredients`. The seed data is fixed in `harness/Driver/Model.cs`.
 
-| Title | Author.Name | Rating | Price | IsVegetarian | Visibility | CreatedAt (UTC) | DateOfOrigin | Directions | Tags | Ingredients (Name:Stock) |
-|---|---|---|---|---|---|---|---|---|---|---|
-| Pancakes | Julia Child | 5 | 4.50 | true | Public (1) | 2024-01-15 08:00 | 1900-01-01 | Whisk and fry | breakfast, sweet | flour:10, egg:0 |
-| Beef Stew | Gordon Ramsay | 3 | 12.00 | false | Public (1) | 2024-03-01 18:30 | null | Simmer for hours | dinner | beef:2, salt:50 |
-| Salt Bread | Julia Child | 4 | 3.25 | true | Private (2) | 2024-06-10 12:00 | 1950-05-20 | Knead and bake | bread, Winner | salt:5, flour:3 |
-| Plain Water | Anonymous | 1 | 0.00 | true | Private (2) | 2023-12-31 23:59 | null | null | (none) | (none) |
+| Title | Author.Name | Rating | Price | IsVegetarian | Visibility | CreatedAt (UTC) | DateOfOrigin | Sku | Serving | ServeTime | Directions | Tags | Ingredients (Name:Stock) |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+| Pancakes | Julia Child | 5 | 4.50 | true | Public (1) | 2024-01-15 08:00 | 1900-01-01 | 001 | Warm, with syrup | 08:30:00.5 | Whisk and fry | breakfast, sweet | flour:10, egg:0 |
+| Beef Stew | Gordon Ramsay | 3 | 12.00 | false | Public (1) | 2024-03-01 18:30 | null | 002 | Hot | 18:00:00 | Simmer for hours | dinner | beef:2, salt:50 |
+| Salt Bread | Julia Child | 4 | 3.25 | true | Private (2) | 2024-06-10 12:00 | 1950-05-20 | 003 | Sliced | 12:15:30.25 | Knead and bake | bread, Winner | salt:5, flour:3 |
+| Plain Water | Anonymous | 1 | 0.00 | true | Private (2) | 2023-12-31 23:59 | null | 004 | null | null | null | (none) | (none) |
 
 ## Driving conventions
 
diff --git a/.agents/skills/verify-querykit/harness/Driver/Configs.cs b/.agents/skills/verify-querykit/harness/Driver/Configs.cs
index 5f58b9d..f039f90 100644
--- a/.agents/skills/verify-querykit/harness/Driver/Configs.cs
+++ b/.agents/skills/verify-querykit/harness/Driver/Configs.cs
@@ -28,11 +28,13 @@ public static class Configs
                 s.DerivedProperty<Recipe>(x => x.Rating >= 4).HasQueryName("top_rated");
             })),
 
-        ["custom-operation"] = ("CustomOperation: total_stock_above = sum of Ingredients.Stock > value.",
+        ["custom-operation"] = ("CustomOperation: total_stock_above = sum of Ingredients.Stock > value. sku_is = Sku == (string)value.",
             () => new QueryKitConfiguration(s =>
             {
                 s.CustomOperation<Recipe>((x, op, value) => x.Ingredients.Sum(i => i.Stock) > (int)value)
                     .HasQueryName("total_stock_above");
+                s.CustomOperation<Recipe>((x, op, value) => x.Sku == (string)value)
+                    .HasQueryName("sku_is");
             })),
 
         ["word-operators"] = ("Custom operators: eq neq gt gte lt lte ct sw ew, and/or, case-insensitive appendix i.",
@@ -52,6 +54,12 @@ public static class Configs
                 s.CaseInsensitiveAppendix = "i";
             })),
 
+        ["hidden-price"] = ("Price PreventFilter and PreventSort, with HasQueryName(\"cost\").",
+            () => new QueryKitConfiguration(s =>
+            {
+                s.Property<Recipe>(x => x.Price).HasQueryName("cost").PreventFilter().PreventSort();
+            })),
+
         ["allow-unknown"] = ("AllowUnknownProperties = true.",
             () => new QueryKitConfiguration(s => s.AllowUnknownProperties = true)),
 
diff --git a/.agents/skills/verify-querykit/harness/Driver/Model.cs b/.agents/skills/verify-querykit/harness/Driver/Model.cs
index 7bd6836..a4ff3ca 100644
--- a/.agents/skills/verify-querykit/harness/Driver/Model.cs
+++ b/.agents/skills/verify-querykit/harness/Driver/Model.cs
@@ -33,6 +33,9 @@ public class Recipe
     public Visibility Visibility { get; set; }
     public DateTime CreatedAt { get; set; }
     public DateOnly? DateOfOrigin { get; set; }
+    public string Sku { get; set; } = "";
+    public string? Serving { get; set; }
+    public TimeOnly? ServeTime { get; set; }
     public List<string> Tags { get; set; } = [];
     public Guid AuthorId { get; set; }
     public Author Author { get; set; } = null!;
@@ -61,25 +64,29 @@ public static List<Recipe> Build()
             Recipe(1, "Pancakes", julia, rating: 5, price: 4.50m, vegetarian: true, Visibility.Public,
                 created: new DateTime(2024, 1, 15, 8, 0, 0, DateTimeKind.Utc), origin: new DateOnly(1900, 1, 1),
                 directions: "Whisk and fry", tags: ["breakfast", "sweet"],
-                ingredients: [("flour", 10), ("egg", 0)]),
+                ingredients: [("flour", 10), ("egg", 0)],
+                sku: "001", serving: "Warm, with syrup", serveTime: new TimeOnly(8, 30, 0, 500)),
             Recipe(2, "Beef Stew", gordon, rating: 3, price: 12.00m, vegetarian: false, Visibility.Public,
                 created: new DateTime(2024, 3, 1, 18, 30, 0, DateTimeKind.Utc), origin: null,
                 directions: "Simmer for hours", tags: ["dinner"],
-                ingredients: [("beef", 2), ("salt", 50)]),
+                ingredients: [("beef", 2), ("salt", 50)],
+                sku: "002", serving: "Hot", serveTime: new TimeOnly(18, 0, 0)),
             Recipe(3, "Salt Bread", julia, rating: 4, price: 3.25m, vegetarian: true, Visibility.Private,
                 created: new DateTime(2024, 6, 10, 12, 0, 0, DateTimeKind.Utc), origin: new DateOnly(1950, 5, 20),
                 directions: "Knead and bake", tags: ["bread", "Winner"],
-                ingredients: [("salt", 5), ("flour", 3)]),
+                ingredients: [("salt", 5), ("flour", 3)],
+                sku: "003", serving: "Sliced", serveTime: new TimeOnly(12, 15, 30, 250)),
             Recipe(4, "Plain Water", anon, rating: 1, price: 0m, vegetarian: true, Visibility.Private,
                 created: new DateTime(2023, 12, 31, 23, 59, 0, DateTimeKind.Utc), origin: null,
                 directions: null, tags: [],
-                ingredients: []),
+                ingredients: [],
+                sku: "004", serving: null, serveTime: null),
         ];
     }
 
     private static Recipe Recipe(int n, string title, Author author, int rating, decimal price, bool vegetarian,
         Visibility visibility, DateTime created, DateOnly? origin, string? directions, List<string> tags,
-        (string Name, int Stock)[] ingredients)
+        (string Name, int Stock)[] ingredients, string sku, string? serving, TimeOnly? serveTime)
     {
         var id = G(n);
         return new Recipe
@@ -93,6 +100,9 @@ private static Recipe Recipe(int n, string title, Author author, int rating, dec
             Visibility = visibility,
             CreatedAt = created,
             DateOfOrigin = origin,
+            Sku = sku,
+            Serving = serving,
+            ServeTime = serveTime,
             Tags = tags,
             AuthorId = author.Id,
             Author = author,
diff --git a/.agents/skills/verify-querykit/harness/Driver/Program.cs b/.agents/skills/verify-querykit/harness/Driver/Program.cs
index 38f43c0..d4a6eb0 100644
--- a/.agents/skills/verify-querykit/harness/Driver/Program.cs
+++ b/.agents/skills/verify-querykit/harness/Driver/Program.cs
@@ -14,6 +14,7 @@
 var target = "both";
 var configName = "none";
 var aggregate = false;
+string? culture = null;
 
 for (var i = 0; i < args.Length; i++)
 {
@@ -24,16 +25,24 @@
         case "--target": target = args[++i]; break;
         case "--config": configName = args[++i]; break;
         case "--aggregate": aggregate = true; break;
+        case "--culture": culture = args[++i]; break;
         case "--list-configs":
             foreach (var (name, preset) in Configs.All) Console.WriteLine($"{name,-18} {preset.Description}");
             return 0;
         default:
             Console.Error.WriteLine($"Unknown argument '{args[i]}'.");
-            Console.Error.WriteLine("Usage: qk-driver [--filter <f>] [--sort <s>] [--target memory|postgres|both] [--config <preset>] [--aggregate] | --list-configs");
+            Console.Error.WriteLine("Usage: qk-driver [--filter <f>] [--sort <s>] [--target memory|postgres|both] [--config <preset>] [--aggregate] [--culture <name>] | --list-configs");
             return 1;
     }
 }
 
+if (culture is not null)
+{
+    // Simulates a consumer app whose thread culture is not en-US, for example de-DE.
+    System.Globalization.CultureInfo.CurrentCulture = new System.Globalization.CultureInfo(culture);
+    System.Globalization.CultureInfo.CurrentUICulture = System.Globalization.CultureInfo.CurrentCulture;
+}
+
 if (!Configs.All.TryGetValue(configName, out var configPreset))
 {
     Console.Error.WriteLine($"Unknown config preset '{configName}'. Run with --list-configs.");
@@ -72,7 +81,8 @@
 
 var doc = new JsonObject
 {
-    ["input"] = new JsonObject { ["filter"] = filter, ["sort"] = sort, ["config"] = configName, ["api"] = api },
+    ["input"] = new JsonObject { ["filter"] = filter, ["sort"] = sort, ["config"] = configName, ["api"] = api,
+        ["culture"] = System.Globalization.CultureInfo.CurrentCulture.Name, ["timeZone"] = TimeZoneInfo.Local.Id },
     ["expression"] = DescribeExpression(),
     ["results"] = results,
 };
@@ -162,6 +172,9 @@ void AddRows(JsonObject result, List<Recipe> recipes)
         ["visibility"] = r.Visibility.ToString(),
         ["createdAt"] = r.CreatedAt.ToString("O"),
         ["dateOfOrigin"] = r.DateOfOrigin?.ToString("O"),
+        ["sku"] = r.Sku,
+        ["serving"] = r.Serving,
+        ["serveTime"] = r.ServeTime?.ToString("O"),
         ["directions"] = r.Directions,
         ["tags"] = new JsonArray(r.Tags.Select(t => (JsonNode?)t).ToArray()),
         ["ingredients"] = new JsonArray(r.Ingredients.OrderBy(x => x.Name)

From 21995bc51f53d1641ec07a7b8a60c9b06acdf2e9 Mon Sep 17 00:00:00 2001
From: Paul DeVito <pdevito3@gmail.com>
Date: Tue, 29 Sep 2026 21:06:13 +0300
Subject: [PATCH 04/13] fix(parser): resolve operator aliases in the grammar

Operator aliases (for example eq and and) were applied with a regex
over the whole filter string before parsing. The regex also changed
text inside quoted values, so Title eq "salt and pepper" became
Title == "salt && pepper" and matched nothing.

The comparison and logical operator parsers now read the configured
aliases directly. An alias still matches without regard to case and
must be followed by whitespace or the end of the input. Query names
set with HasQueryName still resolve when an alias operator follows
them.
---
 .../Tests/FilterParsingRegressionTests.cs     | 41 +++++++++++
 QueryKit.UnitTests/OperatorAliasTests.cs      | 33 +++++++++
 .../QueryKitConfigurationExtensions.cs        | 28 --------
 QueryKit/FilterParser.cs                      | 70 +++++++++++++++----
 4 files changed, 130 insertions(+), 42 deletions(-)
 create mode 100644 QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs

diff --git a/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs b/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
new file mode 100644
index 0000000..42b4b48
--- /dev/null
+++ b/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
@@ -0,0 +1,41 @@
+namespace QueryKit.IntegrationTests.Tests;
+
+using Configuration;
+using FluentAssertions;
+using Microsoft.EntityFrameworkCore;
+using SharedTestingHelper.Fakes;
+using WebApiTestProject.Entities;
+
+public class FilterParsingRegressionTests : TestBase
+{
+    [Fact]
+    public async Task operator_alias_text_inside_quoted_value_is_kept()
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var title = $"salt and pepper or eq {Guid.NewGuid()}";
+        var fakePersonOne = new FakeTestingPersonBuilder()
+            .WithTitle(title)
+            .Build();
+        var fakePersonTwo = new FakeTestingPersonBuilder().Build();
+        await testingServiceScope.InsertAsync(fakePersonOne, fakePersonTwo);
+
+        var input = $"""{nameof(TestingPerson.Title)} eq "{title}" and {nameof(TestingPerson.Id)} neq "{Guid.NewGuid()}" """;
+        var config = new QueryKitConfiguration(settings =>
+        {
+            settings.EqualsOperator = "eq";
+            settings.NotEqualsOperator = "neq";
+            settings.AndOperator = "and";
+            settings.OrOperator = "or";
+        });
+
+        // Act
+        var queryablePeople = testingServiceScope.DbContext().People;
+        var appliedQueryable = queryablePeople.ApplyQueryKitFilter(input, config);
+        var people = await appliedQueryable.ToListAsync();
+
+        // Assert
+        people.Count.Should().Be(1);
+        people[0].Id.Should().Be(fakePersonOne.Id);
+    }
+}
diff --git a/QueryKit.UnitTests/OperatorAliasTests.cs b/QueryKit.UnitTests/OperatorAliasTests.cs
index 681cef1..8a799c5 100644
--- a/QueryKit.UnitTests/OperatorAliasTests.cs
+++ b/QueryKit.UnitTests/OperatorAliasTests.cs
@@ -204,6 +204,39 @@ public void can_use_ints()
         filterExpression.ToDisplayString().Should().Be($"""x => (x.Rating > 10)""");
     }
 
+    [Fact]
+    public void alias_text_inside_quoted_value_is_not_replaced()
+    {
+        var input = """Title eq "salt and pepper or eq gt" and Rating gt 3""";
+
+        var config = new CustomQueryKitConfiguration();
+        var filterExpression = FilterParser.ParseFilter<Recipe>(input, config);
+        filterExpression.ToDisplayString().Should().Be($"""x => ((x.Title == "salt and pepper or eq gt") AndAlso (x.Rating > 3))""");
+    }
+
+    [Fact]
+    public void case_insensitive_alias_text_inside_quoted_value_is_not_replaced()
+    {
+        var input = """Title eqi "Whisk AND fry" """;
+
+        var config = new CustomQueryKitConfiguration();
+        var filterExpression = FilterParser.ParseFilter<Recipe>(input, config);
+        filterExpression.ToDisplayString().Should().Be($"""x => ((x.Title != null) AndAlso (x.Title.ToLower() == "Whisk AND fry".ToLower()))""");
+    }
+
+    [Fact]
+    public void can_use_alias_operator_with_query_name()
+    {
+        var input = """name eq "a eq b" """;
+
+        var config = new CustomQueryKitConfiguration(settings =>
+        {
+            settings.Property<Recipe>(x => x.Title).HasQueryName("name");
+        });
+        var filterExpression = FilterParser.ParseFilter<Recipe>(input, config);
+        filterExpression.ToDisplayString().Should().Be($"""x => (x.Title == "a eq b")""");
+    }
+
     public class CustomQueryKitConfiguration : QueryKitConfiguration
     {
         public CustomQueryKitConfiguration(Action<QueryKitSettings>? configureSettings = null)
diff --git a/QueryKit/Configuration/QueryKitConfigurationExtensions.cs b/QueryKit/Configuration/QueryKitConfigurationExtensions.cs
index 43735b6..f025780 100644
--- a/QueryKit/Configuration/QueryKitConfigurationExtensions.cs
+++ b/QueryKit/Configuration/QueryKitConfigurationExtensions.cs
@@ -1,37 +1,9 @@
 namespace QueryKit.Configuration;
 
-using System.Text.RegularExpressions;
 using QueryKit.Exceptions;
-using QueryKit.Operators;
 
 internal static class QueryKitConfigurationExtensions
 {
-    internal static string ReplaceComparisonAliases(this IQueryKitConfiguration configuration, string input)
-    {
-        var aliasedOperators = ComparisonOperator.GetAliasMatches(configuration);
-        foreach (var comparisonAliasMatch in aliasedOperators)
-        {
-            var escapedAlias = Regex.Escape(comparisonAliasMatch.Alias);
-            var regex = AliasRegexCache.Get($@"(?<=\s|^){escapedAlias}(?=\s|$)");
-            input = regex.Replace(input, comparisonAliasMatch.Operator);
-        }
-        
-        return input;
-    }
-    
-    internal static string ReplaceLogicalAliases(this IQueryKitConfiguration configuration, string input)
-    {
-        var aliasedOperators = LogicalOperator.GetAliasMatches(configuration);
-        foreach (var logicalAliasMatch in aliasedOperators)
-        {
-            var escapedAlias = Regex.Escape(logicalAliasMatch.Alias);
-            var regex = AliasRegexCache.Get($@"(?<=\s|^){escapedAlias}(?=\s|$)");
-            input = regex.Replace(input, logicalAliasMatch.Operator);
-        }
-        
-        return input;
-    }    
-    
     internal static string? GetPropertyPathByQueryName(this IQueryKitConfiguration configuration, string? queryName)
     {
         return configuration.PropertyMappings.GetPropertyPathByQueryName(queryName);
diff --git a/QueryKit/FilterParser.cs b/QueryKit/FilterParser.cs
index c36c616..14abf7c 100644
--- a/QueryKit/FilterParser.cs
+++ b/QueryKit/FilterParser.cs
@@ -21,9 +21,6 @@ public static class FilterParser
     public static Expression<Func<T, bool>> ParseFilter<T>(string input, IQueryKitConfiguration? config = null)
     {
         EnsureWithinParseLimits(input, config);
-
-        input = config?.ReplaceLogicalAliases(input) ?? input;
-        input = config?.ReplaceComparisonAliases(input) ?? input;
         
         var parameter = Expression.Parameter(typeof(T), "x");
         Expression expr;
@@ -136,12 +133,45 @@ from closeParen in Parse.Char(')')
             .Or(Parse.String(ComparisonOperator.HasOperator().Operator()).Text())
             .Or(Parse.String(ComparisonOperator.DoesNotHaveOperator().Operator()).Text());
 
-    private static readonly Parser<ComparisonOperator> ComparisonOperatorParser =
-        Parse.Char(ComparisonOperator.AllPrefix).Optional().Select(opt => opt.IsDefined)
-            .Then(hasHash => 
-                ComparisonOperatorTextParser
-                    .SelectMany(op => Parse.Char(ComparisonOperator.CaseSensitiveAppendix).Optional(), (op, caseInsensitive) => new { op, caseInsensitive, hasHash })
-                    .Select(x => ComparisonOperator.GetByOperatorString(x.op, x.caseInsensitive.IsDefined, x.hasHash)));
+    private static readonly Parser<(string Operator, bool CaseInsensitive)> CanonicalComparisonOperatorParser =
+        ComparisonOperatorTextParser
+            .SelectMany(op => Parse.Char(ComparisonOperator.CaseSensitiveAppendix).Optional(), (op, caseInsensitive) => (op, caseInsensitive.IsDefined));
+
+    private static Parser<ComparisonOperator> ComparisonOperatorParser(IQueryKitConfiguration? config)
+    {
+        var operatorParser = ComparisonOperatorAliasParser(config).Or(CanonicalComparisonOperatorParser);
+        return Parse.Char(ComparisonOperator.AllPrefix).Optional().Select(opt => opt.IsDefined)
+            .Then(hasHash => operatorParser.Select(x => ComparisonOperator.GetByOperatorString(x.Operator, x.CaseInsensitive, hasHash)));
+    }
+
+    // Aliases are matched in the grammar (not by rewriting the input) so text inside quoted values is never changed.
+    // Longer aliases are tried first so an alias that starts with another alias (e.g. `@@$$` and `@@$`) still matches.
+    private static Parser<(string Operator, bool CaseInsensitive)> ComparisonOperatorAliasParser(IQueryKitConfiguration? config)
+    {
+        Parser<(string Operator, bool CaseInsensitive)> parser = i => Result.Failure<(string, bool)>(i, "no operator alias", Array.Empty<string>());
+        if (config == null)
+            return parser;
+
+        var caseInsensitiveSuffix = ComparisonOperator.CaseSensitiveAppendix.ToString();
+        foreach (var match in ComparisonOperator.GetAliasMatches(config).OrderByDescending(x => x.Alias.Length))
+        {
+            var caseInsensitive = match.Operator.EndsWith(caseInsensitiveSuffix);
+            var op = caseInsensitive ? match.Operator[..^caseInsensitiveSuffix.Length] : match.Operator;
+            parser = parser.Or(OperatorAlias(match.Alias).Return((op, caseInsensitive)));
+        }
+
+        return parser;
+    }
+
+    // An alias is a whole word: it must be followed by whitespace or the end of the input.
+    private static Parser<string> OperatorAlias(string alias) => input =>
+    {
+        var result = Parse.IgnoreCase(alias).Text()(input);
+        if (!result.WasSuccessful || result.Remainder.AtEnd || char.IsWhiteSpace(result.Remainder.Current))
+            return result;
+
+        return Result.Failure<string>(input, $"Operator alias '{alias}' must be followed by whitespace", new[] { alias });
+    };
 
     private static PropertyInfo? GetPropertyInfo(Type type, string propertyName)
         => type.GetProperty(propertyName, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance);
@@ -269,6 +299,18 @@ from trailingSpaces in Parse.WhiteSpace.Many()
             ArithmeticFactorParser.Token(),
             (op, left, right) => new BinaryArithmeticExpression(left, op, right));
 
+    private static Parser<LogicalOperator> LogicalOperatorParserWithAliases(IQueryKitConfiguration? config)
+    {
+        var aliases = config == null ? new List<LogicalOperator.LogicalAliasMatch>() : LogicalOperator.GetAliasMatches(config);
+        return aliases.Aggregate(
+            LogicalOperatorParser,
+            (parser, match) => parser.Or(
+                from leadingSpaces in Parse.WhiteSpace.Many()
+                from op in OperatorAlias(match.Alias)
+                from trailingSpaces in Parse.WhiteSpace.Many()
+                select LogicalOperator.GetByOperatorString(match.Operator)));
+    }
+
     private static readonly Dictionary<Type, Func<string, object>> TypeConversionFunctions = new()
     {
         { typeof(string), value => value },
@@ -584,7 +626,7 @@ private static bool IsEnumerable(Type targetType)
     // New arithmetic-aware comparison parser - only matches expressions in parentheses with arithmetic operators
     private static Parser<Expression> ArithmeticComparisonExprParser<T>(ParameterExpression parameter, IQueryKitConfiguration? config)
     {
-        var comparisonOperatorParser = ComparisonOperatorParser.Token();
+        var comparisonOperatorParser = ComparisonOperatorParser(config).Token();
         var rightSideValueParser = RightSideValueParser.Token();
         
         // Only parse arithmetic expressions that are in parentheses and contain arithmetic operators
@@ -703,7 +745,7 @@ private static CaseInsensitiveMode ResolveCaseMode(string? propertyPath, IQueryK
 
     private static Parser<Expression> ComparisonExprParser<T>(ParameterExpression parameter, IQueryKitConfiguration? config)
     {
-        var comparisonOperatorParser = ComparisonOperatorParser.Token();
+        var comparisonOperatorParser = ComparisonOperatorParser(config).Token();
         var rightSideValueParser = RightSideValueParser.Token();
 
         // Try property list comparison first (e.g., (firstName, lastName) @=* "paul")
@@ -1029,7 +1071,7 @@ private static Parser<Expression> PropertyListComparisonExprParser<T>(
         ParameterExpression parameter,
         IQueryKitConfiguration? config)
     {
-        var comparisonOperatorParser = ComparisonOperatorParser.Token();
+        var comparisonOperatorParser = ComparisonOperatorParser(config).Token();
         var rightSideValueParser = RightSideValueParser.Token();
 
         return PropertyListParser
@@ -1124,14 +1166,14 @@ private static Parser<Expression> ExprParser<T>(ParameterExpression parameter, I
     
     private static Parser<Expression> AndExprParser<T>(ParameterExpression parameter, IQueryKitConfiguration? config = null)
         => Parse.ChainOperator(
-            LogicalOperatorParser.Where(x => x.Name == LogicalOperator.AndOperator.Operator()),
+            LogicalOperatorParserWithAliases(config).Where(x => x.Name == LogicalOperator.AndOperator.Operator()),
             AtomicExprParser<T>(parameter, config),
             CombineClauses<T>
         );
 
     private static Parser<Expression> OrExprParser<T>(ParameterExpression parameter, IQueryKitConfiguration? config = null)
         => Parse.ChainOperator(
-            LogicalOperatorParser.Where(x => x.Name == LogicalOperator.OrOperator.Operator()),
+            LogicalOperatorParserWithAliases(config).Where(x => x.Name == LogicalOperator.OrOperator.Operator()),
             AndExprParser<T>(parameter, config),
             CombineClauses<T>
         );

From ebb1b8c63e1cc1004e060732db1375642b920862 Mon Sep 17 00:00:00 2001
From: Paul DeVito <pdevito3@gmail.com>
Date: Tue, 29 Sep 2026 21:07:52 +0300
Subject: [PATCH 05/13] fix(parser): accept a decimal point in every culture

Number values were read with the decimal separator of the current culture only. Under de-DE or fr-FR, Rating > 4.5 failed to parse, so the same filter worked on one server and failed on another.

The number grammar now takes the longer of the invariant match and the current culture match. A '.' decimal point parses in every culture, and a value that parsed before gives the same result. List numbers always use the '.' decimal point because ',' separates the items. The literal checks in IsPropertyPath and the count operator value accept both cultures.
---
 .../Tests/FilterParsingRegressionTests.cs     |  38 ++++++
 .../FilterParsingRegressionTests.cs           | 108 ++++++++++++++++++
 QueryKit/FilterParser.cs                      |  26 ++++-
 3 files changed, 168 insertions(+), 4 deletions(-)
 create mode 100644 QueryKit.UnitTests/FilterParsingRegressionTests.cs

diff --git a/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs b/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
index 42b4b48..2f7a72d 100644
--- a/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
+++ b/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
@@ -1,5 +1,6 @@
 namespace QueryKit.IntegrationTests.Tests;
 
+using System.Globalization;
 using Configuration;
 using FluentAssertions;
 using Microsoft.EntityFrameworkCore;
@@ -38,4 +39,41 @@ public async Task operator_alias_text_inside_quoted_value_is_kept()
         people.Count.Should().Be(1);
         people[0].Id.Should().Be(fakePersonOne.Id);
     }
+
+    [Fact]
+    public async Task decimal_value_uses_invariant_culture()
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var title = $"culture {Guid.NewGuid()}";
+        var fakePersonOne = new FakeTestingPersonBuilder()
+            .WithTitle(title)
+            .WithRating(4.6m)
+            .Build();
+        var fakePersonTwo = new FakeTestingPersonBuilder()
+            .WithTitle(title)
+            .WithRating(4.4m)
+            .Build();
+        await testingServiceScope.InsertAsync(fakePersonOne, fakePersonTwo);
+
+        var input = $"""{nameof(TestingPerson.Title)} == "{title}" && {nameof(TestingPerson.Rating)} > 4.5""";
+
+        // Act
+        var originalCulture = CultureInfo.CurrentCulture;
+        IQueryable<TestingPerson> appliedQueryable;
+        try
+        {
+            CultureInfo.CurrentCulture = new CultureInfo("de-DE");
+            appliedQueryable = testingServiceScope.DbContext().People.ApplyQueryKitFilter(input);
+        }
+        finally
+        {
+            CultureInfo.CurrentCulture = originalCulture;
+        }
+        var people = await appliedQueryable.ToListAsync();
+
+        // Assert
+        people.Count.Should().Be(1);
+        people[0].Id.Should().Be(fakePersonOne.Id);
+    }
 }
diff --git a/QueryKit.UnitTests/FilterParsingRegressionTests.cs b/QueryKit.UnitTests/FilterParsingRegressionTests.cs
new file mode 100644
index 0000000..9e048ab
--- /dev/null
+++ b/QueryKit.UnitTests/FilterParsingRegressionTests.cs
@@ -0,0 +1,108 @@
+namespace QueryKit.UnitTests;
+
+using System.Globalization;
+using Exceptions;
+using FluentAssertions;
+using WebApiTestProject.Entities;
+
+public class FilterParsingRegressionTests
+{
+    [Theory]
+    [InlineData("de-DE")]
+    [InlineData("fr-FR")]
+    [InlineData("en-US")]
+    public void decimal_value_uses_invariant_culture(string cultureName)
+    {
+        var input = """Rating > 4.5""";
+
+        var filterExpression = WithCulture(cultureName, () => FilterParser.ParseFilter<TestingPerson>(input));
+
+        filterExpression.ToDisplayString().Should().Be("x => (x.Rating > 4.5)");
+    }
+
+    [Theory]
+    [InlineData("de-DE")]
+    [InlineData("fr-FR")]
+    public void decimal_value_with_culture_decimal_comma_is_read_as_before(string cultureName)
+    {
+        var input = """Rating > 4,5""";
+
+        var filterExpression = WithCulture(cultureName, () => FilterParser.ParseFilter<TestingPerson>(input));
+
+        filterExpression.ToDisplayString().Should().Be("x => (x.Rating > 45)");
+    }
+
+    [Fact]
+    public void decimal_value_with_decimal_comma_is_not_accepted_in_a_culture_with_decimal_point()
+    {
+        var input = """Rating > 4,5""";
+
+        var act = () => WithCulture("en-US", () => FilterParser.ParseFilter<TestingPerson>(input));
+
+        act.Should().Throw<QueryKitException>();
+    }
+
+    [Theory]
+    [InlineData("de-DE")]
+    [InlineData("en-US")]
+    public void list_numbers_are_separated_by_commas_in_every_culture(string cultureName)
+    {
+        var people = new[]
+        {
+            new TestingPerson { Title = "four", Rating = 4m },
+            new TestingPerson { Title = "four and a half", Rating = 4.5m },
+            new TestingPerson { Title = "five", Rating = 5m },
+        };
+
+        var result = WithCulture(cultureName, () => people.AsQueryable().ApplyQueryKitFilter("Rating ^^ [4,5]").ToList());
+
+        result.Select(x => x.Title).Should().Equal("four", "five");
+    }
+
+    [Theory]
+    [InlineData("de-DE")]
+    [InlineData("en-US")]
+    public void list_number_uses_invariant_culture(string cultureName)
+    {
+        var people = new[]
+        {
+            new TestingPerson { Title = "four", Rating = 4m },
+            new TestingPerson { Title = "four and a half", Rating = 4.5m },
+        };
+
+        var result = WithCulture(cultureName, () => people.AsQueryable().ApplyQueryKitFilter("Rating ^^ [4.5, 6]").ToList());
+
+        result.Select(x => x.Title).Should().Equal("four and a half");
+    }
+
+    [Fact]
+    public void decimal_value_uses_invariant_culture_in_memory()
+    {
+        var people = new[]
+        {
+            new TestingPerson { Title = "low", Rating = 4.4m },
+            new TestingPerson { Title = "high", Rating = 4.6m },
+        };
+
+        var result = WithCulture("de-DE", () => people.AsQueryable().ApplyQueryKitFilter("Rating > 4.5").ToList());
+
+        result.Select(x => x.Title).Should().Equal("high");
+    }
+
+    private static TResult WithCulture<TResult>(string cultureName, Func<TResult> action)
+    {
+        var originalCulture = CultureInfo.CurrentCulture;
+        var originalUiCulture = CultureInfo.CurrentUICulture;
+        try
+        {
+            CultureInfo.CurrentCulture = new CultureInfo(cultureName);
+            CultureInfo.CurrentUICulture = new CultureInfo(cultureName);
+            return action();
+        }
+        finally
+        {
+            CultureInfo.CurrentCulture = originalCulture;
+            CultureInfo.CurrentUICulture = originalUiCulture;
+        }
+    }
+}
diff --git a/QueryKit/FilterParser.cs b/QueryKit/FilterParser.cs
index 14abf7c..bc518c1 100644
--- a/QueryKit/FilterParser.cs
+++ b/QueryKit/FilterParser.cs
@@ -205,9 +205,26 @@ from timeZone in DateTimeZoneParser
         from micros in DateTimeMicrosParser
         select dateFormat + timeFormat + micros + timeZone;
 
+    // A number with a '.' decimal point, or with the decimal separator of the current culture.
+    // The longer match wins, so '4.5' parses in every culture and '4,5' still parses in a culture that uses ','.
+    private static readonly Parser<string> UnsignedNumberParser = input =>
+    {
+        var invariant = Parse.DecimalInvariant(input);
+        var culture = Parse.Decimal(input);
+        return culture.WasSuccessful && (!invariant.WasSuccessful || culture.Remainder.Position > invariant.Remainder.Position)
+            ? culture
+            : invariant;
+    };
+
     private static readonly Parser<string> NumberParser =
         from sign in Parse.Char('-').Optional().Select(x => x.IsDefined ? "-" : "")
-        from number in Parse.Decimal
+        from number in UnsignedNumberParser
+        select sign + number;
+
+    // List items are separated by ',', so a list number always uses the '.' decimal point.
+    private static readonly Parser<string> ListNumberParser =
+        from sign in Parse.Char('-').Optional().Select(x => x.IsDefined ? "-" : "")
+        from number in Parse.DecimalInvariant
         select sign + number;
 
     private static readonly Parser<string> GuidFormatParser = Parse.Regex(@"[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}").Text();
@@ -229,7 +246,7 @@ from closingQuotes in Parse.Char('"').Repeat(count).Text()
             .Or(GuidFormatParser)
             .Or(DateTimeFormatParser)
             .Or(TimeFormatParser)
-            .Or(NumberParser)
+            .Or(ListNumberParser)
             .Or(RawStringLiteralParser.Or(DoubleQuoteParser))
             .Or(Identifier)
             .DelimitedBy(Parse.Char(',').Token());
@@ -424,7 +441,7 @@ private static Expression CreateRightExprFromType(Type leftExprType, string righ
         var targetType = leftExprType;
         if (isEnumerable)
         {
-            if (op.IsCountOperator() && int.TryParse(right, out var intVal))
+            if (op.IsCountOperator() && (int.TryParse(right, out var intVal) || int.TryParse(right, NumberStyles.Integer, CultureInfo.InvariantCulture, out intVal)))
             {
                 return FilterValue.Parameter(intVal, typeof(int));
             }
@@ -1326,8 +1343,9 @@ private static bool IsPropertyPath(string value, Type entityType)
         if (value == "null" || 
             value.StartsWith("\"") || 
             value.StartsWith("[") ||
-            value.Contains("-") && DateTime.TryParse(value, out _) ||
+            value.Contains("-") && (DateTime.TryParse(value, out _) || DateTime.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.None, out _)) ||
             decimal.TryParse(value, out _) ||
+            decimal.TryParse(value, NumberStyles.Number, CultureInfo.InvariantCulture, out _) ||
             bool.TryParse(value, out _) ||
             Guid.TryParse(value, out _))
         {

From 3215dd1079cde4dc9e08fe8ddb75ddc792e3a033 Mon Sep 17 00:00:00 2001
From: Paul DeVito <pdevito3@gmail.com>
Date: Tue, 29 Sep 2026 21:10:08 +0300
Subject: [PATCH 06/13] fix(parser): keep commas inside quoted list values

The in and not-in operators split the list value on every comma after
the quotes were removed. Serving ^^ ["Warm, with syrup"] became the
two items Warm and with syrup, so it matched nothing, and !^^ matched
every row.

The list grammar now escapes each item before it joins the items, and
the value and enum conversions split on unescaped commas only. Each
item is still trimmed, as before.
---
 .../Tests/FilterParsingRegressionTests.cs     | 29 +++++++++++++++
 .../FilterParsingRegressionTests.cs           | 36 ++++++++++++++++++
 QueryKit/FilterParser.cs                      | 37 +++++++++++++++++--
 3 files changed, 99 insertions(+), 3 deletions(-)

diff --git a/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs b/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
index 2f7a72d..af80acc 100644
--- a/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
+++ b/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
@@ -76,4 +76,33 @@ public async Task decimal_value_uses_invariant_culture()
         people.Count.Should().Be(1);
         people[0].Id.Should().Be(fakePersonOne.Id);
     }
+
+    [Fact]
+    public async Task list_value_with_comma_is_one_item()
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var suffix = Guid.NewGuid().ToString();
+        var fakePersonOne = new FakeTestingPersonBuilder()
+            .WithTitle($"Warm, with syrup {suffix}")
+            .WithFirstName(suffix)
+            .Build();
+        var fakePersonTwo = new FakeTestingPersonBuilder()
+            .WithTitle("Warm")
+            .WithFirstName(suffix)
+            .Build();
+        await testingServiceScope.InsertAsync(fakePersonOne, fakePersonTwo);
+
+        var inInput = $"""{nameof(TestingPerson.FirstName)} == "{suffix}" && {nameof(TestingPerson.Title)} ^^ ["Warm, with syrup {suffix}"]""";
+        var notInInput = $"""{nameof(TestingPerson.FirstName)} == "{suffix}" && {nameof(TestingPerson.Title)} !^^ ["Warm, with syrup {suffix}"]""";
+
+        // Act
+        var queryablePeople = testingServiceScope.DbContext().People;
+        var inPeople = await queryablePeople.ApplyQueryKitFilter(inInput).ToListAsync();
+        var notInPeople = await queryablePeople.ApplyQueryKitFilter(notInInput).ToListAsync();
+
+        // Assert
+        inPeople.Select(x => x.Id).Should().Equal(fakePersonOne.Id);
+        notInPeople.Select(x => x.Id).Should().Equal(fakePersonTwo.Id);
+    }
 }
diff --git a/QueryKit.UnitTests/FilterParsingRegressionTests.cs b/QueryKit.UnitTests/FilterParsingRegressionTests.cs
index 9e048ab..dacd9de 100644
--- a/QueryKit.UnitTests/FilterParsingRegressionTests.cs
+++ b/QueryKit.UnitTests/FilterParsingRegressionTests.cs
@@ -89,6 +89,42 @@ public void decimal_value_uses_invariant_culture_in_memory()
         result.Select(x => x.Title).Should().Equal("high");
     }
 
+    [Theory]
+    [InlineData("Title ^^ [\"Warm, with syrup\", \"a\\b\"]", new[] { "Warm, with syrup", "a\\b" })]
+    [InlineData("Title !^^ [\"Warm, with syrup\", \"a\\b\"]", new[] { "Warm", "with syrup" })]
+    [InlineData("Title ^^* [\"WARM, WITH SYRUP\"]", new[] { "Warm, with syrup" })]
+    [InlineData("Title ^^ [\"\"\"Warm, with syrup\"\"\", \"Warm\"]", new[] { "Warm, with syrup", "Warm" })]
+    [InlineData("Title ^^ [\" Warm \", \"with syrup \"]", new[] { "Warm", "with syrup" })]
+    public void list_value_with_comma_is_one_item(string input, string[] expectedTitles)
+    {
+        var people = new[]
+        {
+            new TestingPerson { Title = "Warm, with syrup" },
+            new TestingPerson { Title = "Warm" },
+            new TestingPerson { Title = "with syrup" },
+            new TestingPerson { Title = "a\\b" },
+        };
+
+        var result = people.AsQueryable().ApplyQueryKitFilter(input).ToList();
+
+        result.Select(x => x.Title).Should().BeEquivalentTo(expectedTitles);
+    }
+
+    [Fact]
+    public void enum_list_value_is_split_into_items()
+    {
+        var people = new[]
+        {
+            new TestingPerson { Title = "jan", BirthMonth = BirthMonthEnum.January },
+            new TestingPerson { Title = "feb", BirthMonth = BirthMonthEnum.February },
+            new TestingPerson { Title = "mar", BirthMonth = BirthMonthEnum.March },
+        };
+
+        var result = people.AsQueryable().ApplyQueryKitFilter("""BirthMonth ^^ ["January", "March"]""").ToList();
+
+        result.Select(x => x.Title).Should().BeEquivalentTo("jan", "mar");
+    }
+
     private static TResult WithCulture<TResult>(string cultureName, Func<TResult> action)
     {
         var originalCulture = CultureInfo.CurrentCulture;
diff --git a/QueryKit/FilterParser.cs b/QueryKit/FilterParser.cs
index bc518c1..81d2f61 100644
--- a/QueryKit/FilterParser.cs
+++ b/QueryKit/FilterParser.cs
@@ -3,6 +3,7 @@
 using System.Globalization;
 using System.Linq.Expressions;
 using System.Reflection;
+using System.Text;
 using Configuration;
 using Exceptions;
 using Operators;
@@ -255,7 +256,37 @@ from closingQuotes in Parse.Char('"').Repeat(count).Text()
         from openingBracket in Parse.Char('[')
         from content in SquareBracketValuesParser
         from closingBracket in Parse.Char(']')
-        select "[" + string.Join(",", content) + "]";
+        select "[" + string.Join(",", content.Select(EscapeListItem)) + "]";
+
+    // List items are joined with ',' so quoted items that contain ',' or '\' are escaped and split back with SplitListItems, which trims each item
+    private static string EscapeListItem(string item)
+        => item.Replace(@"\", @"\\").Replace(",", @"\,");
+
+    private static List<string> SplitListItems(string list)
+    {
+        var items = new List<string>();
+        var current = new StringBuilder();
+        var content = list.Substring(1, list.Length - 2);
+        for (var i = 0; i < content.Length; i++)
+        {
+            if (content[i] == '\\' && i + 1 < content.Length)
+            {
+                current.Append(content[++i]);
+            }
+            else if (content[i] == ',')
+            {
+                items.Add(current.ToString().Trim());
+                current.Clear();
+            }
+            else
+            {
+                current.Append(content[i]);
+            }
+        }
+        items.Add(current.ToString().Trim());
+
+        return items;
+    }
 
     private static readonly Parser<RightSideValue> RightSideValueChoiceParser =
         Parse.String("null").Text().Select(v => new RightSideValue(v, false))
@@ -473,7 +504,7 @@ private static Expression CreateRightExprFromType(Type leftExprType, string righ
                 {
                     targetType = typeof(string);
                 }
-                var values = right.Trim('[', ']').Split(',').Select(x => x.Trim()).ToList();
+                var values = SplitListItems(right);
                 var elementType = targetType.IsArray ? targetType.GetElementType()! : targetType;
 
                 var expressions = values.Select(x =>
@@ -574,7 +605,7 @@ private static Expression CreateRightExprFromType(Type leftExprType, string righ
             
             if (right.StartsWith("[") && right.EndsWith("]"))
             {
-                var values = right.Trim('[', ']').Split(',').Select(x => x.Trim()).ToList();
+                var values = SplitListItems(right);
                 var elementType = targetType.IsArray ? targetType.GetElementType() : targetType;
             
                 var expressions = values.Select<string, Expression>(x =>

From d5bcd39542f9011ed6bb1d2ce13d7816b163ce25 Mon Sep 17 00:00:00 2001
From: Paul DeVito <pdevito3@gmail.com>
Date: Tue, 29 Sep 2026 21:38:52 +0300
Subject: [PATCH 07/13] fix(parser): send date time offset values as utc

Filter values are now query parameters. Npgsql rejects a DateTimeOffset parameter with a non-zero offset, so a filter such as `SpecificDate == 2024-01-15T10:00:00+02:00` threw on Postgres. The parser now converts the value to the same instant in UTC.
---
 .../Tests/FilterParsingRegressionTests.cs     | 28 +++++++++++++++++++
 QueryKit.UnitTests/FilterParserTests.cs       |  8 +++---
 QueryKit/FilterParser.cs                      |  5 ++--
 3 files changed, 35 insertions(+), 6 deletions(-)

diff --git a/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs b/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
index af80acc..5dc6f71 100644
--- a/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
+++ b/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
@@ -105,4 +105,32 @@ public async Task list_value_with_comma_is_one_item()
         inPeople.Select(x => x.Id).Should().Equal(fakePersonOne.Id);
         notInPeople.Select(x => x.Id).Should().Equal(fakePersonTwo.Id);
     }
+
+    [Theory]
+    [InlineData("SpecificDate == 2024-01-15T10:00:00+02:00")]
+    [InlineData("SpecificDate ^^ [2024-01-15T10:00:00+02:00]")]
+    public async Task date_time_offset_value_with_offset_matches_same_instant(string valueFilter)
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var title = $"offset {Guid.NewGuid()}";
+        var fakePersonOne = new FakeTestingPersonBuilder()
+            .WithTitle(title)
+            .WithSpecificDate(new DateTimeOffset(2024, 1, 15, 8, 0, 0, TimeSpan.Zero))
+            .Build();
+        var fakePersonTwo = new FakeTestingPersonBuilder()
+            .WithTitle(title)
+            .WithSpecificDate(new DateTimeOffset(2024, 1, 15, 10, 0, 0, TimeSpan.Zero))
+            .Build();
+        await testingServiceScope.InsertAsync(fakePersonOne, fakePersonTwo);
+
+        var input = $"""{nameof(TestingPerson.Title)} == "{title}" && {valueFilter}""";
+
+        // Act
+        var queryablePeople = testingServiceScope.DbContext().People;
+        var people = await queryablePeople.ApplyQueryKitFilter(input).ToListAsync();
+
+        // Assert
+        people.Select(x => x.Id).Should().Equal(fakePersonOne.Id);
+    }
 }
diff --git a/QueryKit.UnitTests/FilterParserTests.cs b/QueryKit.UnitTests/FilterParserTests.cs
index 87ce7fd..6892b8e 100644
--- a/QueryKit.UnitTests/FilterParserTests.cs
+++ b/QueryKit.UnitTests/FilterParserTests.cs
@@ -273,7 +273,7 @@ public void can_handle_datetime_comparison_with_timezone()
     {
         var input = """SpecificDate == 2022-07-01T00:00:03+01:00""";
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
-        filterExpression.ToDisplayString().Should().Be("x => (x.SpecificDate == new Nullable`1(new DateTimeOffset(637922304030000000, 01:00:00)))");
+        filterExpression.ToDisplayString().Should().Be("x => (x.SpecificDate == new Nullable`1(new DateTimeOffset(637922268030000000, 00:00:00)))");
     }
 
     [Theory]
@@ -308,7 +308,7 @@ public void can_handle_datetime_comparison_with_timezone_another()
     {
         var input = """SpecificDate == "2022-07-01T00:00:03+01:00" """;
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
-        filterExpression.ToDisplayString().Should().Be("x => (x.SpecificDate == new Nullable`1(new DateTimeOffset(637922304030000000, 01:00:00)))");
+        filterExpression.ToDisplayString().Should().Be("x => (x.SpecificDate == new Nullable`1(new DateTimeOffset(637922268030000000, 00:00:00)))");
     }
 
     [Fact]
@@ -324,7 +324,7 @@ public void can_handle_datetime_comparison_with_negative_timezone()
     {
         var input = """SpecificDate == 2022-07-01T00:00:03-02:00""";
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
-        filterExpression.ToDisplayString().Should().Be("x => (x.SpecificDate == new Nullable`1(new DateTimeOffset(637922304030000000, -02:00:00)))");
+        filterExpression.ToDisplayString().Should().Be("x => (x.SpecificDate == new Nullable`1(new DateTimeOffset(637922376030000000, 00:00:00)))");
     }
 
     [Fact]
@@ -332,7 +332,7 @@ public void can_handle_datetime_comparison_with_timezone_no_minutes()
     {
         var input = """SpecificDate == 2022-07-01T00:00:03+02""";
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
-        filterExpression.ToDisplayString().Should().Be("x => (x.SpecificDate == new Nullable`1(new DateTimeOffset(637922304030000000, 02:00:00)))");
+        filterExpression.ToDisplayString().Should().Be("x => (x.SpecificDate == new Nullable`1(new DateTimeOffset(637922232030000000, 00:00:00)))");
     }
 
     [Fact]
diff --git a/QueryKit/FilterParser.cs b/QueryKit/FilterParser.cs
index 81d2f61..2a823fe 100644
--- a/QueryKit/FilterParser.cs
+++ b/QueryKit/FilterParser.cs
@@ -373,7 +373,7 @@ from trailingSpaces in Parse.WhiteSpace.Many()
         { typeof(short), value => short.Parse(value, CultureInfo.InvariantCulture) },
         { typeof(byte), value => byte.Parse(value, CultureInfo.InvariantCulture) },
         { typeof(DateTime), value => DateTime.Parse(value, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal) },
-        { typeof(DateTimeOffset), value => DateTimeOffset.Parse(value) },
+        { typeof(DateTimeOffset), value => DateTimeOffset.Parse(value).ToUniversalTime() },
         { typeof(DateOnly), value => DateOnly.Parse(value) },
         { typeof(TimeOnly), value => TimeOnly.Parse(value) },
         { typeof(TimeSpan), value => TimeSpan.Parse(value) },
@@ -543,7 +543,8 @@ private static Expression CreateRightExprFromType(Type leftExprType, string righ
             {
                 var dtStyle = right.EndsWith("Z") ? DateTimeStyles.AdjustToUniversal : DateTimeStyles.AssumeLocal;
                 var dto = DateTimeOffset.Parse(right, CultureInfo.InvariantCulture, dtStyle);
-                return FilterValue.Parameter(dto, rawType);
+                // Npgsql only accepts a DateTimeOffset parameter with offset 0. The UTC value is the same instant.
+                return FilterValue.Parameter(dto.ToUniversalTime(), rawType);
             }
 
             if (targetType == typeof(DateOnly))

From 6c5d9c50a540c43a136db9285719f41d5774af31 Mon Sep 17 00:00:00 2001
From: Paul DeVito <pdevito3@gmail.com>
Date: Tue, 29 Sep 2026 21:11:41 +0300
Subject: [PATCH 08/13] fix(parser): keep fractional seconds in date and time
 values

An unquoted DateTime with a fraction and a zone, for example
2024-01-15T08:00:00.500Z, failed to parse because the grammar read the
zone before the fraction. An unquoted TimeOnly with a fraction also
failed to parse, and a quoted TimeOnly lost a fraction with fewer than
three digits, so 08:30:00.5 became 08:30:00.

The grammar now reads up to seven fraction digits before the zone, the
time grammar accepts a fraction, and the TimeOnly value keeps the
milliseconds and microseconds of the parsed time.
---
 .../Tests/FilterParsingRegressionTests.cs     | 34 ++++++++++++++
 .../FilterParsingRegressionTests.cs           | 44 +++++++++++++++++++
 QueryKit/FilterParser.cs                      | 22 +++-------
 3 files changed, 84 insertions(+), 16 deletions(-)

diff --git a/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs b/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
index 5dc6f71..c074bd2 100644
--- a/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
+++ b/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
@@ -133,4 +133,38 @@ public async Task date_time_offset_value_with_offset_matches_same_instant(string
         // Assert
         people.Select(x => x.Id).Should().Equal(fakePersonOne.Id);
     }
+
+    [Theory]
+    [InlineData("SpecificDateTime == 2024-01-15T08:00:00.500Z")]
+    [InlineData("SpecificDate == 2024-01-15T10:00:00.5+02:00")]
+    [InlineData("Time == 08:30:00.5")]
+    [InlineData("Time == \"08:30:00.5\"")]
+    public async Task fractional_seconds_are_kept(string valueFilter)
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var title = $"fraction {Guid.NewGuid()}";
+        var fakePersonOne = new FakeTestingPersonBuilder()
+            .WithTitle(title)
+            .WithSpecificDateTime(new DateTime(2024, 1, 15, 8, 0, 0, 500, DateTimeKind.Utc))
+            .WithSpecificDate(new DateTimeOffset(2024, 1, 15, 8, 0, 0, 500, TimeSpan.Zero))
+            .WithTime(new TimeOnly(8, 30, 0, 500))
+            .Build();
+        var fakePersonTwo = new FakeTestingPersonBuilder()
+            .WithTitle(title)
+            .WithSpecificDateTime(new DateTime(2024, 1, 15, 8, 0, 0, DateTimeKind.Utc))
+            .WithSpecificDate(new DateTimeOffset(2024, 1, 15, 8, 0, 0, TimeSpan.Zero))
+            .WithTime(new TimeOnly(8, 30, 0))
+            .Build();
+        await testingServiceScope.InsertAsync(fakePersonOne, fakePersonTwo);
+
+        var input = $"""{nameof(TestingPerson.Title)} == "{title}" && {valueFilter}""";
+
+        // Act
+        var queryablePeople = testingServiceScope.DbContext().People;
+        var people = await queryablePeople.ApplyQueryKitFilter(input).ToListAsync();
+
+        // Assert
+        people.Select(x => x.Id).Should().Equal(fakePersonOne.Id);
+    }
 }
diff --git a/QueryKit.UnitTests/FilterParsingRegressionTests.cs b/QueryKit.UnitTests/FilterParsingRegressionTests.cs
index dacd9de..2ab027a 100644
--- a/QueryKit.UnitTests/FilterParsingRegressionTests.cs
+++ b/QueryKit.UnitTests/FilterParsingRegressionTests.cs
@@ -125,6 +125,50 @@ public void enum_list_value_is_split_into_items()
         result.Select(x => x.Title).Should().BeEquivalentTo("jan", "mar");
     }
 
+    [Theory]
+    [InlineData("SpecificDateTime == 2024-01-15T08:00:00.500Z")]
+    [InlineData("SpecificDateTime == 2024-01-15T08:00:00.5Z")]
+    [InlineData("SpecificDateTime == \"2024-01-15T08:00:00.5Z\"")]
+    [InlineData("SpecificDateTime ^^ [2024-01-15T08:00:00.5Z]")]
+    [InlineData("SpecificDate == 2024-01-15T10:00:00.5+02:00")]
+    [InlineData("SpecificDate == 2024-01-15T08:00:00.5000000Z")]
+    [InlineData("Time == 08:30:00.5")]
+    [InlineData("Time == \"08:30:00.5\"")]
+    [InlineData("Time == \"08:30:00.50\"")]
+    [InlineData("Time ^^ [08:30:00.5]")]
+    public void fractional_seconds_are_kept(string input)
+    {
+        var people = new[]
+        {
+            new TestingPerson
+            {
+                Title = "match",
+                SpecificDateTime = new DateTime(2024, 1, 15, 8, 0, 0, 500, DateTimeKind.Utc),
+                SpecificDate = new DateTimeOffset(2024, 1, 15, 8, 0, 0, 500, TimeSpan.Zero),
+                Time = new TimeOnly(8, 30, 0, 500),
+            },
+            new TestingPerson
+            {
+                Title = "whole second",
+                SpecificDateTime = new DateTime(2024, 1, 15, 8, 0, 0, DateTimeKind.Utc),
+                SpecificDate = new DateTimeOffset(2024, 1, 15, 8, 0, 0, TimeSpan.Zero),
+                Time = new TimeOnly(8, 30, 0),
+            },
+        };
+
+        var result = people.AsQueryable().ApplyQueryKitFilter(input).ToList();
+
+        result.Select(x => x.Title).Should().Equal("match");
+    }
+
+    [Fact]
+    public void time_fraction_keeps_microseconds()
+    {
+        var filterExpression = FilterParser.ParseFilter<TestingPerson>("Time == 08:30:00.123456");
+
+        filterExpression.ToDisplayString().Should().Be("x => (x.Time == new Nullable`1(new TimeOnly(8, 30, 0, 123, 456)))");
+    }
+
     private static TResult WithCulture<TResult>(string cultureName, Func<TResult> action)
     {
         var originalCulture = CultureInfo.CurrentCulture;
diff --git a/QueryKit/FilterParser.cs b/QueryKit/FilterParser.cs
index 2a823fe..37bac4d 100644
--- a/QueryKit/FilterParser.cs
+++ b/QueryKit/FilterParser.cs
@@ -195,15 +195,15 @@ private static readonly Parser<string> DoubleQuoteParser
      * DateTime (no offset information): yyyy-MM-ddTHH:mm:ss.ffffff
      * DateTime (in UTC): yyyy-MM-ddTHH:mm:ss.ffffffZ
      */
-    private static readonly Parser<string> TimeFormatParser = Parse.Regex(@"\d{2}:\d{2}:\d{2}").Text();
+    private static readonly Parser<string> TimeFormatParser = Parse.Regex(@"\d{2}:\d{2}:\d{2}(\.\d{1,7})?").Text();
     private static readonly Parser<string> DateTimeTimeParser = Parse.Regex(@"T\d{2}:\d{2}:\d{2}").Text().Optional().Select(x => x.GetOrElse(""));
+    private static readonly Parser<string> DateTimeMicrosParser = Parse.Regex(@"\.\d{1,7}").Text().Optional().Select(x => x.GetOrElse(""));
     private static readonly Parser<string> DateTimeZoneParser = Parse.Regex(@"Z|[+-]\d{2}(:\d{2})?").Text().Optional().Select(x => x.GetOrElse(""));
-    private static readonly Parser<string> DateTimeMicrosParser = Parse.Regex(@"\.\d{1,6}").Text().Optional().Select(x => x.GetOrElse(""));
     private static readonly Parser<string> DateTimeFormatParser =
         from dateFormat in Parse.Regex(@"\d{4}-\d{2}-\d{2}").Text()
         from timeFormat in DateTimeTimeParser
-        from timeZone in DateTimeZoneParser
         from micros in DateTimeMicrosParser
+        from timeZone in DateTimeZoneParser
         select dateFormat + timeFormat + micros + timeZone;
 
     // A number with a '.' decimal point, or with the decimal separator of the current culture.
@@ -557,19 +557,9 @@ private static Expression CreateRightExprFromType(Type leftExprType, string righ
             {
                 var time = TimeOnly.Parse(right, CultureInfo.InvariantCulture);
 
-                int millisecond = 0, microsecond = 0;
-                if (right.Contains('.'))
-                {
-                    var fractionalSeconds = right.Split('.')[1];
-                    if (fractionalSeconds.Length >= 3)
-                    {
-                        millisecond = int.Parse(fractionalSeconds.Substring(0, 3));
-                    }
-                    if (fractionalSeconds.Length >= 6)
-                    {
-                        microsecond = int.Parse(fractionalSeconds.Substring(3, 3));
-                    }
-                }
+                var fractionalTicks = time.Ticks % TimeSpan.TicksPerSecond;
+                var millisecond = (int)(fractionalTicks / TimeSpan.TicksPerMillisecond);
+                var microsecond = (int)(fractionalTicks % TimeSpan.TicksPerMillisecond / 10);
 
                 // One microsecond is 10 ticks. The TimeOnly constructor with microseconds needs .NET 7.
                 var value = new TimeOnly(time.Hour, time.Minute, time.Second, millisecond)

From 43c3d39bd0751df4701441bcc4110589c8790f8d Mon Sep 17 00:00:00 2001
From: Paul DeVito <pdevito3@gmail.com>
Date: Tue, 29 Sep 2026 21:18:14 +0300
Subject: [PATCH 09/13] fix(operators): compare int and decimal properties with
 equals

A property-to-property comparison widens an int property to decimal with a Convert node. The equals and not-equals operators then converted every Convert node to bool, so 'Age == Rating' threw. The bool conversion now applies only to a derived property value boxed to object.
---
 .../Tests/FilterParsingRegressionTests.cs     | 32 +++++++++++++++++++
 .../FilterParsingRegressionTests.cs           | 18 +++++++++++
 QueryKit/Operators/ComparisonOperator.cs      |  8 ++---
 3 files changed, 54 insertions(+), 4 deletions(-)

diff --git a/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs b/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
index c074bd2..ee18982 100644
--- a/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
+++ b/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
@@ -167,4 +167,36 @@ public async Task fractional_seconds_are_kept(string valueFilter)
         // Assert
         people.Select(x => x.Id).Should().Equal(fakePersonOne.Id);
     }
+
+    [Theory]
+    [InlineData("Age == Rating", true)]
+    [InlineData("Rating == Age", true)]
+    [InlineData("Age != Rating", false)]
+    [InlineData("Rating != Age", false)]
+    public async Task int_property_compares_to_decimal_property(string valueFilter, bool expectEqualPerson)
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var title = $"numeric {Guid.NewGuid()}";
+        var fakePersonOne = new FakeTestingPersonBuilder()
+            .WithTitle(title)
+            .WithAge(4)
+            .WithRating(4m)
+            .Build();
+        var fakePersonTwo = new FakeTestingPersonBuilder()
+            .WithTitle(title)
+            .WithAge(4)
+            .WithRating(4.5m)
+            .Build();
+        await testingServiceScope.InsertAsync(fakePersonOne, fakePersonTwo);
+
+        var input = $"""{nameof(TestingPerson.Title)} == "{title}" && {valueFilter}""";
+
+        // Act
+        var queryablePeople = testingServiceScope.DbContext().People;
+        var people = await queryablePeople.ApplyQueryKitFilter(input).ToListAsync();
+
+        // Assert
+        people.Select(x => x.Id).Should().Equal(expectEqualPerson ? fakePersonOne.Id : fakePersonTwo.Id);
+    }
 }
diff --git a/QueryKit.UnitTests/FilterParsingRegressionTests.cs b/QueryKit.UnitTests/FilterParsingRegressionTests.cs
index 2ab027a..76678e7 100644
--- a/QueryKit.UnitTests/FilterParsingRegressionTests.cs
+++ b/QueryKit.UnitTests/FilterParsingRegressionTests.cs
@@ -169,6 +169,24 @@ public void time_fraction_keeps_microseconds()
         filterExpression.ToDisplayString().Should().Be("x => (x.Time == new Nullable`1(new TimeOnly(8, 30, 0, 123, 456)))");
     }
 
+    [Theory]
+    [InlineData("Age == Rating", "equal")]
+    [InlineData("Rating == Age", "equal")]
+    [InlineData("Age != Rating", "different")]
+    [InlineData("Rating != Age", "different")]
+    public void int_property_compares_to_decimal_property(string input, string expectedTitle)
+    {
+        var people = new[]
+        {
+            new TestingPerson { Title = "equal", Age = 4, Rating = 4m },
+            new TestingPerson { Title = "different", Age = 4, Rating = 4.5m },
+        };
+
+        var result = people.AsQueryable().ApplyQueryKitFilter(input).ToList();
+
+        result.Select(x => x.Title).Should().Equal(expectedTitle);
+    }
+
     private static TResult WithCulture<TResult>(string cultureName, Func<TResult> action)
     {
         var originalCulture = CultureInfo.CurrentCulture;
diff --git a/QueryKit/Operators/ComparisonOperator.cs b/QueryKit/Operators/ComparisonOperator.cs
index 0d4e468..6bcd229 100644
--- a/QueryKit/Operators/ComparisonOperator.cs
+++ b/QueryKit/Operators/ComparisonOperator.cs
@@ -222,8 +222,8 @@ public override Expression GetExpression<T>(Expression left, Expression right, T
                 return Expression.AndAlso(nullCheck, caseComparison);
             }
 
-            // for some complex derived expressions
-            if (left.NodeType == ExpressionType.Convert)
+            // A derived property boxes its value to object. Unbox it to bool for a derived bool comparison.
+            if (left.NodeType == ExpressionType.Convert && left.Type == typeof(object))
             {
                 left = Expression.Convert(left, typeof(bool));
             }
@@ -261,8 +261,8 @@ public override Expression GetExpression<T>(Expression left, Expression right, T
                 return Expression.OrElse(nullCheck, caseComparison);
             }
 
-            // for some complex derived expressions
-            if (left.NodeType == ExpressionType.Convert)
+            // A derived property boxes its value to object. Unbox it to bool for a derived bool comparison.
+            if (left.NodeType == ExpressionType.Convert && left.Type == typeof(object))
             {
                 left = Expression.Convert(left, typeof(bool));
             }

From ea69126921cfc542911e7bbdad80b99485bed0e1 Mon Sep 17 00:00:00 2001
From: Paul DeVito <pdevito3@gmail.com>
Date: Tue, 29 Sep 2026 21:21:09 +0300
Subject: [PATCH 10/13] fix(operators): handle null in case-sensitive string
 operators

The case-sensitive @=, _=, and _-= operators and their negations called the string method on a null property. In memory, this threw a NullReferenceException. These operators now add the same null check as the case-insensitive operators, so a null property does not match @=, _=, or _-= and matches their negations. On Postgres, the results do not change.
---
 .../Tests/FilterParsingRegressionTests.cs     | 32 +++++++++++++++++++
 QueryKit.UnitTests/FilterParserTests.cs       | 16 +++++-----
 .../FilterParsingRegressionTests.cs           | 21 ++++++++++++
 QueryKit.UnitTests/OperatorAliasTests.cs      |  2 +-
 QueryKit/Operators/ComparisonOperator.cs      | 30 +++++++++++++----
 5 files changed, 86 insertions(+), 15 deletions(-)

diff --git a/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs b/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
index ee18982..f5156f0 100644
--- a/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
+++ b/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
@@ -199,4 +199,36 @@ public async Task int_property_compares_to_decimal_property(string valueFilter,
         // Assert
         people.Select(x => x.Id).Should().Equal(expectEqualPerson ? fakePersonOne.Id : fakePersonTwo.Id);
     }
+
+    [Theory]
+    [InlineData("""Title @= "am" """, false)]
+    [InlineData("""Title _= "la" """, false)]
+    [InlineData("""Title _-= "mb" """, false)]
+    [InlineData("""Title !@= "am" """, true)]
+    [InlineData("""Title !_= "la" """, true)]
+    [InlineData("""Title !_-= "mb" """, true)]
+    public async Task case_sensitive_string_operator_handles_null_property(string valueFilter, bool expectNullPerson)
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var firstName = $"null title {Guid.NewGuid()}";
+        var fakePersonOne = new FakeTestingPersonBuilder()
+            .WithFirstName(firstName)
+            .WithTitle(null)
+            .Build();
+        var fakePersonTwo = new FakeTestingPersonBuilder()
+            .WithFirstName(firstName)
+            .WithTitle("lamb")
+            .Build();
+        await testingServiceScope.InsertAsync(fakePersonOne, fakePersonTwo);
+
+        var input = $"""{nameof(TestingPerson.FirstName)} == "{firstName}" && {valueFilter}""";
+
+        // Act
+        var queryablePeople = testingServiceScope.DbContext().People;
+        var people = await queryablePeople.ApplyQueryKitFilter(input).ToListAsync();
+
+        // Assert
+        people.Select(x => x.Id).Should().Equal(expectNullPerson ? fakePersonOne.Id : fakePersonTwo.Id);
+    }
 }
diff --git a/QueryKit.UnitTests/FilterParserTests.cs b/QueryKit.UnitTests/FilterParserTests.cs
index 6892b8e..6775090 100644
--- a/QueryKit.UnitTests/FilterParserTests.cs
+++ b/QueryKit.UnitTests/FilterParserTests.cs
@@ -42,7 +42,7 @@ public void complex_with_lots_of_types()
 
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
         filterExpression.ToDisplayString().Should()
-            .Be(""""x => (((((((((x.Title != null) AndAlso x.Title.ToLower().Contains("waffle & chicken".ToLower())) AndAlso (x.Age > 30)) OrElse (x.Id == aa648248-cb69-4217-ac95-d7484795afb2)) OrElse (x.Title == "lamb")) OrElse (x.Title == null)) AndAlso ((x.Age < 18) OrElse ((x.BirthMonth == January) AndAlso x.Title.StartsWith("ally")))) OrElse (x.Rating > 3.5)) OrElse ((x.SpecificDate == new Nullable`1(new DateTimeOffset(637922304030000000, 00:00:00))) AndAlso ((x.Date == new Nullable`1(new DateOnly(2022, 7, 1))) OrElse (x.Time == new Nullable`1(new TimeOnly(0, 0, 3, 0, 0))))))"""");
+            .Be(""""x => (((((((((x.Title != null) AndAlso x.Title.ToLower().Contains("waffle & chicken".ToLower())) AndAlso (x.Age > 30)) OrElse (x.Id == aa648248-cb69-4217-ac95-d7484795afb2)) OrElse (x.Title == "lamb")) OrElse (x.Title == null)) AndAlso ((x.Age < 18) OrElse ((x.BirthMonth == January) AndAlso ((x.Title != null) AndAlso x.Title.StartsWith("ally"))))) OrElse (x.Rating > 3.5)) OrElse ((x.SpecificDate == new Nullable`1(new DateTimeOffset(637922304030000000, 00:00:00))) AndAlso ((x.Date == new Nullable`1(new DateOnly(2022, 7, 1))) OrElse (x.Time == new Nullable`1(new TimeOnly(0, 0, 3, 0, 0))))))"""");
     }
 
     [Fact]
@@ -173,7 +173,7 @@ public void starts_with_operator()
     {
         var input = """Title _= "lam" """;
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
-        filterExpression.ToDisplayString().Should().Be("x => x.Title.StartsWith(\"lam\")");
+        filterExpression.ToDisplayString().Should().Be("x => ((x.Title != null) AndAlso x.Title.StartsWith(\"lam\"))");
     }
 
     [Fact]
@@ -189,7 +189,7 @@ public void ends_with_operator()
     {
         var input = """Title _-= "b" """;
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
-        filterExpression.ToDisplayString().Should().Be("x => x.Title.EndsWith(\"b\")");
+        filterExpression.ToDisplayString().Should().Be("x => ((x.Title != null) AndAlso x.Title.EndsWith(\"b\"))");
     }
 
     [Fact]
@@ -372,7 +372,7 @@ public void multiple_properties_and_operators()
     {
         var input = """Title _= "lamb" && Age >= 25 && Rating < 4.5 && SpecificDate <= 2022-07-01T00:00:03Z && Time == 00:00:03""";
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
-        filterExpression.ToDisplayString().Should().Be("x => ((((x.Title.StartsWith(\"lamb\") AndAlso (x.Age >= 25)) AndAlso (x.Rating < 4.5)) AndAlso (x.SpecificDate <= new Nullable`1(new DateTimeOffset(637922304030000000, 00:00:00)))) AndAlso (x.Time == new Nullable`1(new TimeOnly(0, 0, 3, 0, 0))))");
+        filterExpression.ToDisplayString().Should().Be("x => ((((((x.Title != null) AndAlso x.Title.StartsWith(\"lamb\")) AndAlso (x.Age >= 25)) AndAlso (x.Rating < 4.5)) AndAlso (x.SpecificDate <= new Nullable`1(new DateTimeOffset(637922304030000000, 00:00:00)))) AndAlso (x.Time == new Nullable`1(new TimeOnly(0, 0, 3, 0, 0))))");
     }
 
     [Fact]
@@ -380,7 +380,7 @@ public void complex_filter_with_nested_parentheses()
     {
         var input = """(Title == "lamb" && ((Age >= 25 && Rating < 4.5) || (SpecificDate <= 2022-07-01T00:00:03Z && Time == 00:00:03)) && (Favorite == true || Email.Value _= "example"))""";
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
-        filterExpression.ToDisplayString().Should().Be("""x => (((x.Title == "lamb") AndAlso (((x.Age >= 25) AndAlso (x.Rating < 4.5)) OrElse ((x.SpecificDate <= new Nullable`1(new DateTimeOffset(637922304030000000, 00:00:00))) AndAlso (x.Time == new Nullable`1(new TimeOnly(0, 0, 3, 0, 0)))))) AndAlso ((x.Favorite == True) OrElse x.Email.Value.StartsWith("example")))""");
+        filterExpression.ToDisplayString().Should().Be("""x => (((x.Title == "lamb") AndAlso (((x.Age >= 25) AndAlso (x.Rating < 4.5)) OrElse ((x.SpecificDate <= new Nullable`1(new DateTimeOffset(637922304030000000, 00:00:00))) AndAlso (x.Time == new Nullable`1(new TimeOnly(0, 0, 3, 0, 0)))))) AndAlso ((x.Favorite == True) OrElse ((x.Email.Value != null) AndAlso x.Email.Value.StartsWith("example"))))""");
     }
 
     [Fact]
@@ -412,7 +412,7 @@ public void ends_with_works()
     {
         var input = """Title _-= "lamb" """;
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
-        filterExpression.ToDisplayString().Should().Be("x => x.Title.EndsWith(\"lamb\")");
+        filterExpression.ToDisplayString().Should().Be("x => ((x.Title != null) AndAlso x.Title.EndsWith(\"lamb\"))");
     }
 
     [Fact]
@@ -428,7 +428,7 @@ public void contains_is_case_sensitive()
     {
         var input = """Title @= "lamb" """;
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
-        filterExpression.ToDisplayString().Should().Be("x => x.Title.Contains(\"lamb\")");
+        filterExpression.ToDisplayString().Should().Be("x => ((x.Title != null) AndAlso x.Title.Contains(\"lamb\"))");
     }
 
     [Fact]
@@ -436,7 +436,7 @@ public void not_contains_works()
     {
         var input = """Title !@= "lamb" """;
         var filterExpression = FilterParser.ParseFilter<TestingPerson>(input);
-        filterExpression.ToDisplayString().Should().Be("x => Not(x.Title.Contains(\"lamb\"))");
+        filterExpression.ToDisplayString().Should().Be("x => ((x.Title == null) OrElse Not(x.Title.Contains(\"lamb\")))");
     }
 
     [Fact]
diff --git a/QueryKit.UnitTests/FilterParsingRegressionTests.cs b/QueryKit.UnitTests/FilterParsingRegressionTests.cs
index 76678e7..2404648 100644
--- a/QueryKit.UnitTests/FilterParsingRegressionTests.cs
+++ b/QueryKit.UnitTests/FilterParsingRegressionTests.cs
@@ -187,6 +187,27 @@ public void int_property_compares_to_decimal_property(string input, string expec
         result.Select(x => x.Title).Should().Equal(expectedTitle);
     }
 
+    [Theory]
+    [InlineData("""Title @= "am" """, new[] { "lamb" })]
+    [InlineData("""Title _= "la" """, new[] { "lamb" })]
+    [InlineData("""Title _-= "mb" """, new[] { "lamb" })]
+    [InlineData("""Title !@= "am" """, new[] { "null", "other" })]
+    [InlineData("""Title !_= "la" """, new[] { "null", "other" })]
+    [InlineData("""Title !_-= "mb" """, new[] { "null", "other" })]
+    public void case_sensitive_string_operator_handles_null_property(string input, string[] expectedFirstNames)
+    {
+        var people = new[]
+        {
+            new TestingPerson { Title = null, FirstName = "null" },
+            new TestingPerson { Title = "lamb", FirstName = "lamb" },
+            new TestingPerson { Title = "other", FirstName = "other" },
+        };
+
+        var result = people.AsQueryable().ApplyQueryKitFilter(input).ToList();
+
+        result.Select(x => x.FirstName).Should().Equal(expectedFirstNames);
+    }
+
     private static TResult WithCulture<TResult>(string cultureName, Func<TResult> action)
     {
         var originalCulture = CultureInfo.CurrentCulture;
diff --git a/QueryKit.UnitTests/OperatorAliasTests.cs b/QueryKit.UnitTests/OperatorAliasTests.cs
index 8a799c5..1751706 100644
--- a/QueryKit.UnitTests/OperatorAliasTests.cs
+++ b/QueryKit.UnitTests/OperatorAliasTests.cs
@@ -153,7 +153,7 @@ public void can_use_contains_not_case_sensitive()
             config.CaseInsensitiveAppendix = "$";
         });
         var filterExpression = FilterParser.ParseFilter<Recipe>(input, config);
-        filterExpression.ToDisplayString().Should().Be($"""x => x.Title.Contains("titilating")""");
+        filterExpression.ToDisplayString().Should().Be($"""x => ((x.Title != null) AndAlso x.Title.Contains("titilating"))""");
     }
 
     [Fact]
diff --git a/QueryKit/Operators/ComparisonOperator.cs b/QueryKit/Operators/ComparisonOperator.cs
index 6bcd229..91db9e9 100644
--- a/QueryKit/Operators/ComparisonOperator.cs
+++ b/QueryKit/Operators/ComparisonOperator.cs
@@ -383,7 +383,10 @@ public override Expression GetExpression<T>(Expression left, Expression right, T
                 return Expression.AndAlso(nullCheck, containsCall);
             }
 
-            return Expression.Call(left, typeof(string).GetMethod("Contains", new[] { typeof(string) })!, right);
+            // null doesn't contain anything, so we need: left != null && left.Contains(right)
+            return Expression.AndAlso(
+                Expression.NotEqual(left, Expression.Constant(null, typeof(string))),
+                Expression.Call(left, typeof(string).GetMethod("Contains", new[] { typeof(string) })!, right));
         }
     }
 
@@ -415,7 +418,10 @@ public override Expression GetExpression<T>(Expression left, Expression right, T
                 return Expression.AndAlso(nullCheck, startsWithCall);
             }
 
-            return Expression.Call(left, typeof(string).GetMethod("StartsWith", new[] { typeof(string) })!, right);
+            // null doesn't start with anything, so we need: left != null && left.StartsWith(right)
+            return Expression.AndAlso(
+                Expression.NotEqual(left, Expression.Constant(null, typeof(string))),
+                Expression.Call(left, typeof(string).GetMethod("StartsWith", new[] { typeof(string) })!, right));
         }
     }
 
@@ -447,7 +453,10 @@ public override Expression GetExpression<T>(Expression left, Expression right, T
                 return Expression.AndAlso(nullCheck, endsWithCall);
             }
 
-            return Expression.Call(left, typeof(string).GetMethod("EndsWith", new[] { typeof(string) })!, right);
+            // null doesn't end with anything, so we need: left != null && left.EndsWith(right)
+            return Expression.AndAlso(
+                Expression.NotEqual(left, Expression.Constant(null, typeof(string))),
+                Expression.Call(left, typeof(string).GetMethod("EndsWith", new[] { typeof(string) })!, right));
         }
     }
 
@@ -479,7 +488,10 @@ public override Expression GetExpression<T>(Expression left, Expression right, T
                 return Expression.OrElse(nullCheck, notContainsCall);
             }
 
-            return Expression.Not(Expression.Call(left, typeof(string).GetMethod("Contains", new[] { typeof(string) })!, right));
+            // null doesn't contain anything, so it should be included: left == null || !left.Contains(right)
+            return Expression.OrElse(
+                Expression.Equal(left, Expression.Constant(null, typeof(string))),
+                Expression.Not(Expression.Call(left, typeof(string).GetMethod("Contains", new[] { typeof(string) })!, right)));
         }
     }
 
@@ -511,7 +523,10 @@ public override Expression GetExpression<T>(Expression left, Expression right, T
                 return Expression.OrElse(nullCheck, notStartsWithCall);
             }
 
-            return Expression.Not(Expression.Call(left, typeof(string).GetMethod("StartsWith", new[] { typeof(string) })!, right));
+            // null doesn't start with anything, so it should be included: left == null || !left.StartsWith(right)
+            return Expression.OrElse(
+                Expression.Equal(left, Expression.Constant(null, typeof(string))),
+                Expression.Not(Expression.Call(left, typeof(string).GetMethod("StartsWith", new[] { typeof(string) })!, right)));
         }
     }
 
@@ -543,7 +558,10 @@ public override Expression GetExpression<T>(Expression left, Expression right, T
                 return Expression.OrElse(nullCheck, notEndsWithCall);
             }
 
-            return Expression.Not(Expression.Call(left, typeof(string).GetMethod("EndsWith", new[] { typeof(string) })!, right));
+            // null doesn't end with anything, so it should be included: left == null || !left.EndsWith(right)
+            return Expression.OrElse(
+                Expression.Equal(left, Expression.Constant(null, typeof(string))),
+                Expression.Not(Expression.Call(left, typeof(string).GetMethod("EndsWith", new[] { typeof(string) })!, right)));
         }
     }
 

From 0cda00996aa3cfe3c50c7c203ac7400daa44db73 Mon Sep 17 00:00:00 2001
From: Paul DeVito <pdevito3@gmail.com>
Date: Tue, 29 Sep 2026 21:27:43 +0300
Subject: [PATCH 11/13] fix(operators): pass usesAll through the operator
 factories

The public ComparisonOperator factories accepted a usesAll argument but did not give it to the constructor. An operator from a factory always matched any item of a collection, never every item. The factories now pass usesAll through.
---
 .../Tests/FilterParsingRegressionTests.cs     | 36 ++++++++++++++
 .../FilterParsingRegressionTests.cs           | 41 ++++++++++++++++
 QueryKit/Operators/ComparisonOperator.cs      | 48 +++++++++----------
 3 files changed, 101 insertions(+), 24 deletions(-)

diff --git a/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs b/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
index f5156f0..8ce9c71 100644
--- a/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
+++ b/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
@@ -1,11 +1,16 @@
 namespace QueryKit.IntegrationTests.Tests;
 
 using System.Globalization;
+using System.Linq.Expressions;
 using Configuration;
 using FluentAssertions;
 using Microsoft.EntityFrameworkCore;
+using Operators;
 using SharedTestingHelper.Fakes;
+using SharedTestingHelper.Fakes.Ingredients;
+using SharedTestingHelper.Fakes.Recipes;
 using WebApiTestProject.Entities;
+using WebApiTestProject.Entities.Recipes;
 
 public class FilterParsingRegressionTests : TestBase
 {
@@ -231,4 +236,35 @@ public async Task case_sensitive_string_operator_handles_null_property(string va
         // Assert
         people.Select(x => x.Id).Should().Equal(expectNullPerson ? fakePersonOne.Id : fakePersonTwo.Id);
     }
+
+    [Fact]
+    public async Task comparison_operator_factory_with_uses_all_matches_every_item()
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var name = $"waffle {Guid.NewGuid()}";
+        var fakeRecipeOne = new FakeRecipeBuilder().Build();
+        fakeRecipeOne.AddIngredient(new FakeIngredientBuilder().WithName(name).Build());
+        fakeRecipeOne.AddIngredient(new FakeIngredientBuilder().WithName(name).Build());
+        var fakeRecipeTwo = new FakeRecipeBuilder().Build();
+        fakeRecipeTwo.AddIngredient(new FakeIngredientBuilder().WithName(name).Build());
+        fakeRecipeTwo.AddIngredient(new FakeIngredientBuilder().WithName($"other {Guid.NewGuid()}").Build());
+        await testingServiceScope.InsertAsync(fakeRecipeOne, fakeRecipeTwo);
+
+        Expression<Func<Recipe, IEnumerable<string>>> ingredientNames = x => x.Ingredients.Select(y => y.Name);
+        var body = ComparisonOperator.EqualsOperator(usesAll: true)
+            .GetExpression<Recipe>(ingredientNames.Body, Expression.Constant(name), null);
+        var filterExpression = Expression.Lambda<Func<Recipe, bool>>(body, ingredientNames.Parameters);
+        var recipeIds = new[] { fakeRecipeOne.Id, fakeRecipeTwo.Id };
+
+        // Act
+        var queryableRecipes = testingServiceScope.DbContext().Recipes;
+        var recipes = await queryableRecipes
+            .Where(x => recipeIds.Contains(x.Id))
+            .Where(filterExpression)
+            .ToListAsync();
+
+        // Assert
+        recipes.Select(x => x.Id).Should().Equal(fakeRecipeOne.Id);
+    }
 }
diff --git a/QueryKit.UnitTests/FilterParsingRegressionTests.cs b/QueryKit.UnitTests/FilterParsingRegressionTests.cs
index 2404648..7be16ab 100644
--- a/QueryKit.UnitTests/FilterParsingRegressionTests.cs
+++ b/QueryKit.UnitTests/FilterParsingRegressionTests.cs
@@ -1,9 +1,13 @@
 namespace QueryKit.UnitTests;
 
 using System.Globalization;
+using System.Linq.Expressions;
+using System.Reflection;
 using Exceptions;
 using FluentAssertions;
+using Operators;
 using WebApiTestProject.Entities;
+using WebApiTestProject.Entities.Recipes;
 
 public class FilterParsingRegressionTests
 {
@@ -208,6 +212,43 @@ public void case_sensitive_string_operator_handles_null_property(string input, s
         result.Select(x => x.FirstName).Should().Equal(expectedFirstNames);
     }
 
+    public static IEnumerable<object[]> ComparisonOperatorFactories() =>
+        typeof(ComparisonOperator).GetMethods(BindingFlags.Public | BindingFlags.Static)
+            .Where(x => x.ReturnType == typeof(ComparisonOperator)
+                && x.GetParameters().Select(p => p.Name).SequenceEqual(new[] { "caseInsensitive", "usesAll" }))
+            .Select(x => new object[] { x.Name });
+
+    [Theory]
+    [MemberData(nameof(ComparisonOperatorFactories))]
+    public void comparison_operator_factory_keeps_uses_all(string factoryName)
+    {
+        var factory = typeof(ComparisonOperator).GetMethod(factoryName, BindingFlags.Public | BindingFlags.Static)!;
+
+        var comparisonOperator = (ComparisonOperator)factory.Invoke(null, new object[] { true, true })!;
+
+        comparisonOperator.UsesAll.Should().BeTrue();
+        comparisonOperator.CaseInsensitive.Should().BeTrue();
+    }
+
+    [Fact]
+    public void comparison_operator_factory_has_one_test_case_per_operator_type()
+    {
+        ComparisonOperatorFactories().Should().HaveCount(24);
+    }
+
+    [Fact]
+    public void comparison_operator_factory_with_uses_all_builds_all_expression()
+    {
+        Expression<Func<Recipe, IEnumerable<string>>> ingredientNames = x => x.Ingredients.Select(y => y.Name);
+
+        var body = ComparisonOperator.EqualsOperator(usesAll: true)
+            .GetExpression<Recipe>(ingredientNames.Body, Expression.Constant("waffle"), null);
+        var filterExpression = Expression.Lambda<Func<Recipe, bool>>(body, ingredientNames.Parameters);
+
+        filterExpression.ToDisplayString().Should()
+            .Be(FilterParser.ParseFilter<Recipe>("""Ingredients.Name %== "waffle" """).ToDisplayString());
+    }
+
     private static TResult WithCulture<TResult>(string cultureName, Func<TResult> action)
     {
         var originalCulture = CultureInfo.CurrentCulture;
diff --git a/QueryKit/Operators/ComparisonOperator.cs b/QueryKit/Operators/ComparisonOperator.cs
index 91db9e9..97c959a 100644
--- a/QueryKit/Operators/ComparisonOperator.cs
+++ b/QueryKit/Operators/ComparisonOperator.cs
@@ -34,30 +34,30 @@ public abstract class ComparisonOperator : SmartEnum<ComparisonOperator>
     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);
-    public static ComparisonOperator GreaterThanOperator(bool caseInsensitive = false, bool usesAll = false) => new GreaterThanType(caseInsensitive);
-    public static ComparisonOperator LessThanOperator(bool caseInsensitive = false, bool usesAll = false) => new LessThanType(caseInsensitive);
-    public static ComparisonOperator GreaterThanOrEqualOperator(bool caseInsensitive = false, bool usesAll = false) => new GreaterThanOrEqualType(caseInsensitive);
-    public static ComparisonOperator LessThanOrEqualOperator(bool caseInsensitive = false, bool usesAll = false) => new LessThanOrEqualType(caseInsensitive);
-    public static ComparisonOperator ContainsOperator(bool caseInsensitive = false, bool usesAll = false) => new ContainsType(caseInsensitive);
-    public static ComparisonOperator StartsWithOperator(bool caseInsensitive = false, bool usesAll = false) => new StartsWithType(caseInsensitive);
-    public static ComparisonOperator EndsWithOperator(bool caseInsensitive = false, bool usesAll = false) => new EndsWithType(caseInsensitive);
-    public static ComparisonOperator NotContainsOperator(bool caseInsensitive = false, bool usesAll = false) => new NotContainsType(caseInsensitive);
-    public static ComparisonOperator NotStartsWithOperator(bool caseInsensitive = false, bool usesAll = false) => new NotStartsWithType(caseInsensitive);
-    public static ComparisonOperator NotEndsWithOperator(bool caseInsensitive = false, bool usesAll = false) => new NotEndsWithType(caseInsensitive);
-    public static ComparisonOperator InOperator(bool caseInsensitive = false, bool usesAll = false) => new InType(caseInsensitive);
-    public static ComparisonOperator NotInOperator(bool caseInsensitive = false, bool usesAll = false) => new NotInType(caseInsensitive);
-    public static ComparisonOperator SoundsLikeOperator(bool caseInsensitive = false, bool usesAll = false) => new SoundsLikeType(caseInsensitive);
-    public static ComparisonOperator DoesNotSoundLikeOperator(bool caseInsensitive = false, bool usesAll = false) => new DoesNotSoundLikeType(caseInsensitive);
-    public static ComparisonOperator HasCountEqualToOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountEqualToType(caseInsensitive);
-    public static ComparisonOperator HasCountNotEqualToOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountNotEqualToType(caseInsensitive);
-    public static ComparisonOperator HasCountGreaterThanOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountGreaterThanType(caseInsensitive);
-    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 EqualsOperator(bool caseInsensitive = false, bool usesAll = false) => new EqualsType(caseInsensitive, usesAll);
+    public static ComparisonOperator NotEqualsOperator(bool caseInsensitive = false, bool usesAll = false) => new NotEqualsType(caseInsensitive, usesAll);
+    public static ComparisonOperator GreaterThanOperator(bool caseInsensitive = false, bool usesAll = false) => new GreaterThanType(caseInsensitive, usesAll);
+    public static ComparisonOperator LessThanOperator(bool caseInsensitive = false, bool usesAll = false) => new LessThanType(caseInsensitive, usesAll);
+    public static ComparisonOperator GreaterThanOrEqualOperator(bool caseInsensitive = false, bool usesAll = false) => new GreaterThanOrEqualType(caseInsensitive, usesAll);
+    public static ComparisonOperator LessThanOrEqualOperator(bool caseInsensitive = false, bool usesAll = false) => new LessThanOrEqualType(caseInsensitive, usesAll);
+    public static ComparisonOperator ContainsOperator(bool caseInsensitive = false, bool usesAll = false) => new ContainsType(caseInsensitive, usesAll);
+    public static ComparisonOperator StartsWithOperator(bool caseInsensitive = false, bool usesAll = false) => new StartsWithType(caseInsensitive, usesAll);
+    public static ComparisonOperator EndsWithOperator(bool caseInsensitive = false, bool usesAll = false) => new EndsWithType(caseInsensitive, usesAll);
+    public static ComparisonOperator NotContainsOperator(bool caseInsensitive = false, bool usesAll = false) => new NotContainsType(caseInsensitive, usesAll);
+    public static ComparisonOperator NotStartsWithOperator(bool caseInsensitive = false, bool usesAll = false) => new NotStartsWithType(caseInsensitive, usesAll);
+    public static ComparisonOperator NotEndsWithOperator(bool caseInsensitive = false, bool usesAll = false) => new NotEndsWithType(caseInsensitive, usesAll);
+    public static ComparisonOperator InOperator(bool caseInsensitive = false, bool usesAll = false) => new InType(caseInsensitive, usesAll);
+    public static ComparisonOperator NotInOperator(bool caseInsensitive = false, bool usesAll = false) => new NotInType(caseInsensitive, usesAll);
+    public static ComparisonOperator SoundsLikeOperator(bool caseInsensitive = false, bool usesAll = false) => new SoundsLikeType(caseInsensitive, usesAll);
+    public static ComparisonOperator DoesNotSoundLikeOperator(bool caseInsensitive = false, bool usesAll = false) => new DoesNotSoundLikeType(caseInsensitive, usesAll);
+    public static ComparisonOperator HasCountEqualToOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountEqualToType(caseInsensitive, usesAll);
+    public static ComparisonOperator HasCountNotEqualToOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountNotEqualToType(caseInsensitive, usesAll);
+    public static ComparisonOperator HasCountGreaterThanOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountGreaterThanType(caseInsensitive, usesAll);
+    public static ComparisonOperator HasCountLessThanOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountLessThanType(caseInsensitive, usesAll);
+    public static ComparisonOperator HasCountGreaterThanOrEqualOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountGreaterThanOrEqualType(caseInsensitive, usesAll);
+    public static ComparisonOperator HasCountLessThanOrEqualOperator(bool caseInsensitive = false, bool usesAll = false) => new HasCountLessThanOrEqualType(caseInsensitive, usesAll);
+    public static ComparisonOperator HasOperator(bool caseInsensitive = false, bool usesAll = false) => new HasType(caseInsensitive, usesAll);
+    public static ComparisonOperator DoesNotHaveOperator(bool caseInsensitive = false, bool usesAll = false) => new DoesNotHaveType(caseInsensitive, usesAll);
     
     public static ComparisonOperator GetByOperatorString(string op, bool caseInsensitive = false, bool usesAll = false)
     {

From 0048d752f47911708469c55e461ab0d803b76ff3 Mon Sep 17 00:00:00 2001
From: Paul DeVito <pdevito3@gmail.com>
Date: Tue, 29 Sep 2026 22:56:13 +0300
Subject: [PATCH 12/13] fix(sort): read the sort direction after more than one
 space

The sort parser split each clause on every white-space character, so 'Age  desc' gave an empty direction and threw ArgumentException. The parser now ignores empty parts, so extra spaces or a tab before the direction work.
---
 .../Tests/FilterParsingRegressionTests.cs     | 27 +++++++++++++++++++
 .../FilterParsingRegressionTests.cs           | 17 ++++++++++++
 QueryKit/SortParser.cs                        |  4 +--
 3 files changed, 46 insertions(+), 2 deletions(-)

diff --git a/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs b/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
index 8ce9c71..ca94c82 100644
--- a/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
+++ b/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
@@ -267,4 +267,31 @@ public async Task comparison_operator_factory_with_uses_all_matches_every_item()
         // Assert
         recipes.Select(x => x.Id).Should().Equal(fakeRecipeOne.Id);
     }
+
+    [Fact]
+    public async Task sort_direction_after_double_space_is_read()
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var title = $"sort {Guid.NewGuid()}";
+        var fakePersonOne = new FakeTestingPersonBuilder()
+            .WithTitle(title)
+            .WithAge(20)
+            .Build();
+        var fakePersonTwo = new FakeTestingPersonBuilder()
+            .WithTitle(title)
+            .WithAge(40)
+            .Build();
+        await testingServiceScope.InsertAsync(fakePersonOne, fakePersonTwo);
+
+        // Act
+        var queryablePeople = testingServiceScope.DbContext().People;
+        var people = await queryablePeople
+            .Where(x => x.Title == title)
+            .ApplyQueryKitSort("Age  desc")
+            .ToListAsync();
+
+        // Assert
+        people.Select(x => x.Id).Should().Equal(fakePersonTwo.Id, fakePersonOne.Id);
+    }
 }
diff --git a/QueryKit.UnitTests/FilterParsingRegressionTests.cs b/QueryKit.UnitTests/FilterParsingRegressionTests.cs
index 7be16ab..d12c0cd 100644
--- a/QueryKit.UnitTests/FilterParsingRegressionTests.cs
+++ b/QueryKit.UnitTests/FilterParsingRegressionTests.cs
@@ -249,6 +249,23 @@ public void comparison_operator_factory_with_uses_all_builds_all_expression()
             .Be(FilterParser.ParseFilter<Recipe>("""Ingredients.Name %== "waffle" """).ToDisplayString());
     }
 
+    [Theory]
+    [InlineData("Age  desc")]
+    [InlineData("Age   desc")]
+    [InlineData("Age\tdesc")]
+    public void sort_direction_after_extra_white_space_is_read(string input)
+    {
+        var people = new[]
+        {
+            new TestingPerson { Title = "young", Age = 20 },
+            new TestingPerson { Title = "old", Age = 40 },
+        };
+
+        var result = people.AsQueryable().ApplyQueryKitSort(input).ToList();
+
+        result.Select(x => x.Title).Should().Equal("old", "young");
+    }
+
     private static TResult WithCulture<TResult>(string cultureName, Func<TResult> action)
     {
         var originalCulture = CultureInfo.CurrentCulture;
diff --git a/QueryKit/SortParser.cs b/QueryKit/SortParser.cs
index af1c5f6..26c0280 100644
--- a/QueryKit/SortParser.cs
+++ b/QueryKit/SortParser.cs
@@ -40,9 +40,9 @@ public static List<SortExpressionInfo<T>> ParseSort<T>(string input, IQueryKitCo
 
     private static SortExpressionInfo<T> CreateSortExpression<T>(string sortClause, IQueryKitConfiguration? config = null)
     {
-        var parts = sortClause.Split();
+        var parts = sortClause.Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries);
 
-        var propertyName = parts[0];
+        var propertyName = parts.Length > 0 ? parts[0] : sortClause;
         var direction = parts.Length > 1 ? parts[1].ToLowerInvariant() : Ascending;
         if (sortClause.StartsWith("-"))
         {

From 253370f63db4bebdfe747fc482734b2a56cb195c Mon Sep 17 00:00:00 2001
From: Paul DeVito <pdevito3@gmail.com>
Date: Tue, 29 Sep 2026 21:58:27 +0300
Subject: [PATCH 13/13] test(filter): cover count less-than-or-equal, has, and
 query kit data

No test used `#<=` or `ApplyQueryKit(QueryKitData)`, and no test asserted the returned rows for `^$`. The new tests assert the expression and the returned rows for `#<=`, the returned rows for `^$`, `^$*`, and `%^$`, and apply a filter, a sort, and a query name through QueryKitData on memory and Postgres.
---
 .../Tests/DatabaseFilteringTests.cs           | 56 +++++++++++++++++++
 .../Tests/FilterParsingRegressionTests.cs     | 26 +++++++++
 .../EnumerableFilteringTests.cs               | 27 +++++++++
 QueryKit.UnitTests/FilterParserTests.cs       |  9 +++
 .../FilterParsingRegressionTests.cs           | 20 +++++++
 5 files changed, 138 insertions(+)

diff --git a/QueryKit.IntegrationTests/Tests/DatabaseFilteringTests.cs b/QueryKit.IntegrationTests/Tests/DatabaseFilteringTests.cs
index 8846e2c..8d3fd32 100644
--- a/QueryKit.IntegrationTests/Tests/DatabaseFilteringTests.cs
+++ b/QueryKit.IntegrationTests/Tests/DatabaseFilteringTests.cs
@@ -311,6 +311,31 @@ public async Task can_filter_by_string_for_collection_with_count()
         recipes.Count.Should().Be(1);
         recipes[0].Id.Should().Be(fakeRecipeOne.Id);
     }
+
+    [Fact]
+    public async Task can_filter_by_collection_count_less_than_or_equal()
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var prefix = $"count {Guid.NewGuid()} ";
+        var recipeWithNone = new FakeRecipeBuilder().WithTitle($"{prefix}none").Build();
+        var recipeWithOne = new FakeRecipeBuilder().WithTitle($"{prefix}one").Build();
+        recipeWithOne.AddIngredient(new FakeIngredientBuilder().Build());
+        var recipeWithTwo = new FakeRecipeBuilder().WithTitle($"{prefix}two").Build();
+        recipeWithTwo.AddIngredient(new FakeIngredientBuilder().Build());
+        recipeWithTwo.AddIngredient(new FakeIngredientBuilder().Build());
+        await testingServiceScope.InsertAsync(recipeWithNone, recipeWithOne, recipeWithTwo);
+
+        // Act
+        var queryableRecipes = testingServiceScope.DbContext().Recipes;
+        var recipes = await queryableRecipes
+            .Where(x => x.Title.StartsWith(prefix))
+            .ApplyQueryKitFilter("Ingredients #<= 1")
+            .ToListAsync();
+
+        // Assert
+        recipes.Select(x => x.Id).Should().BeEquivalentTo(new[] { recipeWithNone.Id, recipeWithOne.Id });
+    }
     
     [Fact]
     public async Task can_filter_by_string_for_collection_contains()
@@ -4259,4 +4284,35 @@ public async Task bare_property_name_on_the_right_is_still_a_property_to_propert
         people.Should().ContainSingle(p => p.Id == fakePersonOne.Id);
     }
 
+    [Fact]
+    public async Task can_apply_query_kit_data()
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var prefix = $"data {Guid.NewGuid()} ";
+        var low = new FakeRecipeBuilder().WithTitle($"{prefix}low").WithRating(1).Build();
+        var high = new FakeRecipeBuilder().WithTitle($"{prefix}high").WithRating(5).Build();
+        var middle = new FakeRecipeBuilder().WithTitle($"{prefix}middle").WithRating(3).Build();
+        await testingServiceScope.InsertAsync(low, high, middle);
+
+        var queryKitData = new QueryKitData
+        {
+            Filters = "score >= 3",
+            SortOrder = "score desc",
+            Configuration = new QueryKitConfiguration(config =>
+            {
+                config.Property<Recipe>(x => x.Rating).HasQueryName("score");
+            })
+        };
+
+        // Act
+        var queryableRecipes = testingServiceScope.DbContext().Recipes;
+        var recipes = await queryableRecipes
+            .Where(x => x.Title.StartsWith(prefix))
+            .ApplyQueryKit(queryKitData)
+            .ToListAsync();
+
+        // Assert
+        recipes.Select(x => x.Id).Should().Equal(high.Id, middle.Id);
+    }
 }
diff --git a/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs b/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
index ca94c82..f192c3d 100644
--- a/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
+++ b/QueryKit.IntegrationTests/Tests/FilterParsingRegressionTests.cs
@@ -294,4 +294,30 @@ public async Task sort_direction_after_double_space_is_read()
         // Assert
         people.Select(x => x.Id).Should().Equal(fakePersonTwo.Id, fakePersonOne.Id);
     }
+
+    [Theory]
+    [InlineData("""Tags ^$ "sweet" """, new[] { "pancakes" })]
+    [InlineData("""Tags ^$* "WINNER" """, new[] { "bread" })]
+    [InlineData("""Tags %^$ "dinner" """, new[] { "stew", "water" })]
+    public async Task has_returns_matching_rows(string input, string[] expectedTitles)
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var prefix = $"tags {Guid.NewGuid()} ";
+        var pancakes = new FakeRecipeBuilder().WithTitle($"{prefix}pancakes").Build().SetTags(["breakfast", "sweet"]);
+        var stew = new FakeRecipeBuilder().WithTitle($"{prefix}stew").Build().SetTags(["dinner"]);
+        var bread = new FakeRecipeBuilder().WithTitle($"{prefix}bread").Build().SetTags(["bread", "Winner"]);
+        var water = new FakeRecipeBuilder().WithTitle($"{prefix}water").Build().SetTags([]);
+        await testingServiceScope.InsertAsync(pancakes, stew, bread, water);
+
+        // Act
+        var queryableRecipes = testingServiceScope.DbContext().Recipes;
+        var recipes = await queryableRecipes
+            .Where(x => x.Title.StartsWith(prefix))
+            .ApplyQueryKitFilter(input)
+            .ToListAsync();
+
+        // Assert
+        recipes.Select(x => x.Title[prefix.Length..]).Should().BeEquivalentTo(expectedTitles);
+    }
 }
diff --git a/QueryKit.UnitTests/EnumerableFilteringTests.cs b/QueryKit.UnitTests/EnumerableFilteringTests.cs
index 2a3478d..dc2d1b3 100644
--- a/QueryKit.UnitTests/EnumerableFilteringTests.cs
+++ b/QueryKit.UnitTests/EnumerableFilteringTests.cs
@@ -1,6 +1,7 @@
 namespace QueryKit.UnitTests;
 
 using FluentAssertions;
+using QueryKit.Configuration;
 using QueryKit.WebApiTestProject.Entities.Recipes;
 using SharedTestingHelper.Fakes.Recipes;
 
@@ -232,6 +233,32 @@ public void bare_property_name_on_the_right_is_still_a_property_to_property_comp
         result[0].Id.Should().Be(1);
     }
 
+    [Fact]
+    public void can_apply_query_kit_data_to_enumerable()
+    {
+        // Arrange
+        var low = new FakeRecipeBuilder().WithTitle("low").WithRating(1).Build();
+        var high = new FakeRecipeBuilder().WithTitle("high").WithRating(5).Build();
+        var middle = new FakeRecipeBuilder().WithTitle("middle").WithRating(3).Build();
+        var listOfRecipes = new List<Recipe> { low, high, middle };
+
+        var queryKitData = new QueryKitData
+        {
+            Filters = "score >= 3",
+            SortOrder = "score desc",
+            Configuration = new QueryKitConfiguration(config =>
+            {
+                config.Property<Recipe>(x => x.Rating).HasQueryName("score");
+            })
+        };
+
+        // Act
+        var result = listOfRecipes.ApplyQueryKit(queryKitData).ToList();
+
+        // Assert
+        result.Select(x => x.Title).Should().Equal("high", "middle");
+    }
+
     private class PersonWithNullableEmail
     {
         public string Name { get; set; } = null!;
diff --git a/QueryKit.UnitTests/FilterParserTests.cs b/QueryKit.UnitTests/FilterParserTests.cs
index 6775090..420ec16 100644
--- a/QueryKit.UnitTests/FilterParserTests.cs
+++ b/QueryKit.UnitTests/FilterParserTests.cs
@@ -725,6 +725,15 @@ public void collection_has_operator_greater_than_equal()
             .Be(""""x => (x.Ingredients.Count() >= 0)"""");
     }
 
+    [Fact]
+    public void collection_has_operator_less_than_equal()
+    {
+        var input = """"Ingredients #<= 1"""";
+        var filterExpression = FilterParser.ParseFilter<Recipe>(input);
+        filterExpression.ToDisplayString().Should()
+            .Be(""""x => (x.Ingredients.Count() <= 1)"""");
+    }
+
     [Fact]
     public void primitive_collection_has()
     {
diff --git a/QueryKit.UnitTests/FilterParsingRegressionTests.cs b/QueryKit.UnitTests/FilterParsingRegressionTests.cs
index d12c0cd..2116f59 100644
--- a/QueryKit.UnitTests/FilterParsingRegressionTests.cs
+++ b/QueryKit.UnitTests/FilterParsingRegressionTests.cs
@@ -6,6 +6,7 @@ namespace QueryKit.UnitTests;
 using Exceptions;
 using FluentAssertions;
 using Operators;
+using SharedTestingHelper.Fakes.Recipes;
 using WebApiTestProject.Entities;
 using WebApiTestProject.Entities.Recipes;
 
@@ -266,6 +267,25 @@ public void sort_direction_after_extra_white_space_is_read(string input)
         result.Select(x => x.Title).Should().Equal("old", "young");
     }
 
+    [Theory]
+    [InlineData("""Tags ^$ "sweet" """, new[] { "pancakes" })]
+    [InlineData("""Tags ^$* "WINNER" """, new[] { "bread" })]
+    [InlineData("""Tags %^$ "dinner" """, new[] { "stew", "water" })]
+    public void has_returns_matching_rows(string input, string[] expectedTitles)
+    {
+        var recipes = new[]
+        {
+            new FakeRecipeBuilder().WithTitle("pancakes").Build().SetTags(["breakfast", "sweet"]),
+            new FakeRecipeBuilder().WithTitle("stew").Build().SetTags(["dinner"]),
+            new FakeRecipeBuilder().WithTitle("bread").Build().SetTags(["bread", "Winner"]),
+            new FakeRecipeBuilder().WithTitle("water").Build().SetTags([]),
+        };
+
+        var result = recipes.AsQueryable().ApplyQueryKitFilter(input).ToList();
+
+        result.Select(x => x.Title).Should().BeEquivalentTo(expectedTitles);
+    }
+
     private static TResult WithCulture<TResult>(string cultureName, Func<TResult> action)
     {
         var originalCulture = CultureInfo.CurrentCulture;