Add configurable case-insensitive mode for string filters

Introduces the CaseInsensitiveMode enum to control whether case-insensitive string comparisons use ToLower/LOWER or ToUpper/UPPER. Adds global and per-property configuration for this mode in QueryKitConfiguration, QueryKitSettings, and QueryKitPropertyMapping. Refactors all relevant string comparison logic and operators to honor the selected case transformation, enabling consistent and customizable case-insensitive behavior for various data normalization scenarios.

Author: AlexMKotcz

QueryKit/Configuration/CaseInsensitiveMode.cs

@@ -0,0 +1,13 @@
+namespace QueryKit.Configuration;
+
+/// <summary>
+/// Controls which SQL case transformation is generated for case-insensitive string operators (e.g. @=*, _=*).
+/// </summary>
+public enum CaseInsensitiveMode
+{
+    /// <summary>Default. Generates ToLower() / LOWER() comparisons.</summary>
+    Lower = 0,
+
+    /// <summary>Generates ToUpper() / UPPER() comparisons. Useful when data is normalized to uppercase.</summary>
+    Upper = 1
+}

QueryKit/Configuration/QueryKitConfiguration.cs

@@ -33,6 +33,7 @@ public interface IQueryKitConfiguration
     public string HasOperator { get; set; }
     public string DoesNotHaveOperator { get; set; }
     public int? MaxPropertyDepth { get; set; }
+    public CaseInsensitiveMode CaseInsensitiveComparison { get; set; }
 }
 
 public class QueryKitConfiguration : IQueryKitConfiguration
@@ -68,6 +69,7 @@ public class QueryKitConfiguration : IQueryKitConfiguration
     public bool AllowUnknownProperties { get; set; } = false;
     public Type? DbContextType { get; set; }
     public int? MaxPropertyDepth { get; set; }
+    public CaseInsensitiveMode CaseInsensitiveComparison { get; set; }
 
     public QueryKitConfiguration(Action<QueryKitSettings> configureSettings)
     {
@@ -106,5 +108,6 @@ public QueryKitConfiguration(Action<QueryKitSettings> configureSettings)
         HasOperator = settings.HasOperator;
         DoesNotHaveOperator = settings.DoesNotHaveOperator;
         MaxPropertyDepth = settings.MaxPropertyDepth;
+        CaseInsensitiveComparison = settings.CaseInsensitiveComparison;
     }
 }

QueryKit/Configuration/QueryKitSettings.cs

@@ -36,6 +36,7 @@ public class QueryKitSettings
     public bool AllowUnknownProperties { get; set; }
     public Type? DbContextType { get; set; }
     public int? MaxPropertyDepth { get; set; }
+    public CaseInsensitiveMode CaseInsensitiveComparison { get; set; } = CaseInsensitiveMode.Lower;
 
     public QueryKitPropertyMapping<TModel> Property<TModel>(Expression<Func<TModel, object>>? propertySelector)
     {

QueryKit/FilterParser.cs

@@ -607,6 +607,18 @@ private static bool IsValidPropertyName(string value)
                value.All(c => char.IsLetterOrDigit(c) || c == '_' || c == '.');
     }
 
+    private static CaseInsensitiveMode ResolveCaseMode(string? propertyPath, IQueryKitConfiguration? config)
+    {
+        if (!string.IsNullOrEmpty(propertyPath) && config?.PropertyMappings != null)
+        {
+            var propertyInfo = config.PropertyMappings.GetPropertyInfo(propertyPath)
+                               ?? config.PropertyMappings.GetPropertyInfoByQueryName(propertyPath);
+            if (propertyInfo?.CaseInsensitiveComparison.HasValue == true)
+                return propertyInfo.CaseInsensitiveComparison.Value;
+        }
+        return config?.CaseInsensitiveComparison ?? CaseInsensitiveMode.Lower;
+    }
+
     private static Parser<Expression> ComparisonExprParser<T>(ParameterExpression parameter, IQueryKitConfiguration? config)
     {
         var comparisonOperatorParser = ComparisonOperatorParser.Token();
@@ -661,7 +673,7 @@ private static Parser<Expression> ComparisonExprParser<T>(ParameterExpression pa
                     {
                         var guidStringExpr = HandleGuidConversion(temp.leftExpr, temp.leftExpr.Type);
                         return temp.op.GetExpression<T>(guidStringExpr, CreateRightExpr(temp.leftExpr, temp.right, temp.op, config, guidPropertyPath),
-                            config?.DbContextType);
+                            config?.DbContextType, ResolveCaseMode(guidPropertyPath, config));
                     }
 
                     // For non-string operators, use direct GUID comparison
@@ -692,7 +704,8 @@ private static Parser<Expression> ComparisonExprParser<T>(ParameterExpression pa
 
                         // Ensure compatible types for property-to-property comparison
                         var (leftCompatible, rightCompatible) = EnsureCompatibleTypes(leftExpr, rightPropertyExpr);
-                        return temp.op.GetExpression<T>(leftCompatible, rightCompatible, config?.DbContextType);
+                        var propToProptPath = temp.leftExpr is MemberExpression ptpMemberExpr ? GetPropertyPath(ptpMemberExpr, parameter) : null;
+                        return temp.op.GetExpression<T>(leftCompatible, rightCompatible, config?.DbContextType, ResolveCaseMode(propToProptPath, config));
                     }
                 }
 
@@ -782,7 +795,7 @@ private static Parser<Expression> ComparisonExprParser<T>(ParameterExpression pa
                 }
 
 
-                return temp.op.GetExpression<T>(leftExprForComparison, rightExpr, config?.DbContextType);
+                return temp.op.GetExpression<T>(leftExprForComparison, rightExpr, config?.DbContextType, ResolveCaseMode(propertyPath, config));
             });
 
         return propertyListComparison.Or(arithmeticComparison).Or(regularComparison);
@@ -1134,7 +1147,7 @@ private static Parser<Expression> PropertyListComparisonExprParser<T>(
                     }
 
                     var rightExpr = CreateRightExpr(leftExpr, temp.right, temp.op, config, fullPropPath);
-                    var comparison = temp.op.GetExpression<T>(leftExpr, rightExpr, config?.DbContextType);
+                    var comparison = temp.op.GetExpression<T>(leftExpr, rightExpr, config?.DbContextType, ResolveCaseMode(fullPropPath, config));
 
                     // Combine with AND for negative operators, OR for positive operators
                     result = result == null