Added support for passing a filter condition as second argument to the has() function.

Bart Koelman · Bart Koelman · commit 83db3a2f9bd3 · 2021-05-02T22:41:17.000+02:00
Example: GET /blogs?filter=has(posts,not(equals(url,null)))
diff --git a/docs/usage/reading/filtering.md b/docs/usage/reading/filtering.md
@@ -74,6 +74,16 @@ Putting it all together, you can build quite complex filters, such as:
 GET /blogs?include=owner.articles.revisions&filter=and(or(equals(title,'Technology'),has(owner.articles)),not(equals(owner.lastName,null)))&filter[owner.articles]=equals(caption,'Two')&filter[owner.articles.revisions]=greaterThan(publishTime,'2005-05-05') HTTP/1.1
 ```
 
+_since v4.2_
+
+The `has` function takes an optional filter condition as second parameter, for example:
+
+```http
+GET /customers?filter=has(orders,not(equals(status,'Paid'))) HTTP/1.1
+```
+
+Which returns only customers that have at least one unpaid order.
+
 # Legacy filters
 
 The next section describes how filtering worked in versions prior to v4.0. They are always applied on the set of resources being requested (no nesting).
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/CollectionNotEmptyExpression.cs b/src/JsonApiDotNetCore/Queries/Expressions/CollectionNotEmptyExpression.cs
@@ -1,21 +1,25 @@
+using System;
+using System.Text;
 using JetBrains.Annotations;
 using JsonApiDotNetCore.Queries.Internal.Parsing;
 
 namespace JsonApiDotNetCore.Queries.Expressions
 {
     /// <summary>
-    /// Represents the "has" filter function, resulting from text such as: has(articles)
+    /// Represents the "has" filter function, resulting from text such as: has(articles) or has(articles,equals(isHidden,'false'))
     /// </summary>
     [PublicAPI]
     public class CollectionNotEmptyExpression : FilterExpression
     {
         public ResourceFieldChainExpression TargetCollection { get; }
+        public FilterExpression Filter { get; }
 
-        public CollectionNotEmptyExpression(ResourceFieldChainExpression targetCollection)
+        public CollectionNotEmptyExpression(ResourceFieldChainExpression targetCollection, FilterExpression filter)
         {
             ArgumentGuard.NotNull(targetCollection, nameof(targetCollection));
 
             TargetCollection = targetCollection;
+            Filter = filter;
         }
 
         public override TResult Accept<TArgument, TResult>(QueryExpressionVisitor<TArgument, TResult> visitor, TArgument argument)
@@ -25,7 +29,20 @@ public override TResult Accept<TArgument, TResult>(QueryExpressionVisitor<TArgum
 
         public override string ToString()
         {
-            return $"{Keywords.Has}({TargetCollection})";
+            var builder = new StringBuilder();
+            builder.Append(Keywords.Has);
+            builder.Append('(');
+            builder.Append(TargetCollection);
+
+            if (Filter != null)
+            {
+                builder.Append(',');
+                builder.Append(Filter);
+            }
+
+            builder.Append(')');
+
+            return builder.ToString();
         }
 
         public override bool Equals(object obj)
@@ -42,12 +59,12 @@ public override bool Equals(object obj)
 
             var other = (CollectionNotEmptyExpression)obj;
 
-            return TargetCollection.Equals(other.TargetCollection);
+            return TargetCollection.Equals(other.TargetCollection) && Equals(Filter, other.Filter);
         }
 
         public override int GetHashCode()
         {
-            return TargetCollection.GetHashCode();
+            return HashCode.Combine(TargetCollection, Filter);
         }
     }
 }
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/QueryExpressionRewriter.cs b/src/JsonApiDotNetCore/Queries/Expressions/QueryExpressionRewriter.cs
@@ -93,7 +93,9 @@ public override QueryExpression VisitCollectionNotEmpty(CollectionNotEmptyExpres
             {
                 if (Visit(expression.TargetCollection, argument) is ResourceFieldChainExpression newTargetCollection)
                 {
-                    var newExpression = new CollectionNotEmptyExpression(newTargetCollection);
+                    FilterExpression newFilter = expression.Filter != null ? Visit(expression.Filter, argument) as FilterExpression : null;
+
+                    var newExpression = new CollectionNotEmptyExpression(newTargetCollection, newFilter);
                     return newExpression.Equals(expression) ? expression : newExpression;
                 }
             }
diff --git a/src/JsonApiDotNetCore/Queries/Internal/Parsing/FilterParser.cs b/src/JsonApiDotNetCore/Queries/Internal/Parsing/FilterParser.cs
@@ -14,6 +14,7 @@ namespace JsonApiDotNetCore.Queries.Internal.Parsing
     [PublicAPI]
     public class FilterParser : QueryExpressionParser
     {
+        private readonly IResourceContextProvider _resourceContextProvider;
         private readonly IResourceFactory _resourceFactory;
         private readonly Action<ResourceFieldAttribute, ResourceContext, string> _validateSingleFieldCallback;
         private ResourceContext _resourceContextInScope;
@@ -22,8 +23,10 @@ public FilterParser(IResourceContextProvider resourceContextProvider, IResourceF
             Action<ResourceFieldAttribute, ResourceContext, string> validateSingleFieldCallback = null)
             : base(resourceContextProvider)
         {
+            ArgumentGuard.NotNull(resourceContextProvider, nameof(resourceContextProvider));
             ArgumentGuard.NotNull(resourceFactory, nameof(resourceFactory));
 
+            _resourceContextProvider = resourceContextProvider;
             _resourceFactory = resourceFactory;
             _validateSingleFieldCallback = validateSingleFieldCallback;
         }
@@ -234,10 +237,31 @@ protected CollectionNotEmptyExpression ParseHas()
             EatSingleCharacterToken(TokenKind.OpenParen);
 
             ResourceFieldChainExpression targetCollection = ParseFieldChain(FieldChainRequirements.EndsInToMany, null);
+            FilterExpression filter = null;
+
+            if (TokenStack.TryPeek(out Token nextToken) && nextToken.Kind == TokenKind.Comma)
+            {
+                EatSingleCharacterToken(TokenKind.Comma);
+
+                filter = ParseFilterInHas((HasManyAttribute)targetCollection.Fields.Last());
+            }
 
             EatSingleCharacterToken(TokenKind.CloseParen);
 
-            return new CollectionNotEmptyExpression(targetCollection);
+            return new CollectionNotEmptyExpression(targetCollection, filter);
+        }
+
+        private FilterExpression ParseFilterInHas(HasManyAttribute hasManyRelationship)
+        {
+            ResourceContext outerScopeBackup = _resourceContextInScope;
+
+            Type innerResourceType = hasManyRelationship.RightType;
+            _resourceContextInScope = _resourceContextProvider.GetResourceContext(innerResourceType);
+
+            FilterExpression filter = ParseFilter();
+
+            _resourceContextInScope = outerScopeBackup;
+            return filter;
         }
 
         protected QueryExpression ParseCountOrField(FieldChainRequirements chainRequirements)
diff --git a/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/QueryableBuilder.cs b/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/QueryableBuilder.cs
@@ -93,7 +93,7 @@ protected virtual Expression ApplyFilter(Expression source, FilterExpression fil
         {
             using LambdaScope lambdaScope = _lambdaScopeFactory.CreateScope(_elementType);
 
-            var builder = new WhereClauseBuilder(source, lambdaScope, _extensionType);
+            var builder = new WhereClauseBuilder(source, lambdaScope, _extensionType, _nameFactory);
             return builder.ApplyWhere(filter);
         }
 
diff --git a/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/WhereClauseBuilder.cs b/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/WhereClauseBuilder.cs
@@ -23,27 +23,35 @@ public class WhereClauseBuilder : QueryClauseBuilder<Type>
 
         private readonly Expression _source;
         private readonly Type _extensionType;
+        private readonly LambdaParameterNameFactory _nameFactory;
 
-        public WhereClauseBuilder(Expression source, LambdaScope lambdaScope, Type extensionType)
+        public WhereClauseBuilder(Expression source, LambdaScope lambdaScope, Type extensionType, LambdaParameterNameFactory nameFactory)
             : base(lambdaScope)
         {
             ArgumentGuard.NotNull(source, nameof(source));
             ArgumentGuard.NotNull(extensionType, nameof(extensionType));
+            ArgumentGuard.NotNull(nameFactory, nameof(nameFactory));
 
             _source = source;
             _extensionType = extensionType;
+            _nameFactory = nameFactory;
         }
 
         public Expression ApplyWhere(FilterExpression filter)
         {
             ArgumentGuard.NotNull(filter, nameof(filter));
 
-            Expression body = Visit(filter, null);
-            LambdaExpression lambda = Expression.Lambda(body, LambdaScope.Parameter);
+            LambdaExpression lambda = GetPredicateLambda(filter);
 
             return WhereExtensionMethodCall(lambda);
         }
 
+        private LambdaExpression GetPredicateLambda(FilterExpression filter)
+        {
+            Expression body = Visit(filter, null);
+            return Expression.Lambda(body, LambdaScope.Parameter);
+        }
+
         private Expression WhereExtensionMethodCall(LambdaExpression predicate)
         {
             return Expression.Call(_extensionType, "Where", LambdaScope.Parameter.Type.AsArray(), _source, predicate);
@@ -60,11 +68,28 @@ public override Expression VisitCollectionNotEmpty(CollectionNotEmptyExpression
                 throw new InvalidOperationException("Expression must be a collection.");
             }
 
-            return AnyExtensionMethodCall(elementType, property);
+            Expression predicate = null;
+
+            if (expression.Filter != null)
+            {
+                var hasManyThrough = expression.TargetCollection.Fields.Last() as HasManyThroughAttribute;
+                var lambdaScopeFactory = new LambdaScopeFactory(_nameFactory, hasManyThrough);
+                using LambdaScope lambdaScope = lambdaScopeFactory.CreateScope(elementType);
+
+                var builder = new WhereClauseBuilder(property, lambdaScope, typeof(Enumerable), _nameFactory);
+                predicate = builder.GetPredicateLambda(expression.Filter);
+            }
+
+            return AnyExtensionMethodCall(elementType, property, predicate);
         }
 
-        private static MethodCallExpression AnyExtensionMethodCall(Type elementType, Expression source)
+        private static MethodCallExpression AnyExtensionMethodCall(Type elementType, Expression source, Expression predicate)
         {
+            if (predicate != null)
+            {
+                return Expression.Call(typeof(Enumerable), "Any", elementType.AsArray(), source, predicate);
+            }
+
             return Expression.Call(typeof(Enumerable), "Any", elementType.AsArray(), source);
         }
 
@@ -276,6 +301,8 @@ protected override MemberExpression CreatePropertyExpressionForFieldChain(IReadO
 
         private static string GetPropertyName(ResourceFieldAttribute field)
         {
+            // TODO: Is this still true when using has() with a filter?
+
             // In case of a HasManyThrough access (from count() or has() function), we only need to look at the number of entries in the join table.
             return field is HasManyThroughAttribute hasManyThrough ? hasManyThrough.ThroughProperty.Name : field.Property.Name;
         }
diff --git a/test/JsonApiDotNetCoreExampleTests/IntegrationTests/QueryStrings/Filtering/FilterDepthTests.cs b/test/JsonApiDotNetCoreExampleTests/IntegrationTests/QueryStrings/Filtering/FilterDepthTests.cs
@@ -202,6 +202,35 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             responseDocument.ManyData[0].Id.Should().Be(blogs[1].StringId);
         }
 
+        [Fact]
+        public async Task Can_filter_on_HasMany_relationship_with_nested_condition()
+        {
+            // Arrange
+            List<Blog> blogs = _fakers.Blog.Generate(2);
+            blogs[0].Posts = _fakers.BlogPost.Generate(1);
+            blogs[1].Posts = _fakers.BlogPost.Generate(1);
+            blogs[1].Posts[0].Comments = _fakers.Comment.Generate(1).ToHashSet();
+            blogs[1].Posts[0].Comments.ElementAt(0).Text = "ABC";
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                await dbContext.ClearTableAsync<Blog>();
+                dbContext.Blogs.AddRange(blogs);
+                await dbContext.SaveChangesAsync();
+            });
+
+            const string route = "/blogs?filter=has(posts,has(comments,startsWith(text,'A')))";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecuteGetAsync<Document>(route);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
+
+            responseDocument.ManyData.Should().HaveCount(1);
+            responseDocument.ManyData[0].Id.Should().Be(blogs[1].StringId);
+        }
+
         [Fact]
         public async Task Can_filter_on_HasManyThrough_relationship()
         {
@@ -235,6 +264,44 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             responseDocument.ManyData[0].Id.Should().Be(posts[1].StringId);
         }
 
+        [Fact]
+        public async Task Can_filter_on_HasManyThrough_relationship_with_nested_condition()
+        {
+            // Arrange
+            List<Blog> blogs = _fakers.Blog.Generate(2);
+            blogs[0].Posts = _fakers.BlogPost.Generate(1);
+            blogs[1].Posts = _fakers.BlogPost.Generate(1);
+
+            blogs[1].Posts[0].BlogPostLabels = new HashSet<BlogPostLabel>
+            {
+                new BlogPostLabel
+                {
+                    Label = new Label
+                    {
+                        Color = LabelColor.Green
+                    }
+                }
+            };
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                await dbContext.ClearTableAsync<Blog>();
+                dbContext.Blogs.AddRange(blogs);
+                await dbContext.SaveChangesAsync();
+            });
+
+            const string route = "/blogs?filter=has(posts,has(labels,equals(color,'Green')))";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecuteGetAsync<Document>(route);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
+
+            responseDocument.ManyData.Should().HaveCount(1);
+            responseDocument.ManyData[0].Id.Should().Be(blogs[1].StringId);
+        }
+
         [Fact]
         public async Task Can_filter_in_scope_of_HasMany_relationship()
         {
diff --git a/test/JsonApiDotNetCoreExampleTests/IntegrationTests/QueryStrings/Filtering/FilterOperatorTests.cs b/test/JsonApiDotNetCoreExampleTests/IntegrationTests/QueryStrings/Filtering/FilterOperatorTests.cs
@@ -489,6 +489,53 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             responseDocument.ManyData[0].Id.Should().Be(resource.StringId);
         }
 
+        [Fact]
+        public async Task Can_filter_on_has_with_nested_condition()
+        {
+            // Arrange
+            var resources = new List<FilterableResource>
+            {
+                new FilterableResource
+                {
+                    Children = new List<FilterableResource>
+                    {
+                        new FilterableResource
+                        {
+                            SomeBoolean = false
+                        }
+                    }
+                },
+                new FilterableResource
+                {
+                    Children = new List<FilterableResource>
+                    {
+                        new FilterableResource
+                        {
+                            SomeBoolean = true
+                        }
+                    }
+                }
+            };
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                await dbContext.ClearTableAsync<FilterableResource>();
+                dbContext.FilterableResources.AddRange(resources);
+                await dbContext.SaveChangesAsync();
+            });
+
+            const string route = "/filterableResources?filter=has(children,equals(someBoolean,'true'))";
+
+            // Act
+            (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecuteGetAsync<Document>(route);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
+
+            responseDocument.ManyData.Should().HaveCount(1);
+            responseDocument.ManyData[0].Id.Should().Be(resources[1].StringId);
+        }
+
         [Fact]
         public async Task Can_filter_on_count()
         {
diff --git a/test/JsonApiDotNetCoreExampleTests/UnitTests/QueryStringParameters/FilterParseTests.cs b/test/JsonApiDotNetCoreExampleTests/UnitTests/QueryStringParameters/FilterParseTests.cs
@@ -78,6 +78,7 @@ public void Reader_Is_Enabled(StandardQueryStringParameters parametersDisabled,
         [InlineData("filter", "equals(null", "Field 'null' does not exist on resource 'blogs'.")]
         [InlineData("filter", "equals(title,(", "Count function, value between quotes, null or field name expected.")]
         [InlineData("filter", "equals(has(posts),'true')", "Field 'has' does not exist on resource 'blogs'.")]
+        [InlineData("filter", "has(posts,", "Filter function expected.")]
         [InlineData("filter", "contains)", "( expected.")]
         [InlineData("filter", "contains(title,'a','b')", ") expected.")]
         [InlineData("filter", "contains(title,null)", "Value between quotes expected.")]
@@ -125,14 +126,15 @@ public void Reader_Read_Fails(string parameterName, string parameterValue, strin
         [InlineData("filter[posts.comments]", "greaterThan(createdAt,'2000-01-01')", "posts.comments", "greaterThan(createdAt,'2000-01-01')")]
         [InlineData("filter[posts.comments]", "greaterOrEqual(createdAt,'2000-01-01')", "posts.comments", "greaterOrEqual(createdAt,'2000-01-01')")]
         [InlineData("filter", "has(posts)", null, "has(posts)")]
+        [InlineData("filter", "has(posts,not(equals(url,null)))", null, "has(posts,not(equals(url,null)))")]
         [InlineData("filter", "contains(title,'this')", null, "contains(title,'this')")]
         [InlineData("filter", "startsWith(title,'this')", null, "startsWith(title,'this')")]
         [InlineData("filter", "endsWith(title,'this')", null, "endsWith(title,'this')")]
         [InlineData("filter", "any(title,'this','that','there')", null, "any(title,'this','that','there')")]
         [InlineData("filter", "and(contains(title,'sales'),contains(title,'marketing'),contains(title,'advertising'))", null,
             "and(contains(title,'sales'),contains(title,'marketing'),contains(title,'advertising'))")]
-        [InlineData("filter[posts]", "or(and(not(equals(author.userName,null)),not(equals(author.displayName,null))),not(has(comments)))", "posts",
-            "or(and(not(equals(author.userName,null)),not(equals(author.displayName,null))),not(has(comments)))")]
+        [InlineData("filter[posts]", "or(and(not(equals(author.userName,null)),not(equals(author.displayName,null))),not(has(comments,startsWith(text,'A'))))",
+            "posts", "or(and(not(equals(author.userName,null)),not(equals(author.displayName,null))),not(has(comments,startsWith(text,'A'))))")]
         public void Reader_Read_Succeeds(string parameterName, string parameterValue, string scopeExpected, string valueExpected)
         {
             // Act

Original file line number	Diff line number	Diff line change
`@@ -1,21 +1,25 @@`
	`1`	`+using System;`
	`2`	`+using System.Text;`
`1`	`3`	`using JetBrains.Annotations;`
`2`	`4`	`using JsonApiDotNetCore.Queries.Internal.Parsing;`
`3`	`5`
`4`	`6`	`namespace JsonApiDotNetCore.Queries.Expressions`
`5`	`7`	`{`
`6`	`8`	`/// <summary>`
`7`		`- /// Represents the "has" filter function, resulting from text such as: has(articles)`
	`9`	`+ /// Represents the "has" filter function, resulting from text such as: has(articles) or has(articles,equals(isHidden,'false'))`
`8`	`10`	`/// </summary>`
`9`	`11`	`[PublicAPI]`
`10`	`12`	`public class CollectionNotEmptyExpression : FilterExpression`
`11`	`13`	`{`
`12`	`14`	`public ResourceFieldChainExpression TargetCollection { get; }`
	`15`	`+ public FilterExpression Filter { get; }`
`13`	`16`
`14`		`- public CollectionNotEmptyExpression(ResourceFieldChainExpression targetCollection)`
	`17`	`+ public CollectionNotEmptyExpression(ResourceFieldChainExpression targetCollection, FilterExpression filter)`
`15`	`18`	`{`
`16`	`19`	`ArgumentGuard.NotNull(targetCollection, nameof(targetCollection));`
`17`	`20`
`18`	`21`	`TargetCollection = targetCollection;`
	`22`	`+ Filter = filter;`
`19`	`23`	`}`
`20`	`24`
`21`	`25`	`public override TResult Accept<TArgument, TResult>(QueryExpressionVisitor<TArgument, TResult> visitor, TArgument argument)`
`@@ -25,7 +29,20 @@ public override TResult Accept<TArgument, TResult>(QueryExpressionVisitor<TArgum`
`25`	`29`
`26`	`30`	`public override string ToString()`
`27`	`31`	`{`
`28`		`- return $"{Keywords.Has}({TargetCollection})";`
	`32`	`+ var builder = new StringBuilder();`
	`33`	`+ builder.Append(Keywords.Has);`
	`34`	`+ builder.Append('(');`
	`35`	`+ builder.Append(TargetCollection);`
	`36`	`+`
	`37`	`+ if (Filter != null)`
	`38`	`+ {`
	`39`	`+ builder.Append(',');`
	`40`	`+ builder.Append(Filter);`
	`41`	`+ }`
	`42`	`+`
	`43`	`+ builder.Append(')');`
	`44`	`+`
	`45`	`+ return builder.ToString();`
`29`	`46`	`}`
`30`	`47`
`31`	`48`	`public override bool Equals(object obj)`
`@@ -42,12 +59,12 @@ public override bool Equals(object obj)`
`42`	`59`
`43`	`60`	`var other = (CollectionNotEmptyExpression)obj;`
`44`	`61`
`45`		`- return TargetCollection.Equals(other.TargetCollection);`
	`62`	`+ return TargetCollection.Equals(other.TargetCollection) && Equals(Filter, other.Filter);`
`46`	`63`	`}`
`47`	`64`
`48`	`65`	`public override int GetHashCode()`
`49`	`66`	`{`
`50`		`- return TargetCollection.GetHashCode();`
	`67`	`+ return HashCode.Combine(TargetCollection, Filter);`
`51`	`68`	`}`
`52`	`69`	`}`
`53`	`70`	`}`
Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,9 @@ public override QueryExpression VisitCollectionNotEmpty(CollectionNotEmptyExpres`
`93`	`93`	`{`
`94`	`94`	`if (Visit(expression.TargetCollection, argument) is ResourceFieldChainExpression newTargetCollection)`
`95`	`95`	`{`
`96`		`- var newExpression = new CollectionNotEmptyExpression(newTargetCollection);`
	`96`	`+ FilterExpression newFilter = expression.Filter != null ? Visit(expression.Filter, argument) as FilterExpression : null;`
	`97`	`+`
	`98`	`+ var newExpression = new CollectionNotEmptyExpression(newTargetCollection, newFilter);`
`97`	`99`	`return newExpression.Equals(expression) ? expression : newExpression;`
`98`	`100`	`}`
`99`	`101`	`}`
Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ protected virtual Expression ApplyFilter(Expression source, FilterExpression fil`
`93`	`93`	`{`
`94`	`94`	`using LambdaScope lambdaScope = _lambdaScopeFactory.CreateScope(_elementType);`
`95`	`95`
`96`		`- var builder = new WhereClauseBuilder(source, lambdaScope, _extensionType);`
	`96`	`+ var builder = new WhereClauseBuilder(source, lambdaScope, _extensionType, _nameFactory);`
`97`	`97`	`return builder.ApplyWhere(filter);`
`98`	`98`	`}`
`99`	`99`