Changes LiteralConstantExpression to contain a typed constant instead of a string value. This effectively moves the type resolving/conversion logic from the EF query production phase to the filter parsing phase. By providing a richer QueryLayer model, it becomes easier to implement non-relational and non-EF Core-based repositories. And it enables to produce better errors earlier.

Note we still need to wrap nullable values (see WhereClauseBuilder.ResolveCommonType), due to https://bradwilson.typepad.com/blog/2008/07/creating-nullab.html.

Author: bkoelman

Diff for: src/JsonApiDotNetCore/Queries/Expressions/LiteralConstantExpression.cs

@@ -8,13 +8,22 @@ namespace JsonApiDotNetCore.Queries.Expressions;
 [PublicAPI]
 public class LiteralConstantExpression : IdentifierExpression
 {
-    public string Value { get; }
+    private readonly string _stringValue;
 
-    public LiteralConstantExpression(string text)
+    public object TypedValue { get; }
+
+    public LiteralConstantExpression(object typedValue)
+        : this(typedValue, typedValue.ToString()!)
+    {
+    }
+
+    public LiteralConstantExpression(object typedValue, string stringValue)
     {
-        ArgumentGuard.NotNull(text);
+        ArgumentGuard.NotNull(typedValue);
+        ArgumentGuard.NotNull(stringValue);
 
-        Value = text;
+        TypedValue = typedValue;
+        _stringValue = stringValue;
     }
 
     public override TResult Accept<TArgument, TResult>(QueryExpressionVisitor<TArgument, TResult> visitor, TArgument argument)
@@ -24,8 +33,8 @@ public override TResult Accept<TArgument, TResult>(QueryExpressionVisitor<TArgum
 
     public override string ToString()
     {
-        string value = Value.Replace("\'", "\'\'");
-        return $"'{value}'";
+        string escapedValue = _stringValue.Replace("\'", "\'\'");
+        return $"'{escapedValue}'";
     }
 
     public override string ToFullString()
@@ -47,11 +56,11 @@ public override bool Equals(object? obj)
 
         var other = (LiteralConstantExpression)obj;
 
-        return Value == other.Value;
+        return Equals(TypedValue, other.TypedValue) && _stringValue == other._stringValue;
     }
 
     public override int GetHashCode()
     {
-        return Value.GetHashCode();
+        return HashCode.Combine(TypedValue, _stringValue);
     }
 }

Diff for: src/JsonApiDotNetCore/Queries/Internal/Parsing/FilterParser.cs

@@ -1,11 +1,11 @@
 using System.Collections.Immutable;
-using System.Reflection;
 using Humanizer;
 using JetBrains.Annotations;
 using JsonApiDotNetCore.Configuration;
 using JsonApiDotNetCore.Queries.Expressions;
 using JsonApiDotNetCore.Resources;
 using JsonApiDotNetCore.Resources.Annotations;
+using JsonApiDotNetCore.Resources.Internal;
 
 namespace JsonApiDotNetCore.Queries.Internal.Parsing;
 
@@ -141,28 +141,32 @@ protected ComparisonExpression ParseComparison(string operatorName)
             : FieldChainRequirements.EndsInAttribute;
 
         QueryExpression leftTerm = ParseCountOrField(leftChainRequirements);
+        Converter<string, object> rightConstantValueConverter;
+
+        if (leftTerm is CountExpression)
+        {
+            rightConstantValueConverter = GetConstantValueConverterForCount();
+        }
+        else if (leftTerm is ResourceFieldChainExpression fieldChain && fieldChain.Fields[^1] is AttrAttribute attribute)
+        {
+            rightConstantValueConverter = GetConstantValueConverterForAttribute(attribute);
+        }
+        else
+        {
+            // This temporary value never survives; it gets discarded during the second pass below.
+            rightConstantValueConverter = _ => 0;
+        }
 
         EatSingleCharacterToken(TokenKind.Comma);
 
-        QueryExpression rightTerm = ParseCountOrConstantOrNullOrField(FieldChainRequirements.EndsInAttribute);
+        QueryExpression rightTerm = ParseCountOrConstantOrNullOrField(FieldChainRequirements.EndsInAttribute, rightConstantValueConverter);
 
         EatSingleCharacterToken(TokenKind.CloseParen);
 
-        if (leftTerm is ResourceFieldChainExpression leftChain)
+        if (leftTerm is ResourceFieldChainExpression leftChain && leftChain.Fields[^1] is RelationshipAttribute && rightTerm is not NullConstantExpression)
         {
-            if (leftChainRequirements.HasFlag(FieldChainRequirements.EndsInToOne) && rightTerm is not NullConstantExpression)
-            {
-                // Run another pass over left chain to have it fail when chain ends in relationship.
-                OnResolveFieldChain(leftChain.ToString(), FieldChainRequirements.EndsInAttribute);
-            }
-
-            PropertyInfo leftProperty = leftChain.Fields[^1].Property;
-
-            if (leftProperty.Name == nameof(Identifiable<object>.Id) && rightTerm is LiteralConstantExpression rightConstant)
-            {
-                string id = DeObfuscateStringId(leftProperty.ReflectedType!, rightConstant.Value);
-                rightTerm = new LiteralConstantExpression(id);
-            }
+            // Run another pass over left chain to produce an error.
+            OnResolveFieldChain(leftChain.ToString(), FieldChainRequirements.EndsInAttribute);
         }
 
         return new ComparisonExpression(comparisonOperator, leftTerm, rightTerm);
@@ -173,16 +177,23 @@ protected MatchTextExpression ParseTextMatch(string matchFunctionName)
         EatText(matchFunctionName);
         EatSingleCharacterToken(TokenKind.OpenParen);
 
-        ResourceFieldChainExpression targetAttribute = ParseFieldChain(FieldChainRequirements.EndsInAttribute, null);
+        ResourceFieldChainExpression targetAttributeChain = ParseFieldChain(FieldChainRequirements.EndsInAttribute, null);
+        Type targetAttributeType = ((AttrAttribute)targetAttributeChain.Fields[^1]).Property.PropertyType;
+
+        if (targetAttributeType != typeof(string))
+        {
+            throw new QueryParseException("Attribute of type 'String' expected.");
+        }
 
         EatSingleCharacterToken(TokenKind.Comma);
 
-        LiteralConstantExpression constant = ParseConstant();
+        Converter<string, object> constantValueConverter = stringValue => stringValue;
+        LiteralConstantExpression constant = ParseConstant(constantValueConverter);
 
         EatSingleCharacterToken(TokenKind.CloseParen);
 
         var matchKind = Enum.Parse<TextMatchKind>(matchFunctionName.Pascalize());
-        return new MatchTextExpression(targetAttribute, constant, matchKind);
+        return new MatchTextExpression(targetAttributeChain, constant, matchKind);
     }
 
     protected AnyExpression ParseAny()
@@ -191,52 +202,30 @@ protected AnyExpression ParseAny()
         EatSingleCharacterToken(TokenKind.OpenParen);
 
         ResourceFieldChainExpression targetAttribute = ParseFieldChain(FieldChainRequirements.EndsInAttribute, null);
+        Converter<string, object> constantValueConverter = GetConstantValueConverterForAttribute((AttrAttribute)targetAttribute.Fields[^1]);
 
         EatSingleCharacterToken(TokenKind.Comma);
 
         ImmutableHashSet<LiteralConstantExpression>.Builder constantsBuilder = ImmutableHashSet.CreateBuilder<LiteralConstantExpression>();
 
-        LiteralConstantExpression constant = ParseConstant();
+        LiteralConstantExpression constant = ParseConstant(constantValueConverter);
         constantsBuilder.Add(constant);
 
         while (TokenStack.TryPeek(out Token? nextToken) && nextToken.Kind == TokenKind.Comma)
         {
             EatSingleCharacterToken(TokenKind.Comma);
 
-            constant = ParseConstant();
+            constant = ParseConstant(constantValueConverter);
             constantsBuilder.Add(constant);
         }
 
         EatSingleCharacterToken(TokenKind.CloseParen);
 
         IImmutableSet<LiteralConstantExpression> constantSet = constantsBuilder.ToImmutable();
 
-        PropertyInfo targetAttributeProperty = targetAttribute.Fields[^1].Property;
-
-        if (targetAttributeProperty.Name == nameof(Identifiable<object>.Id))
-        {
-            constantSet = DeObfuscateIdConstants(constantSet, targetAttributeProperty);
-        }
-
         return new AnyExpression(targetAttribute, constantSet);
     }
 
-    private IImmutableSet<LiteralConstantExpression> DeObfuscateIdConstants(IImmutableSet<LiteralConstantExpression> constantSet,
-        PropertyInfo targetAttributeProperty)
-    {
-        ImmutableHashSet<LiteralConstantExpression>.Builder idConstantsBuilder = ImmutableHashSet.CreateBuilder<LiteralConstantExpression>();
-
-        foreach (LiteralConstantExpression idConstant in constantSet)
-        {
-            string stringId = idConstant.Value;
-            string id = DeObfuscateStringId(targetAttributeProperty.ReflectedType!, stringId);
-
-            idConstantsBuilder.Add(new LiteralConstantExpression(id));
-        }
-
-        return idConstantsBuilder.ToImmutable();
-    }
-
     protected HasExpression ParseHas()
     {
         EatText(Keywords.Has);
@@ -360,7 +349,7 @@ protected QueryExpression ParseCountOrField(FieldChainRequirements chainRequirem
         return ParseFieldChain(chainRequirements, "Count function or field name expected.");
     }
 
-    protected QueryExpression ParseCountOrConstantOrNullOrField(FieldChainRequirements chainRequirements)
+    protected QueryExpression ParseCountOrConstantOrNullOrField(FieldChainRequirements chainRequirements, Converter<string, object> constantValueConverter)
     {
         CountExpression? count = TryParseCount();
 
@@ -369,7 +358,7 @@ protected QueryExpression ParseCountOrConstantOrNullOrField(FieldChainRequiremen
             return count;
         }
 
-        IdentifierExpression? constantOrNull = TryParseConstantOrNull();
+        IdentifierExpression? constantOrNull = TryParseConstantOrNull(constantValueConverter);
 
         if (constantOrNull != null)
         {
@@ -379,7 +368,7 @@ protected QueryExpression ParseCountOrConstantOrNullOrField(FieldChainRequiremen
         return ParseFieldChain(chainRequirements, "Count function, value between quotes, null or field name expected.");
     }
 
-    protected IdentifierExpression? TryParseConstantOrNull()
+    protected IdentifierExpression? TryParseConstantOrNull(Converter<string, object> constantValueConverter)
     {
         if (TokenStack.TryPeek(out Token? nextToken))
         {
@@ -392,28 +381,55 @@ protected QueryExpression ParseCountOrConstantOrNullOrField(FieldChainRequiremen
             if (nextToken.Kind == TokenKind.QuotedText)
             {
                 TokenStack.Pop();
-                return new LiteralConstantExpression(nextToken.Value!);
+
+                object constantValue = constantValueConverter(nextToken.Value!);
+                return new LiteralConstantExpression(constantValue, nextToken.Value!);
             }
         }
 
         return null;
     }
 
-    protected LiteralConstantExpression ParseConstant()
+    protected LiteralConstantExpression ParseConstant(Converter<string, object> constantValueConverter)
     {
         if (TokenStack.TryPop(out Token? token) && token.Kind == TokenKind.QuotedText)
         {
-            return new LiteralConstantExpression(token.Value!);
+            object constantValue = constantValueConverter(token.Value!);
+            return new LiteralConstantExpression(constantValue, token.Value!);
         }
 
         throw new QueryParseException("Value between quotes expected.");
     }
 
-    private string DeObfuscateStringId(Type resourceClrType, string stringId)
+    private Converter<string, object> GetConstantValueConverterForCount()
+    {
+        return stringValue => ConvertStringToType(stringValue, typeof(int));
+    }
+
+    private object ConvertStringToType(string value, Type type)
+    {
+        try
+        {
+            return RuntimeTypeConverter.ConvertType(value, type)!;
+        }
+        catch (FormatException)
+        {
+            throw new QueryParseException($"Failed to convert '{value}' of type 'String' to type '{type.Name}'.");
+        }
+    }
+
+    private Converter<string, object> GetConstantValueConverterForAttribute(AttrAttribute attribute)
+    {
+        return stringValue => attribute.Property.Name == nameof(IIdentifiable<object>.Id)
+            ? DeObfuscateStringId(attribute.Type.ClrType, stringValue)
+            : ConvertStringToType(stringValue, attribute.Property.PropertyType);
+    }
+
+    private object DeObfuscateStringId(Type resourceClrType, string stringId)
     {
         IIdentifiable tempResource = _resourceFactory.CreateInstance(resourceClrType);
         tempResource.StringId = stringId;
-        return tempResource.GetTypedId().ToString()!;
+        return tempResource.GetTypedId();
     }
 
     protected override IImmutableList<ResourceFieldAttribute> OnResolveFieldChain(string path, FieldChainRequirements chainRequirements)

Diff for: src/JsonApiDotNetCore/Queries/Internal/QueryLayerComposer.cs

@@ -114,14 +114,14 @@ private static FilterExpression GetInverseHasOneRelationshipFilter<TId>(TId prim
         AttrAttribute idAttribute = GetIdAttribute(relationship.LeftType);
         var idChain = new ResourceFieldChainExpression(ImmutableArray.Create<ResourceFieldAttribute>(inverseRelationship, idAttribute));
 
-        return new ComparisonExpression(ComparisonOperator.Equals, idChain, new LiteralConstantExpression(primaryId!.ToString()!));
+        return new ComparisonExpression(ComparisonOperator.Equals, idChain, new LiteralConstantExpression(primaryId!));
     }
 
     private static FilterExpression GetInverseHasManyRelationshipFilter<TId>(TId primaryId, HasManyAttribute relationship, HasManyAttribute inverseRelationship)
     {
         AttrAttribute idAttribute = GetIdAttribute(relationship.LeftType);
         var idChain = new ResourceFieldChainExpression(ImmutableArray.Create<ResourceFieldAttribute>(idAttribute));
-        var idComparison = new ComparisonExpression(ComparisonOperator.Equals, idChain, new LiteralConstantExpression(primaryId!.ToString()!));
+        var idComparison = new ComparisonExpression(ComparisonOperator.Equals, idChain, new LiteralConstantExpression(primaryId!));
 
         return new HasExpression(new ResourceFieldChainExpression(inverseRelationship), idComparison);
     }
@@ -360,12 +360,12 @@ private IncludeExpression RewriteIncludeForSecondaryEndpoint(IncludeExpression?
 
         if (ids.Count == 1)
         {
-            var constant = new LiteralConstantExpression(ids.Single()!.ToString()!);
+            var constant = new LiteralConstantExpression(ids.Single()!);
             filter = new ComparisonExpression(ComparisonOperator.Equals, idChain, constant);
         }
         else if (ids.Count > 1)
         {
-            ImmutableHashSet<LiteralConstantExpression> constants = ids.Select(id => new LiteralConstantExpression(id!.ToString()!)).ToImmutableHashSet();
+            ImmutableHashSet<LiteralConstantExpression> constants = ids.Select(id => new LiteralConstantExpression(id!)).ToImmutableHashSet();
             filter = new AnyExpression(idChain, constants);
         }