IsProjected on multiple fields (#3916)

Author: PascalSenn

src/HotChocolate/Data/src/Data/Projections/Convention/ProjectionConvention.cs

@@ -92,7 +92,7 @@ private static IReadOnlyList<IProjectionProviderExtension> CollectExtensions(
             IServiceProvider serviceProvider,
             ProjectionConventionDefinition definition)
         {
-            List<IProjectionProviderExtension> extensions = new List<IProjectionProviderExtension>();
+            List<IProjectionProviderExtension> extensions = new();
             extensions.AddRange(definition.ProviderExtensions);
             foreach (var extensionType in definition.ProviderExtensionsTypes)
             {

src/HotChocolate/Data/src/Data/Projections/Optimizers/IsProjectedProjectionOptimizer.cs

@@ -17,40 +17,52 @@ public Selection RewriteSelection(
             SelectionOptimizerContext context,
             Selection selection)
         {
-            if (context.Type is ObjectType type &&
+            if (!(context.Type is ObjectType type &&
                 type.ContextData.TryGetValue(AlwaysProjectedFieldsKey, out object? fieldsObj) &&
-                fieldsObj is string[] fields)
+                fieldsObj is string[] fields))
             {
-                int aliasCount = 0;
-                for (var i = 0; i < fields.Length; i++)
+                return selection;
+            }
+
+            for (var i = 0; i < fields.Length; i++)
+            {
+                var alias = "__projection_alias_" + i;
+
+                // if the field is already in the selection set we do not need to project it
+                if (context.Fields.TryGetValue(fields[i], out var field) &&
+                    field.Field.Name == fields[i])
                 {
-                    if (!context.Fields.TryGetValue(fields[i], out var field) ||
-                        field.Field.Name != fields[i])
-                    {
-                        IObjectField nodesField = type.Fields[fields[i]];
-                        var alias = "__projection_alias_" + aliasCount++;
-                        var nodesFieldNode = new FieldNode(
-                            null,
-                            new NameNode(fields[i]),
-                            new NameNode(alias),
-                            Array.Empty<DirectiveNode>(),
-                            Array.Empty<ArgumentNode>(),
-                            null);
-
-                        FieldDelegate nodesPipeline =
-                            context.CompileResolverPipeline(nodesField, nodesFieldNode);
-
-                        var compiledSelection = new Selection(
-                            context.Type,
-                            nodesField,
-                            nodesFieldNode,
-                            nodesPipeline,
-                            arguments: selection.Arguments,
-                            internalSelection: true);
-
-                        context.Fields[alias] = compiledSelection;
-                    }
+                    continue;
                 }
+
+                // if the field is already added as an alias we do not need to add it
+                if (context.Fields.TryGetValue(alias, out field) &&
+                    field.Field.Name == fields[i])
+                {
+                    continue;
+                }
+
+                IObjectField nodesField = type.Fields[fields[i]];
+                var nodesFieldNode = new FieldNode(
+                    null,
+                    new NameNode(fields[i]),
+                    new NameNode(alias),
+                    Array.Empty<DirectiveNode>(),
+                    Array.Empty<ArgumentNode>(),
+                    null);
+
+                FieldDelegate nodesPipeline =
+                    context.CompileResolverPipeline(nodesField, nodesFieldNode);
+
+                var compiledSelection = new Selection(
+                    context.Type,
+                    nodesField,
+                    nodesFieldNode,
+                    nodesPipeline,
+                    arguments: selection.Arguments,
+                    internalSelection: true);
+
+                context.Fields[alias] = compiledSelection;
             }
 
             return selection;

src/HotChocolate/Data/test/Data.Projections.SqlServer.Tests/QueryableProjectionVisitorIsProjectedTests.cs

@@ -12,9 +12,16 @@ public class QueryableProjectionVisitorIsProjectedTests
             new Foo { IsProjectedTrue = true, IsProjectedFalse = false }
         };
 
+        private static readonly MultipleFoo[] _fooMultipleEntities =
+        {
+            new MultipleFoo{ IsProjectedTrue1 = true, IsProjectedFalse = false },
+            new MultipleFoo{ IsProjectedTrue1 = true, IsProjectedFalse = false }
+        };
+
         private static readonly Bar[] _barEntities =
         {
-            new Bar { IsProjectedFalse = false }, new Bar { IsProjectedFalse = false }
+            new Bar { IsProjectedFalse = false },
+            new Bar { IsProjectedFalse = false }
         };
 
         private readonly SchemaCache _cache = new SchemaCache();
@@ -67,6 +74,22 @@ public async Task IsProjected_Should_AlwaysBeProjectedWhenSelected_When_True()
             res1.MatchSqlSnapshot();
         }
 
+        [Fact]
+        public async Task IsProjected_Should_AlwaysBeProjectedWhenSelected_When_TrueAndMultiple()
+        {
+            // arrange
+            IRequestExecutor tester = _cache.CreateSchema(_fooMultipleEntities);
+
+            // act
+            // assert
+            IExecutionResult res1 = await tester.ExecuteAsync(
+                QueryRequestBuilder.New()
+                    .SetQuery("{ root { isProjectedFalse }}")
+                    .Create());
+
+            res1.MatchSqlSnapshot();
+        }
+
         [Fact]
         public async Task IsProjected_Should_NotFailWhenSelectionSetSkippedCompletely()
         {
@@ -105,5 +128,24 @@ public class Bar
 
             public bool? ShouldNeverBeProjected { get; set; }
         }
+
+        public class MultipleFoo
+        {
+            public int Id { get; set; }
+
+            [IsProjected(true)]
+            public bool? IsProjectedTrue1 { get; set; }
+
+            [IsProjected(true)]
+            public bool? IsProjectedTrue2 { get; set; }
+
+            [IsProjected(true)]
+            public bool? IsProjectedTrue3 { get; set; }
+
+            [IsProjected(false)]
+            public bool? IsProjectedFalse { get; set; }
+
+            public bool? ShouldNeverBeProjected { get; set; }
+        }
     }
 }

src/HotChocolate/Data/test/Data.Projections.SqlServer.Tests/__snapshots__/QueryableProjectionVisitorIsProjectedTests.IsProjected_Should_AlwaysBeProjectedWhenSelected_When_TrueAndMultiple.snap

@@ -0,0 +1,12 @@
+{
+  "data": {
+    "root": [
+      {
+        "isProjectedFalse": null
+      },
+      {
+        "isProjectedFalse": null
+      }
+    ]
+  }
+}

src/HotChocolate/Data/test/Data.Projections.SqlServer.Tests/__snapshots__/QueryableProjectionVisitorIsProjectedTests.IsProjected_Should_AlwaysBeProjectedWhenSelected_When_TrueAndMultiple__sql.snap

@@ -0,0 +1,2 @@
+SELECT "d"."IsProjectedTrue1", "d"."IsProjectedTrue2", "d"."IsProjectedTrue3"
+FROM "Data" AS "d"