Added support for error filters to Fusion (#7190)

ChilliCream · Aug 2, 2024 · 044aabe · 044aabe
1 parent d29f583
commit 044aabe
Show file tree

Hide file tree

Showing 9 changed files with 172 additions and 27 deletions.
diff --git a/...otChocolate/Fusion/src/Core/DependencyInjection/FusionRequestExecutorBuilderExtensions.cs b/...otChocolate/Fusion/src/Core/DependencyInjection/FusionRequestExecutorBuilderExtensions.cs
@@ -1,6 +1,7 @@
 using HotChocolate;
 using HotChocolate.Execution;
 using HotChocolate.Execution.Configuration;
+using HotChocolate.Execution.Errors;
 using HotChocolate.Execution.Options;
 using HotChocolate.Execution.Pipeline;
 using HotChocolate.Fusion;
@@ -343,6 +344,66 @@ public static FusionGatewayBuilder ModifyFusionOptions(
         return builder;
     }
 
+    public static FusionGatewayBuilder AddErrorFilter(
+        this FusionGatewayBuilder builder,
+        Func<IError, IError> errorFilter)
+    {
+        if (builder is null)
+        {
+            throw new ArgumentNullException(nameof(builder));
+        }
+
+        if (errorFilter is null)
+        {
+            throw new ArgumentNullException(nameof(errorFilter));
+        }
+
+        builder.CoreBuilder.ConfigureSchemaServices(
+            s => s.AddSingleton<IErrorFilter>(
+                new FuncErrorFilterWrapper(errorFilter)));
+
+        return builder;
+    }
+
+    public static FusionGatewayBuilder AddErrorFilter<T>(
+        this FusionGatewayBuilder builder,
+        Func<IServiceProvider, T> factory)
+        where T : class, IErrorFilter
+    {
+        if (builder is null)
+        {
+            throw new ArgumentNullException(nameof(builder));
+        }
+
+        if (factory is null)
+        {
+            throw new ArgumentNullException(nameof(factory));
+        }
+
+        builder.CoreBuilder.ConfigureSchemaServices(
+            s => s.AddSingleton<IErrorFilter, T>(
+                sp => factory(sp.GetCombinedServices())));
+
+        return builder;
+    }
+
+    public static FusionGatewayBuilder AddErrorFilter<T>(
+        this FusionGatewayBuilder builder)
+        where T : class, IErrorFilter
+    {
+        if (builder is null)
+        {
+            throw new ArgumentNullException(nameof(builder));
+        }
+
+        builder.Services.TryAddSingleton<T>();
+        builder.CoreBuilder.ConfigureSchemaServices(
+            s => s.AddSingleton<IErrorFilter, T>(
+                sp => sp.GetApplicationService<T>()));
+
+        return builder;
+    }
+
     /// <summary>
     /// Uses the default fusion gateway pipeline.
     /// </summary>

diff --git a/src/HotChocolate/Fusion/src/Core/Execution/ExecutionUtils.cs b/src/HotChocolate/Fusion/src/Core/Execution/ExecutionUtils.cs
@@ -492,6 +492,7 @@ public static void ExtractErrors(
         DocumentNode document,
         OperationDefinitionNode operation,
         ResultBuilder resultBuilder,
+        IErrorHandler errorHandler,
         JsonElement errors,
         ObjectResult selectionSetResult,
         int pathDepth,
@@ -505,14 +506,15 @@ public static void ExtractErrors(
         var path = PathHelper.CreatePathFromContext(selectionSetResult);
         foreach (var error in errors.EnumerateArray())
         {
-            ExtractError(document, operation, resultBuilder, error, path, pathDepth, addDebugInfo);
+            ExtractError(document, operation, resultBuilder, errorHandler, error, path, pathDepth, addDebugInfo);
         }
     }
 
     private static void ExtractError(
         DocumentNode document,
         OperationDefinitionNode operation,
         ResultBuilder resultBuilder,
+        IErrorHandler errorHandler,
         JsonElement error,
         Path parentPath,
         int pathDepth,
@@ -577,7 +579,9 @@ private static void ExtractError(
                 errorBuilder.AddLocation(field);
             }
 
-            resultBuilder.AddError(errorBuilder.Build());
+            var handledError = errorHandler.Handle(errorBuilder.Build());
+
+            resultBuilder.AddError(handledError);
         }
     }
 

diff --git a/src/HotChocolate/Fusion/src/Core/Execution/FederatedQueryContext.cs b/src/HotChocolate/Fusion/src/Core/Execution/FederatedQueryContext.cs
@@ -28,14 +28,17 @@ public FusionExecutionContext(
         INodeIdSerializer idSerializer,
         NodeIdParser nodeIdParser,
         FusionOptions options,
-        IFusionDiagnosticEvents diagnosticEvents)
+        IFusionDiagnosticEvents diagnosticEvents,
+        IErrorHandler errorHandler)
     {
         Configuration = configuration ??
             throw new ArgumentNullException(nameof(configuration));
         QueryPlan = queryPlan ??
             throw new ArgumentNullException(nameof(queryPlan));
         DiagnosticEvents = diagnosticEvents ??
             throw new ArgumentNullException(nameof(diagnosticEvents));
+        ErrorHandler = errorHandler ??
+            throw new ArgumentNullException(nameof(errorHandler));
         _operationContextOwner = operationContextOwner ??
             throw new ArgumentNullException(nameof(operationContextOwner));
         _clientFactory = clientFactory ??
@@ -48,6 +51,8 @@ public FusionExecutionContext(
             throw new ArgumentNullException(nameof(options));
     }
 
+    public IErrorHandler ErrorHandler { get; }
+
     /// <summary>
     /// Gets the schema that is being executed on.
     /// </summary>
@@ -177,5 +182,6 @@ public static FusionExecutionContext CreateFrom(
             context._idSerializer,
             context._nodeIdParser,
             context._options,
-            context.DiagnosticEvents);
+            context.DiagnosticEvents,
+            context.ErrorHandler);
 }
diff --git a/src/HotChocolate/Fusion/src/Core/Execution/Nodes/QueryPlan.cs b/src/HotChocolate/Fusion/src/Core/Execution/Nodes/QueryPlan.cs
@@ -190,7 +190,7 @@ public async Task<IOperationResult> ExecuteAsync(
 
             if (context.Result.Errors.Count == 0)
             {
-                var errorHandler = context.OperationContext.ErrorHandler;
+                var errorHandler = context.ErrorHandler;
                 var error = errorHandler.CreateUnexpectedError(ex).Build();
                 error = errorHandler.Handle(error);
                 context.Result.AddError(error);

diff --git a/src/HotChocolate/Fusion/src/Core/Execution/Nodes/Resolve.cs b/src/HotChocolate/Fusion/src/Core/Execution/Nodes/Resolve.cs
@@ -76,8 +76,11 @@ protected override async Task OnExecuteAsync(
         catch (Exception ex)
         {
             context.DiagnosticEvents.ResolveError(ex);
-            var error = context.OperationContext.ErrorHandler.CreateUnexpectedError(ex);
-            context.Result.AddError(error.Build());
+
+            var errorHandler = context.ErrorHandler;
+            var error = errorHandler.CreateUnexpectedError(ex).Build();
+            error = errorHandler.Handle(error);
+            context.Result.AddError(error);
         }
     }
 
@@ -149,6 +152,7 @@ private void ProcessResponses(
                 context.Operation.Document,
                 context.Operation.Definition,
                 context.Result,
+                context.ErrorHandler,
                 response.Errors,
                 selectionSetResult,
                 pathLength,

diff --git a/src/HotChocolate/Fusion/src/Core/Execution/Nodes/ResolveByKeyBatch.cs b/src/HotChocolate/Fusion/src/Core/Execution/Nodes/ResolveByKeyBatch.cs
@@ -96,8 +96,11 @@ protected override async Task OnExecuteAsync(
         catch (Exception ex)
         {
             context.DiagnosticEvents.ResolveByKeyBatchError(ex);
-            var error = context.OperationContext.ErrorHandler.CreateUnexpectedError(ex);
-            context.Result.AddError(error.Build());
+
+            var errorHandler = context.ErrorHandler;
+            var error = errorHandler.CreateUnexpectedError(ex).Build();
+            error = errorHandler.Handle(error);
+            context.Result.AddError(error);
         }
     }
 
@@ -155,6 +158,7 @@ private void ProcessResult(
                     context.Operation.Document,
                     context.Operation.Definition,
                     context.Result,
+                    context.ErrorHandler,
                     response.Errors,
                     batchState.SelectionSetResult,
                     pathLength + 1,

diff --git a/src/HotChocolate/Fusion/src/Core/Execution/Pipeline/OperationExecutionMiddleware.cs b/src/HotChocolate/Fusion/src/Core/Execution/Pipeline/OperationExecutionMiddleware.cs
@@ -22,7 +22,8 @@ internal sealed class DistributedOperationExecutionMiddleware(
     [SchemaService] GraphQLClientFactory clientFactory,
     [SchemaService] NodeIdParser nodeIdParser,
     [SchemaService] FusionOptions options,
-    [SchemaService] IFusionDiagnosticEvents diagnosticEvents)
+    [SchemaService] IFusionDiagnosticEvents diagnosticEvents,
+    [SchemaService] IErrorHandler errorHandler)
 {
     private static readonly object _queryRoot = new();
     private static readonly object _mutationRoot = new();
@@ -44,6 +45,8 @@ internal sealed class DistributedOperationExecutionMiddleware(
         ?? throw new ArgumentNullException(nameof(options));
     private readonly IFusionDiagnosticEvents _diagnosticEvents = diagnosticEvents
         ?? throw new ArgumentNullException(nameof(diagnosticEvents));
+    private readonly IErrorHandler _errorHandler = errorHandler
+        ?? throw new ArgumentNullException(nameof(errorHandler));
 
     public async ValueTask InvokeAsync(
         IRequestContext context,
@@ -78,7 +81,8 @@ context.Variables is not null &&
                     _nodeIdSerializer,
                     _nodeIdParser,
                     _fusionOptionsAccessor,
-                    diagnosticEvents);
+                    _diagnosticEvents,
+                    _errorHandler);
 
             using (federatedQueryContext.DiagnosticEvents.ExecuteFederatedQuery(context))
             {
@@ -119,6 +123,7 @@ public static RequestCoreMiddleware Create()
             var nodeIdParser = core.SchemaServices.GetRequiredService<NodeIdParser>();
             var fusionOptionsAccessor = core.SchemaServices.GetRequiredService<FusionOptions>();
             var diagnosticEvents = core.SchemaServices.GetRequiredService<IFusionDiagnosticEvents>();
+            var errorHandler = core.SchemaServices.GetRequiredService<IErrorHandler>();
             var middleware = new DistributedOperationExecutionMiddleware(
                 next,
                 contextFactory,
@@ -127,7 +132,8 @@ public static RequestCoreMiddleware Create()
                 clientFactory,
                 nodeIdParser,
                 fusionOptionsAccessor,
-                diagnosticEvents);
+                diagnosticEvents,
+                errorHandler);
             return async context =>
             {
                 var batchDispatcher = context.Services.GetRequiredService<IBatchDispatcher>();

diff --git a/src/HotChocolate/Fusion/test/Core.Tests/SubgraphErrorTests.cs b/src/HotChocolate/Fusion/test/Core.Tests/SubgraphErrorTests.cs
@@ -1,3 +1,4 @@
+using CookieCrumble;
 using HotChocolate.Fusion.Shared;
 using HotChocolate.Execution;
 using Microsoft.Extensions.DependencyInjection;
@@ -2918,4 +2919,56 @@ type Product {
     }
 
     #endregion
+
+    [Fact]
+    public async Task ErrorFilter_Is_Applied()
+    {
+        // arrange
+        var subgraph = await TestSubgraph.CreateAsync(
+            """
+            type Query {
+              field: String @error
+            }
+            """
+        );
+
+        using var subgraphs = new TestSubgraphCollection(output, [subgraph]);
+        var executor = await subgraphs.GetExecutorAsync(
+            configureBuilder: builder =>
+                builder.AddErrorFilter(error => error.WithMessage("REPLACED MESSAGE").WithCode("CUSTOM_CODE")));
+        var request = """
+                      query {
+                        field
+                      }
+                      """;
+
+        // act
+        var result = await executor.ExecuteAsync(request);
+
+        // assert
+        result.MatchInlineSnapshot("""
+                                   {
+                                     "errors": [
+                                       {
+                                         "message": "REPLACED MESSAGE",
+                                         "locations": [
+                                           {
+                                             "line": 2,
+                                             "column": 3
+                                           }
+                                         ],
+                                         "path": [
+                                           "field"
+                                         ],
+                                         "extensions": {
+                                           "code": "CUSTOM_CODE"
+                                         }
+                                       }
+                                     ],
+                                     "data": {
+                                       "field": null
+                                     }
+                                   }
+                                   """);
+    }
 }
diff --git a/src/HotChocolate/Fusion/test/Shared/TestSubgraphCollection.cs b/src/HotChocolate/Fusion/test/Shared/TestSubgraphCollection.cs
@@ -19,25 +19,40 @@ public IHttpClientFactory GetHttpClientFactory()
         return new TestSubgraphCollectionHttpClientFactory(subgraphsDictionary);
     }
 
-    public async Task<IRequestExecutor> GetExecutorAsync(FusionFeatureCollection? features = null)
+    public async Task<IRequestExecutor> GetExecutorAsync(
+        FusionFeatureCollection? features = null,
+        Action<FusionGatewayBuilder>? configureBuilder = null)
     {
         var fusionGraph = await ComposeFusionGraphAsync(features);
 
-        return await GetExecutorAsync(fusionGraph);
+        return await GetExecutorAsync(fusionGraph, configureBuilder);
     }
 
-    public async Task<IRequestExecutor> GetExecutorAsync(Skimmed.SchemaDefinition fusionGraph)
+    public void Dispose()
+    {
+        foreach (var subgraph in subgraphs)
+        {
+            subgraph.TestServer.Dispose();
+        }
+    }
+
+    private async Task<IRequestExecutor> GetExecutorAsync(
+        Skimmed.SchemaDefinition fusionGraph,
+        Action<FusionGatewayBuilder>? configureBuilder = null)
     {
         var httpClientFactory = GetHttpClientFactory();
 
-        return await new ServiceCollection()
+        var builder = new ServiceCollection()
             .AddSingleton(httpClientFactory)
             .AddFusionGatewayServer()
-            .ConfigureFromDocument(SchemaFormatter.FormatAsDocument(fusionGraph))
-            .BuildRequestExecutorAsync();
+            .ConfigureFromDocument(SchemaFormatter.FormatAsDocument(fusionGraph));
+
+        configureBuilder?.Invoke(builder);
+
+        return await builder.BuildRequestExecutorAsync();
     }
 
-    public async Task<Skimmed.SchemaDefinition> ComposeFusionGraphAsync(FusionFeatureCollection? features = null)
+    private async Task<Skimmed.SchemaDefinition> ComposeFusionGraphAsync(FusionFeatureCollection? features = null)
     {
         features ??= new FusionFeatureCollection(FusionFeatures.NodeField);
 
@@ -59,14 +74,6 @@ public async Task<IRequestExecutor> GetExecutorAsync(Skimmed.SchemaDefinition fu
             .ComposeAsync(configurations, features);
     }
 
-    public void Dispose()
-    {
-        foreach (var subgraph in subgraphs)
-        {
-            subgraph.TestServer.Dispose();
-        }
-    }
-
     private IEnumerable<(string SubgraphName, TestSubgraph Subgraph)> GetSubgraphs()
         => subgraphs.Select((s, i) => ($"Subgraph_{++i}", s));