feat: can support hasconversion()

pdevito3 · pdevito3 · commit db1034b5e886 · 2025-06-24T20:42:50.000-04:00
resolves #10
diff --git a/QueryKit.IntegrationTests/Tests/HasConversionTests.cs b/QueryKit.IntegrationTests/Tests/HasConversionTests.cs
@@ -0,0 +1,43 @@
+namespace QueryKit.IntegrationTests.Tests;
+
+using Configuration;
+using FluentAssertions;
+using Microsoft.EntityFrameworkCore;
+using SharedTestingHelper.Fakes;
+using WebApiTestProject.Database;
+using WebApiTestProject.Entities;
+using Xunit.Abstractions;
+
+public class HasConversionTests(ITestOutputHelper testOutputHelper) : TestBase
+{
+    [Fact]
+    public async Task can_filter_by_email_with_has_conversion()
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var faker = new Bogus.Faker();
+        
+        var testEmail = faker.Internet.Email();
+        var person = new FakeTestingPersonBuilder()
+            .WithEmail(testEmail)
+            .Build();
+        var personTwo = new FakeTestingPersonBuilder().Build();
+        
+        await testingServiceScope.InsertAsync(person, personTwo);
+        
+        var input = $"""Email == "{testEmail}" """;
+        var config = new QueryKitConfiguration(config =>
+        {
+            config.Property<TestingPerson>(x => x.Email).HasConversion<string>();
+        });
+        
+        // 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(person.Id);
+    }
+}
diff --git a/QueryKit.UnitTests/FilterParserTests.cs b/QueryKit.UnitTests/FilterParserTests.cs
@@ -762,4 +762,38 @@ public void can_throw_exception_when_invalid_enum_value()
         act.Should().Throw<ParsingException>()
         .WithMessage("There was a parsing failure, likely due to an invalid comparison or logical operator. You may also be missing double quotes surrounding a string or guid.*");
     }
+
+    [Fact]
+    public void can_filter_with_has_conversion_configuration()
+    {
+        // Test that HasConversion<string>() configuration allows targeting the property directly
+        // The Email property is configured with HasConversion to indicate it should be treated as a string
+        // instead of accessing Email.Value. This test verifies the parsing works, 
+        // but the actual EF Core translation should be tested in integration tests.
+        var input = """Email == "test@example.com" """;
+        
+        var config = new QueryKitConfiguration(config =>
+        {
+            // Configure Email property to use HasConversion<string>()
+            // This tells QueryKit that Email should be compared directly as a string
+            // rather than requiring Email.Value access
+            config.Property<TestingPerson>(x => x.Email).HasConversion<string>();
+        });
+        
+        var filterExpression = FilterParser.ParseFilter<TestingPerson>(input, config);
+        
+        // The expression should be created successfully (not throw an exception)
+        filterExpression.Should().NotBeNull();
+        
+        // Let's see what the actual expression looks like
+        var expressionString = filterExpression.ToString();
+        
+        // Debug output - this should show us the actual expression
+        Console.WriteLine($"Generated expression: {expressionString}");
+        
+        // The expression should be created and contain the key elements
+        expressionString.Should().NotBeNullOrEmpty();
+        expressionString.Should().Contain("x.Email");
+        expressionString.Should().Contain("test@example.com");
+    }
 }
diff --git a/QueryKit/FilterParser.cs b/QueryKit/FilterParser.cs
@@ -222,9 +222,21 @@ from closingBracket in Parse.Char(']')
         { typeof(sbyte), value => sbyte.Parse(value, CultureInfo.InvariantCulture) },
     };
 
-    private static Expression CreateRightExpr(Expression leftExpr, string right, ComparisonOperator op)
+    private static Expression CreateRightExpr(Expression leftExpr, string right, ComparisonOperator op, 
+        IQueryKitConfiguration? config = null, string? propertyPath = null)
     {
         var targetType = leftExpr.Type;
+        
+        // Check if this property uses HasConversion and should use the conversion target type
+        if (config?.PropertyMappings != null && !string.IsNullOrEmpty(propertyPath))
+        {
+            var propertyConfig = config.PropertyMappings.GetPropertyInfoByQueryName(propertyPath);
+            if (propertyConfig?.UsesConversion == true && propertyConfig.ConversionTargetType != null)
+            {
+                targetType = propertyConfig.ConversionTargetType;
+            }
+        }
+        
         return CreateRightExprFromType(targetType, right, op);
     }
 
@@ -551,8 +563,15 @@ private static Parser<Expression> ComparisonExprParser<T>(ParameterExpression pa
                 
                 if (temp.leftExpr.Type == typeof(Guid) || temp.leftExpr.Type == typeof(Guid?))
                 {
+                    // Try to determine the property path for HasConversion support
+                    string? guidPropertyPath = null;
+                    if (temp.leftExpr is MemberExpression guidMemberExpr)
+                    {
+                        guidPropertyPath = GetPropertyPath(guidMemberExpr, parameter);
+                    }
+                    
                     var guidStringExpr = HandleGuidConversion(temp.leftExpr, temp.leftExpr.Type);
-                    return temp.op.GetExpression<T>(guidStringExpr, CreateRightExpr(temp.leftExpr, temp.right, temp.op),
+                    return temp.op.GetExpression<T>(guidStringExpr, CreateRightExpr(temp.leftExpr, temp.right, temp.op, config, guidPropertyPath),
                         config?.DbContextType);
                 }
 
@@ -579,14 +598,39 @@ private static Parser<Expression> ComparisonExprParser<T>(ParameterExpression pa
                     }
                 }
 
-                var rightExpr = CreateRightExpr(temp.leftExpr, temp.right, temp.op);
+                // Try to determine the property path for HasConversion support
+                string? propertyPath = null;
+                if (temp.leftExpr is MemberExpression memberExpr)
+                {
+                    propertyPath = GetPropertyPath(memberExpr, parameter);
+                }
+                
+                var rightExpr = CreateRightExpr(temp.leftExpr, temp.right, temp.op, config, propertyPath);
                 
                 // Handle nested collection filtering
                 if (temp.leftExpr is MethodCallExpression methodCall && IsNestedCollectionExpression(methodCall))
                 {
                     return CreateNestedCollectionFilterExpression<T>(methodCall, rightExpr, temp.op);
                 }
                 
+                // Special handling for HasConversion properties
+                if (config?.PropertyMappings != null && !string.IsNullOrEmpty(propertyPath))
+                {
+                    var propertyConfig = config.PropertyMappings.GetPropertyInfoByQueryName(propertyPath);
+                    if (propertyConfig?.UsesConversion == true && temp.op.Operator() == "==")
+                    {
+                        // For HasConversion properties, use Object.Equals instead of Expression.Equal
+                        // This avoids the type compatibility check and lets EF Core handle the conversion
+                        var equalsMethod = typeof(object).GetMethod("Equals", new[] { typeof(object), typeof(object) });
+                        if (equalsMethod != null)
+                        {
+                            var leftAsObject = Expression.Convert(temp.leftExpr, typeof(object));
+                            var rightAsObject = Expression.Convert(rightExpr, typeof(object));
+                            return Expression.Call(equalsMethod, leftAsObject, rightAsObject);
+                        }
+                    }
+                }
+                
                 return temp.op.GetExpression<T>(temp.leftExpr, rightExpr, config?.DbContextType);
             });
 
@@ -712,10 +756,52 @@ private static Parser<Expression> ComparisonExprParser<T>(ParameterExpression pa
                 return Expression.Constant(true, typeof(bool));
             }
 
+            // Check if this property uses HasConversion
+            var currentPropertyConfig = config?.PropertyMappings?.GetPropertyInfoByQueryName(fullPropPath);
+            if (currentPropertyConfig?.UsesConversion == true)
+            {
+                // For HasConversion properties, return the property expression as-is
+                // EF Core will handle the type conversion automatically when it translates the expression to SQL
+                // The key is that the right-side value will be converted to match the property's conversion target type
+                return propertyExpression;
+            }
+            
+            // Also check if this is a nested property where the parent has HasConversion configured
+            if (propertyExpression is MemberExpression nestedMemberExpression &&
+                nestedMemberExpression.Expression is MemberExpression parentExpression)
+            {
+                var parentPropertyPath = GetPropertyPath(parentExpression, parameter);
+                var parentPropertyConfig = config?.PropertyMappings?.GetPropertyInfoByQueryName(parentPropertyPath);
+                
+                if (parentPropertyConfig?.UsesConversion == true)
+                {
+                    // Use the parent expression instead of the nested property
+                    return parentExpression;
+                }
+            }
+
             return propertyExpression;
         });
     }
     
+    private static string GetPropertyPath(MemberExpression memberExpression, ParameterExpression parameter)
+    {
+        var parts = new List<string>();
+        var current = memberExpression;
+        
+        while (current != null)
+        {
+            parts.Insert(0, current.Member.Name);
+            
+            if (current.Expression == parameter)
+                break;
+                
+            current = current.Expression as MemberExpression;
+        }
+        
+        return string.Join(".", parts);
+    }
+    
     private static Type? GetInnerGenericType(Type type)
     {
         if (!IsEnumerable(type))
diff --git a/QueryKit/QueryKitPropertyMappings.cs b/QueryKit/QueryKitPropertyMappings.cs
@@ -406,6 +406,13 @@ public QueryKitPropertyMapping<TModel> HasQueryName(string queryName)
         _propertyInfo.QueryName = queryName;
         return this;
     }
+
+    public QueryKitPropertyMapping<TModel> HasConversion<TTarget>()
+    {
+        _propertyInfo.UsesConversion = true;
+        _propertyInfo.ConversionTargetType = typeof(TTarget);
+        return this;
+    }
 }
 
 public class QueryKitCustomOperationMapping<TModel>
@@ -439,4 +446,6 @@ public class QueryKitPropertyInfo
     internal Expression DerivedExpression { get; set; }
     internal Expression<Func<object, ComparisonOperator, object, bool>>? CustomOperation { get; set; }
     internal Type? CustomOperationEntityType { get; set; }
+    internal bool UsesConversion { get; set; }
+    internal Type? ConversionTargetType { get; set; }
 }
diff --git a/README.md b/README.md
@@ -590,17 +590,17 @@ public sealed class PersonConfiguration : IEntityTypeConfiguration<SpecialPerson
     {
         builder.HasKey(x => x.Id);
       
-      	// Option 1 (as of .NET 8)
+      	// Option 1 (as of .NET 8) - ComplexProperty
       	builder.ComplexProperty(x => x.Email,
             x => x.Property(y => y.Value)
                 .HasColumnName("email")); 
       
-      	// Option 2
+      	// Option 2 - HasConversion (see HasConversion support below)
         builder.Property(x => x.Email)
             .HasConversion(x => x.Value, x => new EmailAddress(x))
             .HasColumnName("email");      
       
-        // Option 3   
+        // Option 3 - OwnsOne
         builder.OwnsOne(x => x.Email, opts =>
         {
             opts.Property(x => x.Value).HasColumnName("email");
@@ -610,8 +610,32 @@ public sealed class PersonConfiguration : IEntityTypeConfiguration<SpecialPerson
 }
 ```
 
-> **Warning**
-> EF properties configured with `HasConversion` are not supported at this time
+### HasConversion Support
+
+For properties configured with EF Core's `HasConversion`, QueryKit provides special support that allows you to filter against the property directly without needing to access nested values. Use the `HasConversion<TTarget>()` configuration method:
+
+```c#
+// EF configuration with HasConversion
+builder.Property(x => x.Email)
+    .HasConversion(x => x.Value, x => new EmailAddress(x))
+    .HasColumnName("email");
+
+// QueryKit configuration for HasConversion properties
+var config = new QueryKitConfiguration(config =>
+{
+    config.Property<SpecialPerson>(x => x.Email)
+        .HasQueryName("email")
+        .HasConversion<string>(); // Specify the target type used in HasConversion
+});
+
+// Now you can filter directly against the property:
+var input = """email == "hello@gmail.com" """;
+var people = _dbContext.People
+    .ApplyQueryKitFilter(input, config)
+    .ToList();
+```
+
+This allows you to use `Email == "value"` syntax instead of `Email.Value == "value"` when the property is configured with HasConversion in EF Core. The `HasConversion<TTarget>()` method tells QueryKit what the conversion target type is so it can handle the type conversion properly.
 
 ## Sorting
 

Original file line number	Diff line number	Diff line change
`@@ -406,6 +406,13 @@ public QueryKitPropertyMapping<TModel> HasQueryName(string queryName)`
`406`	`406`	`_propertyInfo.QueryName = queryName;`
`407`	`407`	`return this;`
`408`	`408`	`}`
	`409`	`+`
	`410`	`+ public QueryKitPropertyMapping<TModel> HasConversion<TTarget>()`
	`411`	`+ {`
	`412`	`+ _propertyInfo.UsesConversion = true;`
	`413`	`+ _propertyInfo.ConversionTargetType = typeof(TTarget);`
	`414`	`+ return this;`
	`415`	`+ }`
`409`	`416`	`}`
`410`	`417`
`411`	`418`	`public class QueryKitCustomOperationMapping<TModel>`
`@@ -439,4 +446,6 @@ public class QueryKitPropertyInfo`
`439`	`446`	`internal Expression DerivedExpression { get; set; }`
`440`	`447`	`internal Expression<Func<object, ComparisonOperator, object, bool>>? CustomOperation { get; set; }`
`441`	`448`	`internal Type? CustomOperationEntityType { get; set; }`
	`449`	`+ internal bool UsesConversion { get; set; }`
	`450`	`+ internal Type? ConversionTargetType { get; set; }`
`442`	`451`	`}`