Resource inheritance: derived filters

Author: Bart Koelman

src/JsonApiDotNetCore/Queries/Expressions/IsTypeExpression.cs

@@ -0,0 +1,78 @@
+using System.Text;
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Queries.Internal.Parsing;
+
+namespace JsonApiDotNetCore.Queries.Expressions;
+
+/// <summary>
+/// Represents the "isType" filter function, resulting from text such as: isType(,men), isType(creator,men) or
+/// isType(creator,men,equals(hasBeard,'true'))
+/// </summary>
+[PublicAPI]
+public class IsTypeExpression : FilterExpression
+{
+    public ResourceFieldChainExpression? TargetToOneRelationship { get; }
+    public ResourceType DerivedType { get; }
+    public FilterExpression? Child { get; }
+
+    public IsTypeExpression(ResourceFieldChainExpression? targetToOneRelationship, ResourceType derivedType, FilterExpression? child)
+    {
+        ArgumentGuard.NotNull(derivedType, nameof(derivedType));
+
+        TargetToOneRelationship = targetToOneRelationship;
+        DerivedType = derivedType;
+        Child = child;
+    }
+
+    public override TResult Accept<TArgument, TResult>(QueryExpressionVisitor<TArgument, TResult> visitor, TArgument argument)
+    {
+        return visitor.VisitIsType(this, argument);
+    }
+
+    public override string ToString()
+    {
+        var builder = new StringBuilder();
+        builder.Append(Keywords.IsType);
+        builder.Append('(');
+
+        if (TargetToOneRelationship != null)
+        {
+            builder.Append(TargetToOneRelationship);
+        }
+
+        builder.Append(',');
+        builder.Append(DerivedType);
+
+        if (Child != null)
+        {
+            builder.Append(',');
+            builder.Append(Child);
+        }
+
+        builder.Append(')');
+        return builder.ToString();
+    }
+
+    public override bool Equals(object? obj)
+    {
+        if (ReferenceEquals(this, obj))
+        {
+            return true;
+        }
+
+        if (obj is null || GetType() != obj.GetType())
+        {
+            return false;
+        }
+
+        var other = (IsTypeExpression)obj;
+
+        return Equals(TargetToOneRelationship, other.TargetToOneRelationship) && DerivedType.Equals(other.DerivedType) && Equals(Child, other.Child);
+    }
+
+    public override int GetHashCode()
+    {
+        return HashCode.Combine(TargetToOneRelationship, DerivedType, Child);
+    }
+}

src/JsonApiDotNetCore/Queries/Expressions/QueryExpressionRewriter.cs

@@ -91,6 +91,18 @@ public override QueryExpression VisitNullConstant(NullConstantExpression express
         return null;
     }
 
+    public override QueryExpression VisitIsType(IsTypeExpression expression, TArgument argument)
+    {
+        ResourceFieldChainExpression? newTargetToOneRelationship = expression.TargetToOneRelationship != null
+            ? Visit(expression.TargetToOneRelationship, argument) as ResourceFieldChainExpression
+            : null;
+
+        FilterExpression? newChild = expression.Child != null ? Visit(expression.Child, argument) as FilterExpression : null;
+
+        var newExpression = new IsTypeExpression(newTargetToOneRelationship, expression.DerivedType, newChild);
+        return newExpression.Equals(expression) ? expression : newExpression;
+    }
+
     public override QueryExpression? VisitSortElement(SortElementExpression expression, TArgument argument)
     {
         SortElementExpression? newExpression = null;

src/JsonApiDotNetCore/Queries/Expressions/QueryExpressionVisitor.cs

@@ -53,6 +53,11 @@ public virtual TResult VisitHas(HasExpression expression, TArgument argument)
         return DefaultVisit(expression, argument);
     }
 
+    public virtual TResult VisitIsType(IsTypeExpression expression, TArgument argument)
+    {
+        return DefaultVisit(expression, argument);
+    }
+
     public virtual TResult VisitSortElement(SortElementExpression expression, TArgument argument)
     {
         return DefaultVisit(expression, argument);

src/JsonApiDotNetCore/Queries/Internal/Parsing/FilterParser.cs

@@ -28,15 +28,16 @@ public FilterExpression Parse(string source, ResourceType resourceTypeInScope)
     {
         ArgumentGuard.NotNull(resourceTypeInScope, nameof(resourceTypeInScope));
 
-        _resourceTypeInScope = resourceTypeInScope;
-
-        Tokenize(source);
+        return InScopeOfResourceType(resourceTypeInScope, () =>
+        {
+            Tokenize(source);
 
-        FilterExpression expression = ParseFilter();
+            FilterExpression expression = ParseFilter();
 
-        AssertTokenStackIsEmpty();
+            AssertTokenStackIsEmpty();
 
-        return expression;
+            return expression;
+        });
     }
 
     protected FilterExpression ParseFilter()
@@ -76,6 +77,10 @@ protected FilterExpression ParseFilter()
                 {
                     return ParseHas();
                 }
+                case Keywords.IsType:
+                {
+                    return ParseIsType();
+                }
             }
         }
 
@@ -259,13 +264,92 @@ protected HasExpression ParseHas()
 
     private FilterExpression ParseFilterInHas(HasManyAttribute hasManyRelationship)
     {
-        ResourceType outerScopeBackup = _resourceTypeInScope!;
+        return InScopeOfResourceType(hasManyRelationship.RightType, ParseFilter);
+    }
+
+    private IsTypeExpression ParseIsType()
+    {
+        EatText(Keywords.IsType);
+        EatSingleCharacterToken(TokenKind.OpenParen);
+
+        ResourceFieldChainExpression? targetToOneRelationship = TryParseToOneRelationshipChain();
+
+        EatSingleCharacterToken(TokenKind.Comma);
+
+        ResourceType baseType = targetToOneRelationship != null ? ((RelationshipAttribute)targetToOneRelationship.Fields[^1]).RightType : _resourceTypeInScope!;
+        ResourceType derivedType = ParseDerivedType(baseType);
+
+        FilterExpression? child = TryParseFilterInIsType(derivedType);
+
+        EatSingleCharacterToken(TokenKind.CloseParen);
+
+        return new IsTypeExpression(targetToOneRelationship, derivedType, child);
+    }
+
+    private ResourceFieldChainExpression? TryParseToOneRelationshipChain()
+    {
+        if (TokenStack.TryPeek(out Token? nextToken) && nextToken.Kind == TokenKind.Comma)
+        {
+            return null;
+        }
+
+        return ParseFieldChain(FieldChainRequirements.EndsInToOne, "Relationship name or , expected.");
+    }
+
+    private ResourceType ParseDerivedType(ResourceType baseType)
+    {
+        if (TokenStack.TryPop(out Token? token) && token.Kind == TokenKind.Text)
+        {
+            string derivedTypeName = token.Value!;
+            return ResolveDerivedType(baseType, derivedTypeName);
+        }
+
+        throw new QueryParseException("Resource type expected.");
+    }
+
+    private ResourceType ResolveDerivedType(ResourceType baseType, string derivedTypeName)
+    {
+        ResourceType? derivedType = GetDerivedType(baseType, derivedTypeName);
+
+        if (derivedType == null)
+        {
+            throw new QueryParseException($"Resource type '{derivedTypeName}' does not exist or does not derive from '{baseType.PublicName}'.");
+        }
+
+        return derivedType;
+    }
+
+    private ResourceType? GetDerivedType(ResourceType baseType, string publicName)
+    {
+        foreach (ResourceType derivedType in baseType.DirectlyDerivedTypes)
+        {
+            if (derivedType.PublicName == publicName)
+            {
+                return derivedType;
+            }
+
+            ResourceType? nextType = GetDerivedType(derivedType, publicName);
+
+            if (nextType != null)
+            {
+                return nextType;
+            }
+        }
+
+        return null;
+    }
+
+    private FilterExpression? TryParseFilterInIsType(ResourceType derivedType)
+    {
+        FilterExpression? filter = null;
 
-        _resourceTypeInScope = hasManyRelationship.RightType;
+        if (TokenStack.TryPeek(out Token? nextToken) && nextToken.Kind == TokenKind.Comma)
+        {
+            EatSingleCharacterToken(TokenKind.Comma);
 
-        FilterExpression filter = ParseFilter();
+            filter = InScopeOfResourceType(derivedType, ParseFilter);
+        }
 
-        _resourceTypeInScope = outerScopeBackup;
         return filter;
     }
 
@@ -349,11 +433,31 @@ protected override IImmutableList<ResourceFieldAttribute> OnResolveFieldChain(st
             return ChainResolver.ResolveToOneChainEndingInAttribute(_resourceTypeInScope!, path, _validateSingleFieldCallback);
         }
 
+        if (chainRequirements == FieldChainRequirements.EndsInToOne)
+        {
+            return ChainResolver.ResolveToOneChain(_resourceTypeInScope!, path, _validateSingleFieldCallback);
+        }
+
         if (chainRequirements.HasFlag(FieldChainRequirements.EndsInAttribute) && chainRequirements.HasFlag(FieldChainRequirements.EndsInToOne))
         {
             return ChainResolver.ResolveToOneChainEndingInAttributeOrToOne(_resourceTypeInScope!, path, _validateSingleFieldCallback);
         }
 
         throw new InvalidOperationException($"Unexpected combination of chain requirement flags '{chainRequirements}'.");
     }
+
+    private TResult InScopeOfResourceType<TResult>(ResourceType resourceType, Func<TResult> action)
+    {
+        ResourceType? backupType = _resourceTypeInScope;
+
+        try
+        {
+            _resourceTypeInScope = resourceType;
+            return action();
+        }
+        finally
+        {
+            _resourceTypeInScope = backupType;
+        }
+    }
 }

src/JsonApiDotNetCore/Queries/Internal/Parsing/Keywords.cs

@@ -23,4 +23,5 @@ public static class Keywords
     public const string Any = "any";
     public const string Count = "count";
     public const string Has = "has";
+    public const string IsType = "isType";
 }

src/JsonApiDotNetCore/Queries/Internal/Parsing/ResourceFieldChainResolver.cs

@@ -9,6 +9,32 @@ namespace JsonApiDotNetCore.Queries.Internal.Parsing;
 /// </summary>
 internal sealed class ResourceFieldChainResolver
 {
+    /// <summary>
+    /// Resolves a chain of to-one relationships.
+    /// <example>author</example>
+    /// <example>
+    /// author.address.country
+    /// </example>
+    /// </summary>
+    public IImmutableList<ResourceFieldAttribute> ResolveToOneChain(ResourceType resourceType, string path,
+        Action<ResourceFieldAttribute, ResourceType, string>? validateCallback = null)
+    {
+        ImmutableArray<ResourceFieldAttribute>.Builder chainBuilder = ImmutableArray.CreateBuilder<ResourceFieldAttribute>();
+        ResourceType nextResourceType = resourceType;
+
+        foreach (string publicName in path.Split("."))
+        {
+            RelationshipAttribute toOneRelationship = GetToOneRelationship(publicName, nextResourceType, path);
+
+            validateCallback?.Invoke(toOneRelationship, nextResourceType, path);
+
+            chainBuilder.Add(toOneRelationship);
+            nextResourceType = toOneRelationship.RightType;
+        }
+
+        return chainBuilder.ToImmutable();
+    }
+
     /// <summary>
     /// Resolves a chain of relationships that ends in a to-many relationship, for example: blogs.owner.articles.comments
     /// </summary>

src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/LambdaScope.cs

@@ -14,15 +14,30 @@ public sealed class LambdaScope : IDisposable
     public ParameterExpression Parameter { get; }
     public Expression Accessor { get; }
 
-    public LambdaScope(LambdaParameterNameFactory nameFactory, Type elementType, Expression? accessorExpression)
+    private LambdaScope(LambdaParameterNameScope parameterNameScope, ParameterExpression parameter, Expression accessor)
+    {
+        _parameterNameScope = parameterNameScope;
+        Parameter = parameter;
+        Accessor = accessor;
+    }
+
+    public static LambdaScope Create(LambdaParameterNameFactory nameFactory, Type elementType, Expression? accessorExpression)
     {
         ArgumentGuard.NotNull(nameFactory, nameof(nameFactory));
         ArgumentGuard.NotNull(elementType, nameof(elementType));
 
-        _parameterNameScope = nameFactory.Create(elementType.Name);
-        Parameter = Expression.Parameter(elementType, _parameterNameScope.Name);
+        LambdaParameterNameScope parameterNameScope = nameFactory.Create(elementType.Name);
+        ParameterExpression parameter = Expression.Parameter(elementType, parameterNameScope.Name);
+        Expression accessor = accessorExpression ?? parameter;
+
+        return new LambdaScope(parameterNameScope, parameter, accessor);
+    }
+
+    public LambdaScope WithAccessor(Expression accessorExpression)
+    {
+        ArgumentGuard.NotNull(accessorExpression, nameof(accessorExpression));
 
-        Accessor = accessorExpression ?? Parameter;
+        return new LambdaScope(_parameterNameScope, Parameter, accessorExpression);
     }
 
     public void Dispose()

src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/LambdaScopeFactory.cs

@@ -19,6 +19,6 @@ public LambdaScope CreateScope(Type elementType, Expression? accessorExpression
     {
         ArgumentGuard.NotNull(elementType, nameof(elementType));
 
-        return new LambdaScope(_nameFactory, elementType, accessorExpression);
+        return LambdaScope.Create(_nameFactory, elementType, accessorExpression);
     }
 }

src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/QueryClauseBuilder.cs

@@ -9,7 +9,7 @@ namespace JsonApiDotNetCore.Queries.Internal.QueryableBuilding;
 /// </summary>
 public abstract class QueryClauseBuilder<TArgument> : QueryExpressionVisitor<TArgument, Expression>
 {
-    protected LambdaScope LambdaScope { get; }
+    protected LambdaScope LambdaScope { get; private set; }
 
     protected QueryClauseBuilder(LambdaScope lambdaScope)
     {
@@ -83,4 +83,24 @@ private static MemberExpression CreatePropertyExpressionFromComponents(Expressio
 
         return property!;
     }
+
+    protected TResult WithLambdaScopeAccessor<TResult>(Expression accessorExpression, Func<TResult> action)
+    {
+        ArgumentGuard.NotNull(accessorExpression, nameof(accessorExpression));
+        ArgumentGuard.NotNull(action, nameof(action));
+
+        LambdaScope backupScope = LambdaScope;
+
+        try
+        {
+            using (LambdaScope = LambdaScope.WithAccessor(accessorExpression))
+            {
+                return action();
+            }
+        }
+        finally
+        {
+            LambdaScope = backupScope;
+        }
+    }
 }

src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/SelectClauseBuilder.cs

@@ -194,7 +194,8 @@ private static void IncludeEagerLoads(ResourceType resourceType, Dictionary<Prop
 
     private MemberAssignment CreatePropertyAssignment(PropertySelector propertySelector, LambdaScope lambdaScope)
     {
-        bool requiresUpCast = !propertySelector.Property.DeclaringType!.IsAssignableFrom(lambdaScope.Accessor.Type);
+        bool requiresUpCast = lambdaScope.Accessor.Type != propertySelector.Property.DeclaringType &&
+            lambdaScope.Accessor.Type.IsAssignableFrom(propertySelector.Property.DeclaringType);
 
         MemberExpression propertyAccess = requiresUpCast
             ? Expression.MakeMemberAccess(Expression.Convert(lambdaScope.Accessor, propertySelector.Property.DeclaringType!), propertySelector.Property)