Added SkipIntrospectionFields option on MaxDepthAnalyzer

src/HotChocolate/Core/src/Execution/DependencyInjection/RequestExecutorBuilderExtensions.Validation.cs

@@ -137,10 +137,42 @@ public static IRequestExecutorBuilder AddValidationRule<T>(
         return ConfigureValidation(builder, b => b.TryAddValidationRule(factory));
     }
 
+    /// <summary>
+    /// Adds a validation rule that inspects if a GraphQL query document 
+    /// exceeds the maximum allowed operation depth.
+    /// </summary>
     public static IRequestExecutorBuilder AddMaxExecutionDepthRule(
         this IRequestExecutorBuilder builder,
-        int maxAllowedExecutionDepth) =>
+        int maxAllowedExecutionDepth)
+    {
+        if (builder is null)
+        {
+            throw new ArgumentNullException(nameof(builder));
+        }
+
         ConfigureValidation(builder, b => b.AddMaxExecutionDepthRule(maxAllowedExecutionDepth));
+        return builder;
+    }
+
+    /// <summary>
+    /// Adds a validation rule that inspects if a GraphQL query document 
+    /// exceeds the maximum allowed operation depth.
+    /// </summary>
+    public static IRequestExecutorBuilder AddMaxExecutionDepthRule(
+        this IRequestExecutorBuilder builder,
+        int maxAllowedExecutionDepth,
+        bool skipIntrospectionFields)
+    {
+        if (builder is null)
+        {
+            throw new ArgumentNullException(nameof(builder));
+        }
+
+        ConfigureValidation(
+            builder,
+            b => b.AddMaxExecutionDepthRule(maxAllowedExecutionDepth, skipIntrospectionFields));
+        return builder;
+    }
 
     /// <summary>
     /// Adds a validation rule that only allows requests to use `__schema` or `__type`

src/HotChocolate/Core/src/Execution/Pipeline/Complexity/ComplexityContext.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using HotChocolate.Language;
 using HotChocolate.Types;

src/HotChocolate/Core/src/Execution/Pipeline/Complexity/OperationComplexityAnalyzer.cs

@@ -1,4 +1,3 @@
-using System;
 using HotChocolate.Language;
 
 namespace HotChocolate.Execution.Pipeline.Complexity;

src/HotChocolate/Core/src/Validation/Extensions/ValidatiobBuilderExtensions.Rules.cs

@@ -303,10 +303,20 @@ public static IValidationBuilder AddOperationRules(
     public static IValidationBuilder AddMaxExecutionDepthRule(
         this IValidationBuilder builder,
         int maxAllowedExecutionDepth)
+        => AddMaxExecutionDepthRule(builder, maxAllowedExecutionDepth, false);
+
+    public static IValidationBuilder AddMaxExecutionDepthRule(
+        this IValidationBuilder builder,
+        int maxAllowedExecutionDepth,
+        bool skipIntrospectionFields)
     {
         return builder
             .TryAddValidationVisitor((_, o) => new MaxExecutionDepthVisitor(o))
-            .SetAllowedExecutionDepth(maxAllowedExecutionDepth);
+            .ModifyValidationOptions(o =>
+            {
+                o.MaxAllowedExecutionDepth = maxAllowedExecutionDepth;
+                o.SkipIntrospectionFields = skipIntrospectionFields;
+            });
     }
 
     /// <summary>

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

@@ -85,26 +85,10 @@ public static IValidationBuilder ConfigureValidation(
         return builder;
     }
 
-    /// <summary>
-    /// Sets the maximum allowed depth of a query. The default
-    /// value is <see langword="null"/>. The minimum allowed value is
-    /// <c>1</c>.
-    /// </summary>
-    internal static IValidationBuilder SetAllowedExecutionDepth(
+    internal static IValidationBuilder ModifyValidationOptions(
         this IValidationBuilder builder,
-        int allowedExecutionDepth)
-    {
-        if (allowedExecutionDepth < 1)
-        {
-            throw new ArgumentOutOfRangeException(
-                nameof(allowedExecutionDepth),
-                allowedExecutionDepth,
-                Resources.HotChocolateValidationBuilderExtensions_MinimumAllowedValue);
-        }
-
-        return builder.ConfigureValidation(m =>
-            m.Modifiers.Add(o => o.MaxAllowedExecutionDepth = allowedExecutionDepth));
-    }
+        Action<ValidationOptions> configure)
+        => builder.ConfigureValidation(m => m.Modifiers.Add(configure));
 
     public static IValidationBuilder TryAddValidationVisitor<T>(
         this IValidationBuilder builder,

src/HotChocolate/Core/src/Validation/HotChocolate.Validation.csproj

@@ -15,6 +15,10 @@
     <ProjectReference Include="..\Types\HotChocolate.Types.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <InternalsVisibleTo Include="HotChocolate.Validation.Tests" />
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="3.1.4" />
     <PackageReference Include="Microsoft.Extensions.Options" Version="3.1.4" />

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

@@ -7,4 +7,10 @@ public interface IMaxExecutionDepthOptionsAccessor
     /// <see langword="null"/>. The minimum allowed value is <c>1</c>.
     /// </summary>
     int? MaxAllowedExecutionDepth { get; }
+
+    /// <summary>
+    /// Specifies that the max execution depth analysis 
+    /// shall skip introspection fields.
+    /// </summary>
+    bool SkipIntrospectionFields { get; }
 }

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

@@ -7,6 +7,8 @@ namespace HotChocolate.Validation.Options;
 /// </summary>
 public class ValidationOptions : IMaxExecutionDepthOptionsAccessor
 {
+    private int? _maxAllowedExecutionDepth;
+
     /// <summary>
     /// Gets the document rules of the validation.
     /// </summary>
@@ -17,5 +19,18 @@ public class ValidationOptions : IMaxExecutionDepthOptionsAccessor
     /// Gets the maximum allowed depth of a query. The default value is
     /// <see langword="null"/>. The minimum allowed value is <c>1</c>.
     /// </summary>
-    public int? MaxAllowedExecutionDepth { get; set; }
+    public int? MaxAllowedExecutionDepth
+    {
+        get => _maxAllowedExecutionDepth;
+        set
+        {
+            _maxAllowedExecutionDepth = value < 1 ? 1 : value;
+        }
+    }
+
+    /// <summary>
+    /// Specifies that the max execution depth analysis 
+    /// shall skip introspection fields.
+    /// </summary>
+    public bool SkipIntrospectionFields { get; set; }
 }

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

@@ -209,9 +209,6 @@
   <data name="ErrorHelper_MaxExecutionDepth" xml:space="preserve">
     <value>The GraphQL document has an execution depth of {0} which exceeds the max allowed execution depth of {1}.</value>
   </data>
-  <data name="HotChocolateValidationBuilderExtensions_MinimumAllowedValue" xml:space="preserve">
-    <value>The minimum allowed value is 1.</value>
-  </data>
   <data name="ErrorHelper_DirectiveMustBeUniqueInLocation" xml:space="preserve">
     <value>Only one of each directive is allowed per location.</value>
   </data>

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

@@ -42,6 +42,12 @@ protected override ISyntaxVisitorAction Enter(
         FieldNode node,
         IDocumentValidatorContext context)
     {
+        if (_options.SkipIntrospectionFields && 
+            node.Name.Value.StartsWith("__"))
+        {
+            return Skip;
+        }
+
         context.Fields.Push(node);
 
         if (context.Count < context.Fields.Count)

src/HotChocolate/Core/test/Execution.Tests/Integration/StarWarsCodeFirst/StarWarsCodeFirstTests.cs

@@ -765,6 +765,42 @@ ... on Droid {
                 });
         }
 
+        [Fact]
+        public async Task Execution_Depth_Is_Skipped_For_Introspection()
+        {
+            Snapshot.FullName();
+            await ExpectValid(@"
+                query {
+                    __schema {
+                        types {
+                            fields {
+                                type {
+                                    kind
+                                    name
+                                    ofType {
+                                        kind
+                                        name
+                                        ofType {
+                                            kind
+                                            name
+                                            ofType {
+                                                kind
+                                                name
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }",
+                configure: c =>
+                {
+                    AddDefaultConfiguration(c);
+                    c.AddMaxExecutionDepthRule(3, skipIntrospectionFields: true);
+                });
+        }
+
         [InlineData("true")]
         [InlineData("false")]
         [Theory]

src/HotChocolate/Core/test/Validation.Tests/Extensions/HotChocolateValidationBuilderExtensionsTests.cs

@@ -0,0 +1,24 @@
+using System;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+
+namespace HotChocolate.Validation.Extensions;
+
+public class HotChocolateValidationBuilderExtensionsTests
+{
+    [Fact]
+    public void AddMaxExecutionDepthRule1_Builder_Is_Null()
+    {
+        void Fail()
+            => HotChocolateValidationBuilderExtensions.AddMaxExecutionDepthRule(null!, 5);
+        Assert.Throws<ArgumentNullException>(Fail);
+    }
+
+    [Fact]
+    public void AddMaxExecutionDepthRule2_Builder_Is_Null()
+    {
+        void Fail()
+            => HotChocolateValidationBuilderExtensions.AddMaxExecutionDepthRule(null!, 5, true);
+        Assert.Throws<ArgumentNullException>(Fail);
+    }
+}

src/HotChocolate/Core/test/Validation.Tests/MaxDepthRuleTests.cs

@@ -6,7 +6,7 @@ namespace HotChocolate.Validation
     public class MaxDepthRuleTests : DocumentValidatorVisitorTestBase
     {
         public MaxDepthRuleTests()
-            : base(b => b.AddMaxExecutionDepthRule(3))
+            : base(b => b.AddMaxExecutionDepthRule(3, skipIntrospectionFields: false))
         {
         }
 
@@ -87,6 +87,36 @@ ... on Level3 {
             ");
         }
 
+        [Fact]
+        public void MaxDepth3_IntrospectionQuery_Exceeds_Allowed_Depth_Error()
+        {
+            ExpectErrors(@"
+                query {
+                    __schema {
+                        types {
+                            fields {
+                                type {
+                                    kind
+                                    name
+                                    ofType {
+                                        kind
+                                        name
+                                        ofType {
+                                            kind
+                                            name
+                                            ofType {
+                                                kind
+                                                name
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }");
+        }
+
         [Fact]
         public void MaxDepth3_QueryWith3Levels_Valid()
         {