fix: handle null expressions in GetFullPropertyPath for complex conditionals

Previously, complex conditional expressions with null values would throw:
System.ArgumentNullException: Value cannot be null. (Parameter 'expression')

This occurred when using conditional expressions like:
x.DueDate.HasValue ? (calculation) : (int?)null

The fix adds comprehensive null checking throughout GetFullPropertyPath to:
- Handle null operands in Convert/Cast expressions
- Handle null arguments in method calls, constructors, and invocations
- Handle null expressions in member access, conditionals, and binary operations
- Return appropriate string representations ("null") for null values

Changes made:
- Added null checks in Convert, MemberAccess, Binary, Conditional expressions
- Added null checks for method call arguments and objects
- Added null checks for New expression arguments and constructors
- Added null checks for Invoke expression arguments
- All null expressions now return "null" instead of throwing

Test added to verify complex conditional expressions with nullable types
no longer throw ArgumentNullException and are handled gracefully.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: pdevito3

QueryKit.IntegrationTests/Tests/DatabaseFilteringTests.cs

@@ -3796,4 +3796,47 @@ public async Task can_filter_with_derived_property_containing_complex_method_cal
         // Note: The actual filtering logic may need separate investigation
     }
 
+    [Fact]
+    public async Task can_filter_with_derived_property_containing_complex_conditional_expression()
+    {
+        // Arrange
+        var testingServiceScope = new TestingServiceScope();
+        var uniqueId = Guid.NewGuid().ToString();
+
+        var futureDate = DateOnly.FromDateTime(DateTime.UtcNow.AddDays(10));
+        var pastDate = DateOnly.FromDateTime(DateTime.UtcNow.AddDays(-5));
+
+        var fakePersonOne = new FakeTestingPersonBuilder()
+            .WithFirstName($"Future_{uniqueId}")
+            .WithDate(futureDate)
+            .Build();
+        var fakePersonTwo = new FakeTestingPersonBuilder()
+            .WithFirstName($"Past_{uniqueId}")
+            .WithDate(pastDate)
+            .Build();
+        var fakePersonThree = new FakeTestingPersonBuilder()
+            .WithFirstName($"NoDate_{uniqueId}")
+            .WithDate(null)
+            .Build();
+
+        await testingServiceScope.InsertAsync(fakePersonOne, fakePersonTwo, fakePersonThree);
+
+        // This should not throw "Value cannot be null" anymore
+        Action act = () =>
+        {
+            var config = new QueryKitConfiguration(config =>
+            {
+                config.DerivedProperty<TestingPerson>(x =>
+                    x.Date.HasValue
+                        ? (DateOnly.FromDateTime(DateTime.UtcNow).ToDateTime(TimeOnly.MinValue) -
+                           x.Date.Value.ToDateTime(TimeOnly.MinValue)).Days
+                        : (int?)null
+                ).HasQueryName("daysUntilDue");
+            });
+        };
+
+        // Assert - Should not throw ArgumentNullException
+        act.Should().NotThrow<ArgumentNullException>("null values in expressions should be handled properly");
+    }
+
 }

QueryKit/QueryKitPropertyMappings.cs

@@ -174,7 +174,7 @@ private static string GetFullPropertyPath(Expression? expression)
                     var argumentsList = new List<string>();
                     foreach (var arg in call.Arguments)
                     {
-                        argumentsList.Add(GetFullPropertyPath(arg));
+                        argumentsList.Add(arg != null ? GetFullPropertyPath(arg) : "null");
                     }
                     var argumentsString = string.Join(", ", argumentsList);
 
@@ -195,12 +195,14 @@ private static string GetFullPropertyPath(Expression? expression)
                 return GetFullPropertyPath(lambda.Body);
             case ExpressionType.Convert:
                 var unary = (UnaryExpression)expression;
-                return GetFullPropertyPath(unary.Operand);
+                return unary.Operand != null ? GetFullPropertyPath(unary.Operand) : "null";
             case ExpressionType.MemberAccess:
                 var memberExpression = (MemberExpression)expression;
-                return memberExpression?.Expression?.NodeType == ExpressionType.Parameter 
-                    ? memberExpression.Member.Name 
-                    : $"{GetFullPropertyPath(memberExpression?.Expression)}.{memberExpression?.Member?.Name}";
+                if (memberExpression?.Expression == null)
+                    return memberExpression?.Member?.Name ?? "null";
+                return memberExpression.Expression.NodeType == ExpressionType.Parameter
+                    ? memberExpression.Member.Name
+                    : $"{GetFullPropertyPath(memberExpression.Expression)}.{memberExpression.Member?.Name}";
             case ExpressionType.Add:
             case ExpressionType.Subtract:
             case ExpressionType.Multiply:
@@ -220,8 +222,8 @@ private static string GetFullPropertyPath(Expression? expression)
             case ExpressionType.MultiplyChecked:
             case ExpressionType.SubtractChecked:
                 var binary = (BinaryExpression)expression;
-                var left = GetFullPropertyPath(binary.Left);
-                var right = GetFullPropertyPath(binary.Right);
+                var left = binary.Left != null ? GetFullPropertyPath(binary.Left) : "null";
+                var right = binary.Right != null ? GetFullPropertyPath(binary.Right) : "null";
                 var op = GetOperator(binary.NodeType);
                 return $"{left} {op} {right}";
             case ExpressionType.Constant:
@@ -230,20 +232,23 @@ private static string GetFullPropertyPath(Expression? expression)
 
             case ExpressionType.Conditional:
                 var conditional = (ConditionalExpression)expression;
-                var test = GetFullPropertyPath(conditional.Test);
-                var ifTrue = GetFullPropertyPath(conditional.IfTrue);
-                var ifFalse = GetFullPropertyPath(conditional.IfFalse);
+                var test = conditional.Test != null ? GetFullPropertyPath(conditional.Test) : "null";
+                var ifTrue = conditional.IfTrue != null ? GetFullPropertyPath(conditional.IfTrue) : "null";
+                var ifFalse = conditional.IfFalse != null ? GetFullPropertyPath(conditional.IfFalse) : "null";
                 return $"({test}) ? ({ifTrue}) : ({ifFalse})";
 
             case ExpressionType.New:
                 var newExpression = (NewExpression)expression;
-                var arguments = newExpression.Arguments.Select(GetFullPropertyPath);
-                return $"{newExpression.Constructor.DeclaringType.Name}({string.Join(", ", arguments)})";
+                var arguments = newExpression.Arguments.Select(arg => arg != null ? GetFullPropertyPath(arg) : "null");
+                return newExpression.Constructor != null
+                    ? $"{newExpression.Constructor.DeclaringType.Name}({string.Join(", ", arguments)})"
+                    : $"new({string.Join(", ", arguments)})";
 
             case ExpressionType.Invoke:
                 var invocation = (InvocationExpression)expression;
-                var invocationArguments = invocation.Arguments.Select(GetFullPropertyPath);
-                return $"{GetFullPropertyPath(invocation.Expression)}({string.Join(", ", invocationArguments)})";
+                var invocationArguments = invocation.Arguments.Select(arg => arg != null ? GetFullPropertyPath(arg) : "null");
+                var invocationExpr = invocation.Expression != null ? GetFullPropertyPath(invocation.Expression) : "null";
+                return $"{invocationExpr}({string.Join(", ", invocationArguments)})";
 
             case ExpressionType.ListInit:
                 var listInit = (ListInitExpression)expression;