Backport "Allow empty filter expressions to be visited #5214" to 12 (#…

…5293)

src/HotChocolate/Data/src/Data/Filters/Expressions/QueryableCombinator.cs

@@ -16,7 +16,8 @@ public override bool TryCombineOperations(
     {
         if (operations.Count == 0)
         {
-            throw ThrowHelper.Filtering_QueryableCombinator_QueueEmpty(this);
+             combined = default!;
+             return false;
         }
 
         combined = operations.Dequeue();

src/HotChocolate/Data/test/Data.Filters.InMemory.Tests/__snapshots__/QueryableFilterCombinatorTests.Create_Empty_Expression_true.snap

@@ -0,0 +1,12 @@
+{
+  "data": {
+    "root": [
+      {
+        "bar": true
+      },
+      {
+        "bar": false
+      }
+    ]
+  }
+}

src/HotChocolate/Data/test/Data.Filters.InMemory.Tests/asd.cs

@@ -0,0 +1,54 @@
+using System.Threading.Tasks;
+using HotChocolate.Execution;
+using Snapshooter;
+using Snapshooter.Xunit;
+using Xunit;
+
+namespace HotChocolate.Data.Filters;
+
+public class QueryableFilterCombinatorTests
+{
+    private static readonly Foo[] _fooEntities = { new() { Bar = true }, new() { Bar = false } };
+
+    private readonly SchemaCache _cache = new();
+
+    [Fact]
+    public async Task Create_Empty_Expression()
+    {
+        // arrange
+        var tester = _cache.CreateSchema<Foo, FooFilterInput>(_fooEntities);
+
+        // act
+        // assert
+        var res1 = await tester.ExecuteAsync(
+            QueryRequestBuilder.New()
+                .SetQuery("{ root(where: { }){ bar }}")
+                .Create());
+
+        res1.ToJson().MatchSnapshot(new SnapshotNameExtension("true"));
+    }
+
+    public class Foo
+    {
+        public int Id { get; set; }
+
+        public bool Bar { get; set; }
+    }
+
+    public class FooNullable
+    {
+        public int Id { get; set; }
+
+        public bool? Bar { get; set; }
+    }
+
+    public class FooFilterInput
+        : FilterInputType<Foo>
+    {
+    }
+
+    public class FooNullableFilterInput
+        : FilterInputType<FooNullable>
+    {
+    }
+}

src/HotChocolate/MongoDb/src/Data/Driver/MongoDbFilterDefinition.cs

@@ -7,6 +7,13 @@ namespace HotChocolate.Data.MongoDb
 {
     public abstract class MongoDbFilterDefinition : FilterDefinition<BsonDocument>
     {
+        private static readonly MongoDbFilterDefinition _empty = new MongoDbEmptyFilterDefinition();
+
+        /// <summary>
+        /// Gets an empty filter. An empty filter matches everything.
+        /// </summary>
+        public static new MongoDbFilterDefinition Empty => MongoDbFilterDefinition._empty;
+
         public abstract BsonDocument Render(
             IBsonSerializer documentSerializer,
             IBsonSerializerRegistry serializerRegistry);
@@ -52,5 +59,15 @@ public override BsonDocument Render(
                 return Render(documentSerializer, serializerRegistry);
             }
         }
+
+        internal sealed class MongoDbEmptyFilterDefinition : MongoDbFilterDefinition
+        {
+            public override BsonDocument Render(
+                IBsonSerializer documentSerializer,
+                IBsonSerializerRegistry serializerRegistry)
+            {
+                return new BsonDocument();
+            }
+        }
     }
 }

src/HotChocolate/MongoDb/src/Data/Extensions/MongoDbFilterScopeExtensions.cs

@@ -1,7 +1,5 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
-using MongoDB.Bson;
-using MongoDB.Driver;
 
 namespace HotChocolate.Data.MongoDb.Filters
 {
@@ -18,7 +16,8 @@ public static bool TryCreateQuery(
 
             if (scope.Level.Peek().Count == 0)
             {
-                return false;
+                query = MongoDbFilterDefinition.Empty;
+                return true;
             }
 
             query = new AndFilterDefinition(scope.Level.Peek().ToArray());

src/HotChocolate/MongoDb/src/Data/Filters/MongoDbFilterCombinator.cs

@@ -20,7 +20,8 @@ public override bool TryCombineOperations(
         {
             if (operations.Count == 0)
             {
-                throw ThrowHelper.Filtering_MongoDbCombinator_QueueEmpty(this);
+                 combined = default!;
+                 return false;
             }
 
             combined = combinator switch

src/HotChocolate/MongoDb/src/Data/Filters/MongoDbFilterProvider.cs

@@ -52,21 +52,18 @@ async ValueTask ExecuteAsync(
 
                     Visitor.Visit(filter, visitorContext);
 
-                    if (!visitorContext.TryCreateQuery(out MongoDbFilterDefinition? whereQuery) ||
-                        visitorContext.Errors.Count > 0)
+                    if (visitorContext.Errors.Count > 0)
                     {
                         context.Result = Array.Empty<TEntityType>();
                         foreach (IError error in visitorContext.Errors)
                         {
                             context.ReportError(error.WithPath(context.Path));
                         }
                     }
-                    else
+                    else if (visitorContext.TryCreateQuery(out MongoDbFilterDefinition? whereQuery))
                     {
-                        context.LocalContextData =
-                            context.LocalContextData.SetItem(
-                                nameof(FilterDefinition<TEntityType>),
-                                whereQuery);
+                        context.LocalContextData = context.LocalContextData
+                            .SetItem(nameof(FilterDefinition<TEntityType>), whereQuery);
 
                         await next(context).ConfigureAwait(false);
 

src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/HotChocolate.Data.MongoDb.Filters.Tests.csproj

@@ -12,6 +12,6 @@
 
   <ItemGroup>
     <PackageReference Include="Squadron.Mongo" Version="0.5.0" />
-    <PackageReference Include="MongoDB.Driver" Version="2.14.0"/>
+    <PackageReference Include="MongoDB.Driver" Version="2.14.0" />
   </ItemGroup>
 </Project>

src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/MongoDbFilterCombinatorTests.cs

@@ -0,0 +1,50 @@
+using HotChocolate.Data.Filters;
+using HotChocolate.Execution;
+using MongoDB.Bson.Serialization.Attributes;
+using Squadron;
+using Xunit;
+using System;
+using System.Threading.Tasks;
+
+namespace HotChocolate.Data.MongoDb.Filters;
+
+public class MongoDbFilterCombinatorTests
+    : SchemaCache
+    , IClassFixture<MongoResource>
+{
+    private static readonly Foo[] _fooEntities = { new() { Bar = true }, new() { Bar = false } };
+
+    public MongoDbFilterCombinatorTests(MongoResource resource)
+    {
+        Init(resource);
+    }
+
+    [Fact]
+    public async Task Create_Empty_Expression()
+    {
+        // arrange
+        var tester = CreateSchema<Foo, FooFilterInput>(_fooEntities);
+
+        // act
+        // assert
+        var res1 = await tester.ExecuteAsync(
+            QueryRequestBuilder.New()
+                .SetQuery("{ root(where: { }){ bar }}")
+                .Create());
+
+        res1.MatchDocumentSnapshot("res1");
+    }
+
+    public class Foo
+    {
+        [BsonId]
+        public Guid Id { get; set; } = Guid.NewGuid();
+
+        public bool Bar { get; set; }
+    }
+
+    public class FooFilterInput
+        : FilterInputType<Foo>
+    {
+    }
+}

src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/__snapshots__/MongoDbFilterCombinatorTests.Create_Empty_Expression_res1.snap

@@ -0,0 +1,12 @@
+{
+  "data": {
+    "root": [
+      {
+        "bar": true
+      },
+      {
+        "bar": false
+      }
+    ]
+  }
+}

src/HotChocolate/MongoDb/test/Data.MongoDb.Filters.Tests/__snapshots__/MongoDbFilterCombinatorTests.Create_Empty_Expression_res1_query.snap

@@ -0,0 +1 @@
+find({ })

src/HotChocolate/Neo4J/src/Data/Execution/Neo4JExecutable.cs

@@ -91,7 +91,11 @@ public Neo4JExecutable<T> WithLimit(int limit)
         /// <inheritdoc />
         public INeo4JExecutable WithFiltering(CompoundCondition filters)
         {
-            _filters = filters;
+            if (!filters.IsEmpty)
+            {
+                _filters = filters;
+            }
+
             return this;
         }
 

src/HotChocolate/Neo4J/src/Data/Filtering/Extensions/Neo4JFilterScopeExtensions.cs

@@ -17,7 +17,8 @@ public static bool TryCreateQuery(
 
             if (scope.Level.Peek().Count == 0)
             {
-                return false;
+                query = new CompoundCondition(null);
+                return true;
             }
 
             var conditions = new CompoundCondition(Operator.And);

src/HotChocolate/Neo4J/src/Data/Filtering/Neo4JFilterCombinator.cs

@@ -18,7 +18,8 @@ public override bool TryCombineOperations(
         {
             if (operations.Count == 0)
             {
-                throw ThrowHelper.Filtering_Neo4JFilterCombinator_QueueEmpty(this);
+                combined = default!;
+                return false;
             }
 
             combined = combinator switch

src/HotChocolate/Neo4J/src/Data/Filtering/Neo4JFilterProvider.cs

@@ -49,16 +49,15 @@ async ValueTask ExecuteAsync(
 
                     Visitor.Visit(filter, visitorContext);
 
-                    if (!visitorContext.TryCreateQuery(out CompoundCondition whereQuery) ||
-                        visitorContext.Errors.Count > 0)
+                    if (visitorContext.Errors.Count > 0)
                     {
                         context.Result = Array.Empty<TEntityType>();
                         foreach (IError error in visitorContext.Errors)
                         {
                             context.ReportError(error.WithPath(context.Path));
                         }
                     }
-                    else
+                    else if (visitorContext.TryCreateQuery(out CompoundCondition whereQuery))
                     {
                         context.LocalContextData =
                             context.LocalContextData.SetItem("Filter", whereQuery);

src/HotChocolate/Neo4J/src/Data/Language/CompoundCondition.cs

@@ -26,6 +26,8 @@ public CompoundCondition(Operator? op)
             _conditions = new List<Condition>();
         }
 
+        public bool IsEmpty => _conditions.Count == 0;
+
         public override ClauseKind Kind => ClauseKind.CompoundCondition;
 
         public new void And(Condition condition) =>

src/HotChocolate/Neo4J/test/HotChocolate.Data.Neo4J.Filtering.Tests/Neo4JFilterCombinatorTests.cs

@@ -0,0 +1,47 @@
+using System.Threading.Tasks;
+using HotChocolate.Data.Filters;
+using HotChocolate.Data.Neo4J.Sorting;
+using HotChocolate.Execution;
+using Xunit;
+
+ namespace HotChocolate.Data.Neo4J.Filtering;
+
+ public class Neo4JFilterCombinatorTests
+        : IClassFixture<Neo4JFixture>
+ {
+     private readonly Neo4JFixture _fixture;
+
+     public Neo4JFilterCombinatorTests(Neo4JFixture fixture)
+     {
+         _fixture = fixture;
+     }
+
+     private const string _fooEntitiesCypher =
+         @"CREATE (:FooBool {Bar: true}), (:FooBool {Bar: false})";
+
+     [Fact]
+     public async Task Create_Empty_Expression()
+     {
+         // arrange
+         var tester =
+             await _fixture.GetOrCreateSchema<FooBool, FooBoolFilterType>(_fooEntitiesCypher);
+
+         // act
+         // assert
+         IExecutionResult res1 = await tester.ExecuteAsync(
+             QueryRequestBuilder.New()
+                 .SetQuery("{ root(where: { }){ bar }}")
+                 .Create());
+
+            res1.MatchDocumentSnapshot("ASC");
+     }
+
+     public class FooBool
+     {
+         public bool Bar { get; set; }
+     }
+
+     public class FooBoolFilterType : FilterInputType<FooBool>
+     {
+     }
+ }

src/HotChocolate/Neo4J/test/HotChocolate.Data.Neo4J.Filtering.Tests/__snapshots__/Neo4JFilterCombinatorTests.Create_Empty_Expression_ASC.snap

@@ -0,0 +1,12 @@
+{
+  "data": {
+    "root": [
+      {
+        "bar": true
+      },
+      {
+        "bar": false
+      }
+    ]
+  }
+}

src/HotChocolate/Neo4J/test/HotChocolate.Data.Neo4J.Filtering.Tests/__snapshots__/Neo4JFilterCombinatorTests.Create_Empty_Expression_ASC_query.snap

@@ -0,0 +1 @@
+MATCH (fooBool:FooBool) RETURN fooBool {.Bar}