wip

Author: Jamess-Lucass

example/Controllers/UserController.cs

@@ -1,6 +1,7 @@
 using AutoMapper;
 using AutoMapper.QueryableExtensions;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
 
 [ApiController]
 [Route("controller/[controller]")]
@@ -22,6 +23,8 @@ public UsersController(ApplicationDbContext db, IMapper mapper)
     public ActionResult<IEnumerable<UserDto>> Get()
     {
         var users = _db.Users
+            .Include(x => x.Manager)
+                .ThenInclude(x => x.Manager)
             .Where(x => !x.IsDeleted)
             .ProjectTo<UserDto>(_mapper.ConfigurationProvider);
 

example/Dto/UserDto.cs

@@ -13,4 +13,5 @@ public record UserDto
     public int? NullableInt { get; set; }
     public DateTime DateOfBirthUtc { get; set; }
     public DateTime DateOfBirthTz { get; set; }
+    public User? Manager { get; set; }
 }

example/Entities/User.cs

@@ -16,4 +16,5 @@ public record User
 
     [Column(TypeName = "timestamp without time zone")]
     public DateTime DateOfBirthTz { get; set; }
+    public User? Manager { get; set; }
 }

example/Program.cs

@@ -1,4 +1,5 @@
 using System.Reflection;
+using System.Text.Json;
 using AutoMapper;
 using AutoMapper.QueryableExtensions;
 using Bogus;
@@ -50,7 +51,8 @@
 
                 u.DateOfBirthUtc = date;
                 u.DateOfBirthTz = TimeZoneInfo.ConvertTimeFromUtc(date, timeZone);
-            });
+            })
+            .RuleFor(x => x.Manager, (f, u) => f.CreateManager(3));
 
         context.Users.AddRange(users.Generate(1_000));
         context.SaveChanges();
@@ -62,6 +64,8 @@
 app.MapGet("/minimal/users", (ApplicationDbContext db, [FromServices] IMapper mapper, [AsParameters] Query query) =>
 {
     var result = db.Users
+        .Include(x => x.Manager)
+            .ThenInclude(x => x.Manager)
         .Where(x => !x.IsDeleted)
         .ProjectTo<UserDto>(mapper.ConfigurationProvider)
         .Apply(query);
@@ -79,3 +83,27 @@
 app.MapControllers();
 
 app.Run();
+
+public static class FakerExtensions
+{
+    public static User? CreateManager(this Faker f, int depth)
+    {
+        if (depth <= 0 || !f.Random.Bool(0.6f)) // 60% chance of having manager, stop at depth 0
+            return null;
+
+        return new User
+        {
+            Id = f.Random.Guid(),
+            Firstname = f.Person.FirstName,
+            Lastname = f.Person.LastName,
+            Age = f.Random.Int(0, 100),
+            IsDeleted = f.Random.Bool(),
+            Test = f.Random.Double(),
+            NullableInt = f.Random.Bool() ? f.Random.Int(1, 100) : null,
+            IsEmailVerified = f.Random.Bool(),
+            DateOfBirthUtc = f.Date.Past().ToUniversalTime(),
+            DateOfBirthTz = TimeZoneInfo.ConvertTimeFromUtc(f.Date.Past().ToUniversalTime(), TimeZoneInfo.FindSystemTimeZoneById("America/New_York")),
+            Manager = f.CreateManager(depth - 1) // Recursive call with reduced depth
+        };
+    }
+}

src/GoatQuery/src/Evaluator/FilterEvaluator.cs

@@ -88,20 +88,12 @@ private static Result<Expression> BuildPropertyExpression(ParameterExpression pa
                     var nullCheck = Expression.NotEqual(current, Expression.Constant(null));
                     var propertyAccess = Expression.Property(current, segment);
 
-                    // For the final segment, we'll handle null checks in the comparison
-                    if (segment == segments.Last())
-                    {
-                        current = propertyAccess;
-                    }
-                    else
-                    {
-                        // For intermediate segments, we need to ensure they're not null
-                        current = Expression.Condition(
-                            nullCheck,
-                            propertyAccess,
-                            Expression.Constant(null, propertyInfo.PropertyType)
-                        );
-                    }
+                    // Create null-safe navigation for all segments
+                    current = Expression.Condition(
+                        nullCheck,
+                        propertyAccess,
+                        Expression.Constant(null, propertyInfo.PropertyType)
+                    );
                 }
                 else
                 {
@@ -223,15 +215,92 @@ private static Result<Expression> CreatePropertyPathComparison(Expression proper
 
     private static Expression CreateNullCheckExpression(Expression property, List<string> segments)
     {
-        // Work backwards from the property expression to create null checks for each level
-        // For now, we'll use a simple approach - if any level is null, the comparison is false
+        // For property paths, we need to ensure that all intermediate reference types are not null
+        // The BuildPropertyExpression already handles null-safe navigation with conditional expressions,
+        // but we need to create an additional check for the final comparison
+
+        if (segments.Count <= 1)
+        {
+            // Single property, no intermediate null checks needed
+            return Expression.Constant(true);
+        }
+
+        // For a path like "manager.firstName", we need to check that "manager" is not null
+        // We need to traverse the property path and create null checks for each reference type level
+
+        var parameterExpression = GetParameterFromProperty(property);
+        if (parameterExpression == null)
+        {
+            return Expression.Constant(true);
+        }
+
+        Expression current = parameterExpression;
+        Expression nullCheckExpression = null;
+
+        // Check all segments except the last one (since the last one is handled in the comparison)
+        for (int i = 0; i < segments.Count - 1; i++)
+        {
+            var segment = segments[i];
+            var propertyInfo = current.Type.GetProperty(segment);
+
+            if (propertyInfo != null)
+            {
+                var propertyAccess = Expression.Property(current, segment);
+
+                // Only add null checks for reference types (not value types)
+                if (!propertyInfo.PropertyType.IsValueType)
+                {
+                    var nullCheck = Expression.NotEqual(propertyAccess, Expression.Constant(null));
+
+                    if (nullCheckExpression == null)
+                    {
+                        nullCheckExpression = nullCheck;
+                    }
+                    else
+                    {
+                        nullCheckExpression = Expression.AndAlso(nullCheckExpression, nullCheck);
+                    }
+                }
+
+                current = propertyAccess;
+            }
+        }
 
-        // This is a simplified implementation. In a more robust version, you'd want to 
-        // traverse the expression tree and create proper null checks for each level.
-        // For the current implementation, we'll rely on the property mapping and expression building
-        // to handle the null safety.
+        return nullCheckExpression ?? Expression.Constant(true);
+    }
 
-        return Expression.Constant(true); // Placeholder - will be enhanced based on testing
+    private static ParameterExpression GetParameterFromProperty(Expression expression)
+    {
+        // Traverse the expression tree to find the root parameter
+        while (expression != null)
+        {
+            if (expression is ParameterExpression parameter)
+            {
+                return parameter;
+            }
+            else if (expression is MemberExpression memberExpression)
+            {
+                expression = memberExpression.Expression;
+            }
+            else if (expression is ConditionalExpression conditionalExpression)
+            {
+                // Handle the case where we have conditional expressions from BuildPropertyExpression
+                expression = conditionalExpression.Test;
+                if (expression is BinaryExpression binaryExpression && binaryExpression.Left is MemberExpression memberExpr)
+                {
+                    expression = memberExpr.Expression;
+                }
+                else
+                {
+                    break;
+                }
+            }
+            else
+            {
+                break;
+            }
+        }
+        return null;
     }
 
     private static Result<Expression> CreateStandardComparison(Expression property, ConstantExpression value, string operatorKeyword, QueryExpression leftExpression)

src/GoatQuery/src/Extensions/QueryableExtension.cs

@@ -11,22 +11,32 @@ public static class QueryableExtension
     private static Dictionary<string, string> CreatePropertyMapping<T>()
     {
         var result = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
-        var visitedTypes = new HashSet<Type>();
+        var typeMappings = new Dictionary<Type, Dictionary<string, string>>();
 
-        BuildPropertyMapping(typeof(T), "", result, visitedTypes);
+        BuildPropertyMapping(typeof(T), "", result, typeMappings);
 
         return result;
     }
 
-    private static void BuildPropertyMapping(Type type, string prefix, Dictionary<string, string> result, HashSet<Type> visitedTypes)
+    private static void BuildPropertyMapping(Type type, string prefix, Dictionary<string, string> result, Dictionary<Type, Dictionary<string, string>> typeMappings)
     {
-        // Prevent circular reference loops
-        if (visitedTypes.Contains(type))
+        // Check if we've already mapped this type
+        if (typeMappings.ContainsKey(type))
         {
+            // Reuse the existing mappings for this type
+            var existingMappings = typeMappings[type];
+            foreach (var mapping in existingMappings)
+            {
+                var prefixedJsonPath = string.IsNullOrEmpty(prefix) ? mapping.Key : $"{prefix}/{mapping.Key}";
+                var prefixedPropertyPath = string.IsNullOrEmpty(prefix) ? mapping.Value : $"{prefix}.{mapping.Value}";
+                result[prefixedJsonPath] = prefixedPropertyPath;
+            }
             return;
         }
 
-        visitedTypes.Add(type);
+        // Create a new mapping for this type
+        var currentTypeMappings = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        typeMappings[type] = currentTypeMappings;
 
         var properties = type.GetProperties();
 
@@ -42,15 +52,14 @@ private static void BuildPropertyMapping(Type type, string prefix, Dictionary<st
 
             // Add the mapping for this property
             result[fullJsonPath] = fullPropertyPath;
+            currentTypeMappings[jsonName] = property.Name;
 
             // Recursively process nested object properties (but not primitive types, collections, etc.)
             if (IsComplexType(property.PropertyType))
             {
-                BuildPropertyMapping(property.PropertyType, fullJsonPath, result, visitedTypes);
+                BuildPropertyMapping(property.PropertyType, fullJsonPath, result, typeMappings);
             }
         }
-
-        visitedTypes.Remove(type);
     }
 
     private static bool IsComplexType(Type type)