Add support for empty selection sets

src/HotChocolate/Core/src/Types/Execution/RequestExecutorManager.cs

@@ -445,11 +445,14 @@ private static void BuildDocumentValidator(
         serviceCollection.AddSingleton(sp =>
         {
             var rootServices = sp.GetRootServiceProvider();
+            // The document validator is resolved after the schema is assigned to LazySchema.
+            var options = sp.GetRequiredService<ISchemaDefinition>().GetOptions();
 
             var builder =
                 DocumentValidatorBuilder.New()
                     .SetServices(rootServices)
-                    .AddDefaultRules();
+                    .AddDefaultRules()
+                    .ModifyOptions(o => o.EnableEmptySelectionSets = options.EnableEmptySelectionSets);
 
             foreach (var hook in hooks)
             {

src/HotChocolate/Core/src/Types/IReadOnlySchemaOptions.cs

@@ -171,6 +171,12 @@ public interface IReadOnlySchemaOptions
     /// </summary>
     bool EnableStream { get; }
 
+    /// <summary>
+    /// Enables empty selection sets according to GraphQL specification PR 1227; defaults to <c>false</c>.
+    /// When disabled, an empty selection set is a validation error, and an empty subscription root is invalid in either state.
+    /// </summary>
+    bool EnableEmptySelectionSets { get; }
+
     /// <summary>
     /// Specified if the leading I shall be stripped from the interface name.
     /// </summary>

src/HotChocolate/Core/src/Types/SchemaOptions.cs

@@ -112,6 +112,9 @@ public FieldBindingFlags DefaultFieldBindingFlags
     /// <inheritdoc cref="IReadOnlySchemaOptions.EnableStream"/>
     public bool EnableStream { get; set; }
 
+    /// <inheritdoc cref="IReadOnlySchemaOptions.EnableEmptySelectionSets"/>
+    public bool EnableEmptySelectionSets { get; set; }
+
     /// <inheritdoc cref="IReadOnlySchemaOptions.StripLeadingIFromInterface"/>
     public bool StripLeadingIFromInterface { get; set; }
 
@@ -238,6 +241,7 @@ public static SchemaOptions FromOptions(IReadOnlySchemaOptions options)
             EnableFlagEnums = options.EnableFlagEnums,
             EnableDefer = options.EnableDefer,
             EnableStream = options.EnableStream,
+            EnableEmptySelectionSets = options.EnableEmptySelectionSets,
             DefaultFieldBindingFlags = options.DefaultFieldBindingFlags,
             StripLeadingIFromInterface = options.StripLeadingIFromInterface,
             EnableTag = options.EnableTag,

src/HotChocolate/Core/src/Validation/ErrorHelper.cs

@@ -272,6 +272,19 @@ public IError NoSelectionOnRootType(OperationDefinitionNode node, IType fieldTyp
                 .Build();
         }
 
+        public IError NoSelectionOnFragment(SelectionSetNode node, IType typeCondition)
+        {
+            return ErrorBuilder.New()
+                .SetMessage(
+                    Resources.ErrorHelper_NoSelectionOnFragment,
+                    typeCondition.NamedType().Name)
+                .AddLocation(node)
+                .SetPath(context.CreateErrorPath())
+                .SetExtension("type", typeCondition.NamedType().Name)
+                .SpecifiedBy("sec-Field-Selections")
+                .Build();
+        }
+
         public IError FieldIsRequiredButNull(ISyntaxNode node, string fieldName)
         {
             return ErrorBuilder.New()

src/HotChocolate/Core/src/Validation/Extensions/ValidationBuilderExtensions.cs

@@ -118,7 +118,7 @@ public static DocumentValidatorBuilder AddFieldRules(
     {
         return builder
             .AddRule<FieldSelectionsRule>()
-            .AddRule<LeafFieldSelectionsRule>()
+            .AddRule((_, o) => new LeafFieldSelectionsRule(o.EnableEmptySelectionSets))
             .AddRule((_, o) => new OverlappingFieldsCanBeMergedRule(o.MaxAllowedFieldMergeComparisons));
     }
 

src/HotChocolate/Core/src/Validation/Options/ValidationOptions.cs

@@ -8,6 +8,11 @@ public sealed class ValidationOptions
     , IErrorOptionsAccessor
     , IIntrospectionOptionsAccessor
 {
+    /// <summary>
+    /// Specifies whether empty selection sets are valid. Defaults to <c>false</c>.
+    /// </summary>
+    public bool EnableEmptySelectionSets { get; set; }
+
     /// <summary>
     /// Gets the maximum allowed depth of a query. The default value is
     /// <see langword="null"/>. The minimum allowed value is <c>1</c>.

src/HotChocolate/Core/src/Validation/Properties/Resources.resx

@@ -143,6 +143,9 @@
   <data name="ErrorHelper_NoSelectionOnCompositeField" xml:space="preserve">
     <value>Field "{0}" of type "{1}" must have a selection of subfields. Did you mean "{0} {{ ... }}"?</value>
   </data>
+  <data name="ErrorHelper_NoSelectionOnFragment" xml:space="preserve">
+    <value>The fragment on type "{0}" has an empty selection set. Fragments without selections are disallowed.</value>
+  </data>
   <data name="ErrorHelper_NoSelectionOnRootType" xml:space="preserve">
     <value>Operation `{0}` has an empty selection set. Root types without selections are disallowed.</value>
   </data>

src/HotChocolate/Core/src/Validation/Rules/LeafFieldSelectionsRule.cs

@@ -5,6 +5,13 @@ namespace HotChocolate.Validation.Rules;
 
 internal sealed class LeafFieldSelectionsRule : IDocumentValidatorRule
 {
+    private readonly bool _enableEmptySelectionSets;
+
+    public LeafFieldSelectionsRule(bool enableEmptySelectionSets = false)
+    {
+        _enableEmptySelectionSets = enableEmptySelectionSets;
+    }
+
     public ushort Priority => ushort.MaxValue;
 
     public bool IsCacheable => true;
@@ -22,10 +29,13 @@ public void Validate(DocumentValidatorContext context, DocumentNode document)
             {
                 if (operationDef.SelectionSet.Selections.Count == 0)
                 {
-                    context.ReportError(
-                        context.NoSelectionOnRootType(
-                            operationDef,
-                            rootType));
+                    if (!_enableEmptySelectionSets || operationDef.Operation == OperationType.Subscription)
+                    {
+                        context.ReportError(
+                            context.NoSelectionOnRootType(
+                                operationDef,
+                                rootType));
+                    }
 
                     continue;
                 }
@@ -40,6 +50,16 @@ private void ValidateSelectionSet(
         SelectionSetNode selectionSet,
         IType type)
     {
+        if (selectionSet.Selections.Count == 0)
+        {
+            if (!_enableEmptySelectionSets)
+            {
+                context.ReportError(context.NoSelectionOnFragment(selectionSet, type));
+            }
+
+            return;
+        }
+
         foreach (var selection in selectionSet.Selections)
         {
             if (selection is FieldNode field)
@@ -101,11 +121,19 @@ private void ValidateField(
         }
         else
         {
-            if (field.SelectionSet is null or { Selections.Count: 0 })
+            if (field.SelectionSet is null)
             {
                 context.ReportError(
                     context.NoSelectionOnCompositeField(field, complex, fieldDef.Type));
             }
+            else if (field.SelectionSet.Selections.Count == 0)
+            {
+                if (!_enableEmptySelectionSets)
+                {
+                    context.ReportError(
+                        context.NoSelectionOnCompositeField(field, complex, fieldDef.Type));
+                }
+            }
             else
             {
                 ValidateSelectionSet(context, field.SelectionSet, fieldDef.Type);

src/HotChocolate/Core/src/Validation/Rules/OperationVisitor.cs

@@ -21,7 +21,7 @@ namespace HotChocolate.Validation.Rules;
 ///
 /// AND
 ///
-/// Subscription operations must have exactly one root field.
+/// Subscription operations must have exactly one root field, including an empty selection set.
 ///
 /// https://spec.graphql.org/September2025/#sec-Single-Root-Field
 ///
@@ -113,7 +113,7 @@ protected override ISyntaxVisitorAction Leave(
 
         if (node.Operation == OperationType.Subscription)
         {
-            if (responseNames.Count > 1)
+            if (responseNames.Count != 1)
             {
                 context.ReportError(context.SubscriptionSingleRootField(node));
             }

src/HotChocolate/Core/test/Execution.Tests/DependencyInjection/RequestExecutorBuilderExtensions_SchemaOptionsTests.cs

@@ -21,6 +21,161 @@ public async Task ModifyOptions_ValidatePipelineOrder_False()
         Assert.False(interceptor.Options.ValidatePipelineOrder);
     }
 
+    [Fact]
+    public async Task ModifyOptions_EnableEmptySelectionSets_ExecutesEmptySelectionSets()
+    {
+        // arrange
+        var executor =
+            await new ServiceCollection()
+                .AddGraphQLServer()
+                .AddQueryType<Query>()
+                .ModifyOptions(o => o.EnableEmptySelectionSets = true)
+                .BuildRequestExecutorAsync(cancellationToken: TestContext.Current.CancellationToken);
+
+        // act
+        var rootResult = await executor.ExecuteAsync("{ }", TestContext.Current.CancellationToken);
+        var objectResult = await executor.ExecuteAsync("{ hero { } }", TestContext.Current.CancellationToken);
+
+        // assert
+        rootResult.MatchInlineSnapshot(
+            """
+            {
+              "data": {}
+            }
+            """);
+        objectResult.MatchInlineSnapshot(
+            """
+            {
+              "data": {
+                "hero": {}
+              }
+            }
+            """);
+    }
+
+    [Fact]
+    public async Task ConfigureSchema_Should_ExecuteEmptySelectionSets_When_Enabled()
+    {
+        // arrange
+        var executor =
+            await new ServiceCollection()
+                .AddGraphQLServer()
+                .AddQueryType<Query>()
+                .ConfigureSchema(b => b.ModifyOptions(o => o.EnableEmptySelectionSets = true))
+                .BuildRequestExecutorAsync(cancellationToken: TestContext.Current.CancellationToken);
+
+        // act
+        var result = await executor.ExecuteAsync("{ }", TestContext.Current.CancellationToken);
+
+        // assert
+        result.MatchInlineSnapshot(
+            """
+            {
+              "data": {}
+            }
+            """);
+    }
+
+    [Fact]
+    public async Task MakeExecutable_Should_ExecuteEmptySelectionSets_When_SchemaIsPrebuilt()
+    {
+        // arrange
+        var schema =
+            SchemaBuilder.New()
+                .ModifyOptions(o => o.EnableEmptySelectionSets = true)
+                .AddQueryType<Query>()
+                .Create();
+        var executor = schema.MakeExecutable();
+
+        // act
+        var result = await executor.ExecuteAsync("{ }", TestContext.Current.CancellationToken);
+
+        // assert
+        result.MatchInlineSnapshot(
+            """
+            {
+              "data": {}
+            }
+            """);
+    }
+
+    [Fact]
+    public async Task ConfigureValidation_Should_RejectEmptySelectionSets_When_Disabled()
+    {
+        // arrange
+        var executor =
+            await new ServiceCollection()
+                .AddGraphQLServer()
+                .AddQueryType<Query>()
+                .ModifyOptions(o => o.EnableEmptySelectionSets = true)
+                .ConfigureValidation((_, b) =>
+                    b.ModifyOptions(o => o.EnableEmptySelectionSets = false))
+                .BuildRequestExecutorAsync(cancellationToken: TestContext.Current.CancellationToken);
+
+        // act
+        var result = await executor.ExecuteAsync("{ }", TestContext.Current.CancellationToken);
+
+        // assert
+        result.MatchInlineSnapshot(
+            """
+            {
+              "errors": [
+                {
+                  "message": "Operation `Unnamed` has an empty selection set. Root types without selections are disallowed.",
+                  "locations": [
+                    {
+                      "line": 1,
+                      "column": 1
+                    }
+                  ],
+                  "extensions": {
+                    "operation": "Unnamed",
+                    "type": "Query",
+                    "specifiedBy": "https://spec.graphql.org/September2025/#sec-Field-Selections"
+                  }
+                }
+              ]
+            }
+            """);
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_Should_RejectEmptySelectionSets_When_Disabled()
+    {
+        // arrange
+        var executor =
+            await new ServiceCollection()
+                .AddGraphQLServer()
+                .AddQueryType<Query>()
+                .BuildRequestExecutorAsync(cancellationToken: TestContext.Current.CancellationToken);
+
+        // act
+        var result = await executor.ExecuteAsync("{ }", TestContext.Current.CancellationToken);
+
+        // assert
+        result.MatchInlineSnapshot(
+            """
+            {
+              "errors": [
+                {
+                  "message": "Operation `Unnamed` has an empty selection set. Root types without selections are disallowed.",
+                  "locations": [
+                    {
+                      "line": 1,
+                      "column": 1
+                    }
+                  ],
+                  "extensions": {
+                    "operation": "Unnamed",
+                    "type": "Query",
+                    "specifiedBy": "https://spec.graphql.org/September2025/#sec-Field-Selections"
+                  }
+                }
+              ]
+            }
+            """);
+    }
+
     private sealed class OptionsInterceptor : TypeInterceptor
     {
         public IReadOnlySchemaOptions Options { get; private set; } = null!;
@@ -36,5 +191,12 @@ internal override void OnBeforeCreateSchemaInternal(
     public class Query
     {
         public string Abc() => "abc";
+
+        public Hero Hero() => new();
+    }
+
+    public class Hero
+    {
+        public string Name => "Luke";
     }
 }