[Fusion] Add AddErrorFilter & DisableIntrospection (#8736)

Author: tobias-tengler

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

@@ -69,7 +69,7 @@ public void AddValidationRule_2_Factory_Is_Null()
     }
 
     [Fact]
-    public async Task AddIntrospectionAllowedRule_IntegrationTest_NotAllowed()
+    public async Task DisableIntrospection_NotAllowed()
     {
         await new ServiceCollection()
             .AddGraphQLServer()
@@ -84,69 +84,53 @@ public async Task AddIntrospectionAllowedRule_IntegrationTest_NotAllowed()
     }
 
     [Fact]
-    public async Task AllowIntrospection_IntegrationTest_NotAllowed()
+    public async Task DisableIntrospection_NotAllowed_CustomMessage()
     {
         await new ServiceCollection()
             .AddGraphQLServer()
             .AddQueryType(d => d.Name("Query").Field("foo").Resolve("bar"))
-            .DisableIntrospection(disable: true)
-            .ExecuteRequestAsync(
-                OperationRequestBuilder
-                    .New()
-                    .SetDocument("{ __schema { description } }")
-                    .Build())
-            .MatchSnapshotAsync();
-    }
-
-    [Fact]
-    public async Task AllowIntrospection_IntegrationTest_Allowed()
-    {
-        await new ServiceCollection()
-            .AddGraphQLServer()
-            .AddQueryType(d => d.Name("Query").Field("foo").Resolve("bar"))
-            .DisableIntrospection(disable: false)
+            .DisableIntrospection()
             .ExecuteRequestAsync(
                 OperationRequestBuilder
                     .New()
                     .SetDocument("{ __schema { description } }")
+                    .SetIntrospectionNotAllowedMessage("Bar")
                     .Build())
             .MatchSnapshotAsync();
     }
 
     [Fact]
-    public async Task AllowIntrospection_IntegrationTest_NotAllowed_CustomMessage()
+    public async Task DisableIntrospection_True_NotAllowed()
     {
         await new ServiceCollection()
             .AddGraphQLServer()
             .AddQueryType(d => d.Name("Query").Field("foo").Resolve("bar"))
-            .DisableIntrospection()
+            .DisableIntrospection(disable: true)
             .ExecuteRequestAsync(
                 OperationRequestBuilder
                     .New()
                     .SetDocument("{ __schema { description } }")
-                    .SetIntrospectionNotAllowedMessage("Bar")
                     .Build())
             .MatchSnapshotAsync();
     }
 
     [Fact]
-    public async Task AddIntrospectionAllowedRule_IntegrationTest_NotAllowed_CustomMessage()
+    public async Task DisableIntrospection_False_Allowed()
     {
         await new ServiceCollection()
             .AddGraphQLServer()
             .AddQueryType(d => d.Name("Query").Field("foo").Resolve("bar"))
-            .DisableIntrospection()
+            .DisableIntrospection(disable: false)
             .ExecuteRequestAsync(
                 OperationRequestBuilder
                     .New()
                     .SetDocument("{ __schema { description } }")
-                    .SetIntrospectionNotAllowedMessage("Baz")
                     .Build())
             .MatchSnapshotAsync();
     }
 
     [Fact]
-    public async Task AddIntrospectionAllowedRule_IntegrationTest_Allowed()
+    public async Task DisableIntrospection_Request_AllowIntrospection_Is_Allowed()
     {
         var executor =
             await new ServiceCollection()

src/HotChocolate/Core/test/Execution.Tests/DependencyInjection/__snapshots__/RequestExecutorBuilderExtensionsValidationTests.AddIntrospectionAllowedRule_IntegrationTest_NotAllowed_CustomMessage.snap

@@ -1,4 +1,4 @@
-{
+{
   "data": {
     "__schema": {
       "description": null

src/HotChocolate/Core/test/Execution.Tests/DependencyInjection/__snapshots__/RequestExecutorBuilderExtensionsValidationTests.AddIntrospectionAllowedRule_IntegrationTest_NotAllowed_CustomMessageFact.snap

@@ -0,0 +1,45 @@
+using System.Diagnostics.CodeAnalysis;
+using HotChocolate;
+using HotChocolate.Execution;
+using HotChocolate.Fusion.Configuration;
+using HotChocolate.Fusion.Diagnostics;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+
+namespace Microsoft.Extensions.DependencyInjection;
+
+public static partial class CoreFusionGatewayBuilderExtensions
+{
+    public static IFusionGatewayBuilder AddErrorFilter(
+        this IFusionGatewayBuilder builder,
+        Func<IError, IError> errorFilter)
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+        ArgumentNullException.ThrowIfNull(errorFilter);
+
+        return builder.ConfigureSchemaServices(
+            (_, s) => s.AddSingleton<IErrorFilter>(new FuncErrorFilterWrapper(errorFilter)));
+    }
+
+    public static IFusionGatewayBuilder AddErrorFilter<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] T>(
+        this IFusionGatewayBuilder builder)
+        where T : class, IErrorFilter
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+
+        builder.Services.TryAddSingleton<T>();
+        return builder.ConfigureSchemaServices(
+            (sp, s) => s.AddSingleton<IErrorFilter, T>(_ => sp.GetRequiredService<T>()));
+    }
+
+    public static IFusionGatewayBuilder AddErrorFilter<T>(
+        this IFusionGatewayBuilder builder,
+        Func<IServiceProvider, T> factory)
+        where T : class, IErrorFilter
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+        ArgumentNullException.ThrowIfNull(factory);
+
+        return builder.ConfigureSchemaServices(
+            (sp, s) => s.AddSingleton<IErrorFilter, T>(_ => factory(sp)));
+    }
+}

src/HotChocolate/Core/test/Execution.Tests/DependencyInjection/__snapshots__/RequestExecutorBuilderExtensionsValidationTests.AllowIntrospection_IntegrationTest_Allowed.snap renamed to src/HotChocolate/Core/test/Execution.Tests/DependencyInjection/__snapshots__/RequestExecutorBuilderExtensionsValidationTests.DisableIntrospection_False_Allowed.snap

@@ -0,0 +1,162 @@
+using System.Diagnostics.CodeAnalysis;
+using HotChocolate;
+using HotChocolate.Fusion.Configuration;
+using HotChocolate.Validation;
+using HotChocolate.Validation.Options;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Microsoft.Extensions.DependencyInjection;
+
+public static partial class CoreFusionGatewayBuilderExtensions
+{
+    public static IFusionGatewayBuilder AddValidationVisitor<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] T>(
+        this IFusionGatewayBuilder builder,
+        bool isCacheable = true)
+        where T : DocumentValidatorVisitor, new()
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+        return ConfigureValidation(builder, (_, b) => b.AddVisitor<T>(isCacheable: isCacheable));
+    }
+
+    public static IFusionGatewayBuilder AddValidationVisitor<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)]  T>(
+        this IFusionGatewayBuilder builder,
+        Func<IServiceProvider, ValidationOptions, T> factory,
+        bool isCacheable = true)
+        where T : DocumentValidatorVisitor
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+        ArgumentNullException.ThrowIfNull(factory);
+
+        return ConfigureValidation(
+            builder,
+            (_, b) => b.AddVisitor(factory, isCacheable: isCacheable));
+    }
+
+    public static IFusionGatewayBuilder AddValidationRule<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] T>(
+        this IFusionGatewayBuilder builder)
+        where T : class, IDocumentValidatorRule, new()
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+        return ConfigureValidation(builder, (_, b) => b.AddRule<T>());
+    }
+
+    public static IFusionGatewayBuilder AddValidationRule<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] T>(
+        this IFusionGatewayBuilder builder,
+        Func<IServiceProvider, ValidationOptions, T> factory)
+        where T : class, IDocumentValidatorRule
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+        ArgumentNullException.ThrowIfNull(factory);
+
+        return ConfigureValidation(builder, (_, b) => b.AddRule(factory));
+    }
+
+    public static IFusionGatewayBuilder AddMaxExecutionDepthRule(
+        this IFusionGatewayBuilder builder,
+        int maxAllowedExecutionDepth,
+        bool skipIntrospectionFields = false,
+        bool allowRequestOverrides = false,
+        Func<IServiceProvider, ValidationOptions, bool>? isEnabled = null)
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+
+        ConfigureValidation(
+            builder,
+            (_, b) => b.AddMaxExecutionDepthRule(
+                maxAllowedExecutionDepth,
+                skipIntrospectionFields,
+                allowRequestOverrides,
+                isEnabled));
+        return builder;
+    }
+
+    public static IFusionGatewayBuilder DisableIntrospection(
+        this IFusionGatewayBuilder builder,
+        bool disable = true)
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+
+        return ConfigureValidation(
+            builder,
+            (_, b) => b.ModifyOptions(o => o.DisableIntrospection = disable));
+    }
+
+    public static IFusionGatewayBuilder DisableIntrospection(
+        this IFusionGatewayBuilder builder,
+        Func<IServiceProvider, ValidationOptions, bool> disable)
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+        ArgumentNullException.ThrowIfNull(disable);
+
+        return ConfigureValidation(
+            builder,
+            (s, b) => b.ModifyOptions(o => o.DisableIntrospection = disable(s, o)));
+    }
+
+    public static IFusionGatewayBuilder SetMaxAllowedValidationErrors(
+        this IFusionGatewayBuilder builder,
+        int maxAllowedValidationErrors)
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+
+        ConfigureValidation(
+            builder,
+            (_, b) => b.ModifyOptions(o => o.MaxAllowedErrors = maxAllowedValidationErrors));
+
+        return builder;
+    }
+
+    public static IFusionGatewayBuilder SetIntrospectionAllowedDepth(
+        this IFusionGatewayBuilder builder,
+        ushort maxAllowedOfTypeDepth,
+        ushort maxAllowedListRecursiveDepth)
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+
+        ConfigureValidation(
+            builder,
+            (_, b) => b.ModifyOptions(o =>
+            {
+                o.MaxAllowedOfTypeDepth = maxAllowedOfTypeDepth;
+                o.MaxAllowedListRecursiveDepth = maxAllowedListRecursiveDepth;
+            }));
+
+        return builder;
+    }
+
+    public static IFusionGatewayBuilder AddMaxAllowedFieldCycleDepthRule(
+        this IFusionGatewayBuilder builder,
+        ushort? defaultCycleLimit = 3,
+        (SchemaCoordinate Coordinate, ushort MaxAllowed)[]? coordinateCycleLimits = null,
+        Func<IServiceProvider, ValidationOptions, bool>? isEnabled = null)
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+
+        ConfigureValidation(
+            builder,
+            (_, b) => b.AddMaxAllowedFieldCycleDepthRule(
+                defaultCycleLimit,
+                coordinateCycleLimits,
+                isEnabled));
+
+        return builder;
+    }
+
+    public static IFusionGatewayBuilder RemoveMaxAllowedFieldCycleDepthRule(
+        this IFusionGatewayBuilder builder)
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+
+        ConfigureValidation(builder, (_, b) => b.RemoveMaxAllowedFieldCycleDepthRule());
+        return builder;
+    }
+
+    public static IFusionGatewayBuilder ConfigureValidation(
+        this IFusionGatewayBuilder builder,
+        Action<IServiceProvider, DocumentValidatorBuilder> configure)
+    {
+        return FusionSetupUtilities.Configure(
+            builder,
+            options => options.DocumentValidatorBuilderModifiers.Add(configure));
+    }
+}