ability to parse to other primitive numeric types

Author: Jamess-Lucass

src/GoatQuery/src/Evaluator/FilterEvaluator.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Linq.Expressions;
 using FluentResults;
@@ -18,21 +19,27 @@ public static Result<Expression> Evaluate(QueryExpression expression, ParameterE
 
                     var property = Expression.Property(parameterExpression, propertyName);
 
-                    ConstantExpression value = null;
+                    ConstantExpression value;
 
                     switch (exp.Right)
                     {
                         case GuidLiteral literal:
                             value = Expression.Constant(literal.Value, property.Type);
                             break;
                         case IntegerLiteral literal:
-                            value = Expression.Constant(literal.Value, property.Type);
+                            var integerConstant = GetIntegerExpressionConstant(literal.Value, property.Type);
+                            if (integerConstant.IsFailed)
+                            {
+                                return Result.Fail(integerConstant.Errors);
+                            }
+
+                            value = integerConstant.Value;
                             break;
                         case StringLiteral literal:
                             value = Expression.Constant(literal.Value, property.Type);
                             break;
                         default:
-                            break;
+                            return Result.Fail($"Unsupported literal type: {exp.Right.GetType().Name}");
                     }
 
                     switch (exp.Operator)
@@ -47,6 +54,8 @@ public static Result<Expression> Evaluate(QueryExpression expression, ParameterE
                             var method = identifier.Value.GetType().GetMethod("Contains", new[] { value?.Value.GetType() });
 
                             return Expression.Call(property, method, value);
+                        default:
+                            return Result.Fail($"Unsupported operator: {exp.Operator}");
                     }
                 }
 
@@ -75,4 +84,37 @@ public static Result<Expression> Evaluate(QueryExpression expression, ParameterE
 
         return null;
     }
+
+    private static Result<ConstantExpression> GetIntegerExpressionConstant(int value, Type targetType)
+    {
+        try
+        {
+            // Fetch the underlying type if it's nullable.
+            var underlyingType = Nullable.GetUnderlyingType(targetType);
+            var type = underlyingType ?? targetType;
+
+            object convertedValue = type switch
+            {
+                Type t when t == typeof(int) => value,
+                Type t when t == typeof(long) => Convert.ToInt64(value),
+                Type t when t == typeof(short) => Convert.ToInt16(value),
+                Type t when t == typeof(byte) => Convert.ToByte(value),
+                Type t when t == typeof(uint) => Convert.ToUInt32(value),
+                Type t when t == typeof(ulong) => Convert.ToUInt64(value),
+                Type t when t == typeof(ushort) => Convert.ToUInt16(value),
+                Type t when t == typeof(sbyte) => Convert.ToSByte(value),
+                _ => throw new NotSupportedException($"Unsupported numeric type: {targetType.Name}")
+            };
+
+            return Expression.Constant(convertedValue, targetType);
+        }
+        catch (OverflowException)
+        {
+            return Result.Fail($"Value {value} is too large for type {targetType.Name}");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail($"Error converting {value} to {targetType.Name}: {ex.Message}");
+        }
+    }
 }

src/GoatQuery/tests/Filter/FilterTest.cs

@@ -156,4 +156,43 @@ public void Test_Filter_WithCustomJsonPropertyName()
             new CustomJsonPropertyUser { Lastname = "John" },
         }, result.Value.Query);
     }
+
+    public record IntegerConverts
+    {
+        public long Long { get; set; }
+        public short Short { get; set; }
+        public byte Byte { get; set; }
+        public uint Uint { get; set; }
+        public ulong ULong { get; set; }
+        public ushort UShort { get; set; }
+        public sbyte SByte { get; set; }
+    }
+
+    [Theory]
+    [InlineData("long eq 10")]
+    [InlineData("short eq 20")]
+    [InlineData("byte eq 30")]
+    [InlineData("uint eq 40")]
+    [InlineData("ulong eq 50")]
+    [InlineData("ushort eq 60")]
+    [InlineData("sbyte eq 70")]
+    public void Test_Filter_CanConvertIntToOtherNumericTypes(string filter)
+    {
+        var users = new List<IntegerConverts>{
+            new IntegerConverts() { Long = 0, Short = 0, Byte = 0, Uint = 0, ULong = 0, UShort = 0, SByte = 0},
+            new IntegerConverts() { Long = 10, Short = 20, Byte = 30, Uint = 40, ULong = 50, UShort = 60, SByte = 70},
+            new IntegerConverts() { Long = 1, Short = 2, Byte = 3, Uint = 4, ULong = 5, UShort = 6, SByte = 7},
+        }.AsQueryable();
+
+        var query = new Query
+        {
+            Filter = filter
+        };
+
+        var result = users.Apply(query);
+
+        Assert.Equal(new List<IntegerConverts>{
+            new IntegerConverts() { Long = 10, Short = 20, Byte = 30, Uint = 40, ULong = 50, UShort = 60, SByte = 70},
+        }, result.Value.Query);
+    }
 }

src/GoatQuery/tests/User.cs

@@ -5,6 +5,8 @@ public record User
     public int Age { get; set; }
     public Guid UserId { get; set; }
     public string Firstname { get; set; } = string.Empty;
+
+    public string Long { get; set; } = string.Empty;
 }
 
 public sealed record CustomJsonPropertyUser : User