Fix issue where non-conditional fields become conditional. (#9706)

Author: michaelstaib

src/HotChocolate/Core/src/Types/Execution/Processing/OperationCompiler.cs

@@ -291,13 +291,12 @@ private SelectionSet BuildSelectionSet(
         var includeFlags = new List<ulong>();
         var deferUsages = new List<DeferUsage>();
         var selectionSetId = ++lastId;
-        var alwaysIncluded = false;
-
         foreach (var (responseName, nodes) in fieldMap)
         {
             includeFlags.Clear();
             deferUsages.Clear();
 
+            var alwaysIncluded = false;
             var first = nodes[0];
             var isInternal = IsInternal(first.Node);
             var hasNonDeferredNode = first.DeferUsage is null;

src/HotChocolate/Core/test/Execution.Tests/Processing/SelectionIncludeConditionTests.cs

@@ -758,12 +758,134 @@ fragment B on Person {
             """);
     }
 
+    [Fact]
+    public async Task Complementary_Fragment_Spreads_Should_Use_Full_Fragment_When_Minimal_Is_False()
+    {
+        // arrange
+        var result = await ExecuteComplementaryFragmentQueryAsync(minimal: false);
+
+        // assert
+        result.MatchInlineSnapshot(
+            """
+            {
+              "data": {
+                "series": [
+                  {
+                    "streams": [
+                      {
+                        "__typename": "Stream",
+                        "id": "stream-1",
+                        "hasDrm": true,
+                        "title": "Stream One",
+                        "publishedAt": "2026-01-01"
+                      }
+                    ]
+                  }
+                ]
+              }
+            }
+            """);
+    }
+
+    [Fact]
+    public async Task Complementary_Fragment_Spreads_Should_Use_Minimal_Fragment_When_Minimal_Is_True()
+    {
+        // arrange
+        var result = await ExecuteComplementaryFragmentQueryAsync(minimal: true);
+
+        // assert
+        result.MatchInlineSnapshot(
+            """
+            {
+              "data": {
+                "series": [
+                  {
+                    "streams": [
+                      {
+                        "__typename": "Stream",
+                        "id": "stream-1",
+                        "hasDrm": true
+                      }
+                    ]
+                  }
+                ]
+              }
+            }
+            """);
+    }
+
+    private static async Task<IExecutionResult> ExecuteComplementaryFragmentQueryAsync(bool minimal)
+    {
+        var schema = SchemaBuilder.New()
+            .AddDocumentFromString(
+                """
+                type Query {
+                  series: [Series!]!
+                }
+
+                type Series {
+                  id: ID!
+                  streams: [Stream!]!
+                }
+
+                type Stream {
+                  id: ID!
+                  title: String
+                  hasDrm: Boolean
+                  publishedAt: String
+                }
+                """)
+            .AddResolver<Query>()
+            .Create();
+
+        return await schema.MakeExecutable().ExecuteAsync(
+            OperationRequestBuilder.New()
+                .SetDocument(
+                    """
+                    query TestQuery($minimal: Boolean = false) {
+                      series {
+                        streams {
+                          __typename
+                          ...streamFields
+                        }
+                      }
+                    }
+
+                    fragment streamFields on Stream {
+                      __typename
+                      ...MinimalStream @include(if: $minimal)
+                      ...FullStream @skip(if: $minimal)
+                    }
+
+                    fragment MinimalStream on Stream {
+                      id
+                      hasDrm
+                    }
+
+                    fragment FullStream on Stream {
+                      id
+                      title
+                      hasDrm
+                      publishedAt
+                    }
+                    """)
+                .SetVariableValues(
+                    $$"""
+                    {
+                      "minimal": {{minimal.ToString().ToLowerInvariant()}}
+                    }
+                    """)
+                .Build());
+    }
+
     public sealed class Query
     {
         public Person Person() => new Person();
 
         [UsePaging]
         public Person[] Persons() => [new Person()];
+
+        public Series[] Series() => [new Series()];
     }
 
     public sealed class Person
@@ -772,4 +894,22 @@ public sealed class Person
 
         public string Address { get; } = "world";
     }
+
+    public sealed class Series
+    {
+        public string Id { get; } = "series-1";
+
+        public Stream[] Streams() => [new Stream()];
+    }
+
+    public sealed class Stream
+    {
+        public string Id { get; } = "stream-1";
+
+        public string Title { get; } = "Stream One";
+
+        public bool HasDrm { get; } = true;
+
+        public string PublishedAt { get; } = "2026-01-01";
+    }
 }

src/HotChocolate/Fusion/src/Fusion.Execution.Types/FusionSchemaDefinition.cs

@@ -424,8 +424,10 @@ private ImmutableArray<Lookup> GetPossibleLookupsInternal(ITypeDefinition type,
     }
 
     /// <summary>
-    /// Tries to get the best direct lookup to transition from one schema to another without intermediary transitions.
-    /// The best lookup algorithm will try to find the smallest possible key that does not require any intermediary transitions.
+    /// Tries to get the best direct lookup to transition from one schema
+    /// to another without intermediary transitions.
+    /// The best lookup algorithm will try to find the smallest possible key that does not
+    /// require any intermediary transitions.
     /// </summary>
     /// <param name="type">The type to get the best direct lookup for.</param>
     /// <param name="fromSchemas">The schemas to get the best direct lookup from.</param>
@@ -442,7 +444,7 @@ public bool TryGetBestDirectLookup(
         ArgumentNullException.ThrowIfNull(fromSchemas);
         ArgumentException.ThrowIfNullOrEmpty(toSchema);
 
-        foreach (var fromSchema in fromSchemas)
+        foreach (var fromSchema in fromSchemas.OrderBy(static t => t, StringComparer.Ordinal))
         {
             if (TryGetBestDirectLookup(type, fromSchema, toSchema, out lookup))
             {

src/HotChocolate/Fusion/src/Fusion.Execution/Execution/Nodes/Operation.cs

@@ -242,8 +242,10 @@ public ulong CreateIncludeFlags(IVariableValueCollection variables)
         {
             if (includeCondition.IsIncluded(variables))
             {
-                includeFlags |= 1ul << index++;
+                includeFlags |= 1ul << index;
             }
+
+            index++;
         }
 
         return includeFlags;

src/HotChocolate/Fusion/src/Fusion.Execution/Execution/Nodes/OperationCompiler.cs

@@ -245,14 +245,12 @@ private SelectionSet BuildSelectionSet(
             includeFlags.Clear();
             deliveryGroups.Clear();
 
+            var alwaysIncluded = false;
             var first = nodes[0];
-            var isInternal = IsInternal(first.Node);
+            var isInternal = IsInternal(nodes);
             var hasImmediateNode = first.DeliveryGroup is null;
 
-            if (first.PathIncludeFlags > 0)
-            {
-                includeFlags.Add(first.PathIncludeFlags);
-            }
+            AddIncludeFlags(first, isInternal, includeFlags, ref alwaysIncluded);
 
             if (first.DeliveryGroup is not null)
             {
@@ -271,10 +269,7 @@ private SelectionSet BuildSelectionSet(
                             $"The syntax nodes for the response name {responseName} are not all the same.");
                     }
 
-                    if (next.PathIncludeFlags > 0)
-                    {
-                        includeFlags.Add(next.PathIncludeFlags);
-                    }
+                    AddIncludeFlags(next, isInternal, includeFlags, ref alwaysIncluded);
 
                     if (next.DeliveryGroup is null)
                     {
@@ -284,11 +279,6 @@ private SelectionSet BuildSelectionSet(
                     {
                         deliveryGroups.Add(next.DeliveryGroup);
                     }
-
-                    if (isInternal)
-                    {
-                        isInternal = IsInternal(next.Node);
-                    }
                 }
             }
 
@@ -413,6 +403,44 @@ private static void CollapseIncludeFlags(List<ulong> includeFlags)
         }
     }
 
+    private static void AddIncludeFlags(
+        FieldSelectionNode node,
+        bool isInternalSelection,
+        List<ulong> includeFlags,
+        ref bool alwaysIncluded)
+    {
+        if (!isInternalSelection && IsInternal(node.Node))
+        {
+            return;
+        }
+
+        if (node.PathIncludeFlags == 0)
+        {
+            alwaysIncluded = true;
+            if (includeFlags.Count > 0)
+            {
+                includeFlags.Clear();
+            }
+        }
+        else if (!alwaysIncluded)
+        {
+            includeFlags.Add(node.PathIncludeFlags);
+        }
+    }
+
+    private static bool IsInternal(List<FieldSelectionNode> nodes)
+    {
+        for (var i = 0; i < nodes.Count; i++)
+        {
+            if (!IsInternal(nodes[i].Node))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     private bool DoesTypeApply(NamedTypeNode? typeCondition, IObjectTypeDefinition typeContext)
     {
         if (typeCondition is null)

src/HotChocolate/Fusion/test/Fusion.AspNetCore.Tests/__snapshots__/ConditionalTests.NodeField_Skip_On_Interface_Selection_Type_Refinement_With_Same_Unskipped_Selection.yaml

@@ -23,7 +23,11 @@ response:
   body: |
     {
       "data": {
-        "node": {}
+        "node": {
+          "author": {
+            "rating": 123
+          }
+        }
       }
     }
 sourceSchemas: