Integrated Gateway into Request Pipeline (#5298)

src/HotChocolate/Core/src/Execution/DependencyInjection/InternalServiceCollectionExtensions.cs

@@ -50,6 +50,7 @@ internal static class InternalServiceCollectionExtensions
         services.TryAddSingleton(_ => new ObjectResultPool(maximumRetained, maximumArrayCapacity));
         services.TryAddSingleton(_ => new ListResultPool(maximumRetained, maximumArrayCapacity));
         services.TryAddSingleton<ResultPool>();
+        services.TryAddTransient<ResultBuilder>();
         return services;
     }
 
@@ -129,18 +130,12 @@ internal static class InternalServiceCollectionExtensions
         {
             var pool = sp.GetRequiredService<ObjectPool<DeferredWorkState>>();
             var state = pool.Get();
-
             return new DeferredWorkStateOwner(state, pool);
         });
 
-        services.TryAddTransient<DeferredWorkScheduler>();
-
         services.TryAddScoped<IFactory<DeferredWorkStateOwner>>(
             sp => new ServiceFactory<DeferredWorkStateOwner>(sp));
 
-        services.TryAddScoped<IFactory<DeferredWorkScheduler>>(
-            sp => new ServiceFactory<DeferredWorkScheduler>(sp));
-
         return services;
     }
 

src/HotChocolate/Core/src/Execution/Processing/DeferredWorkScheduler.cs

@@ -2,26 +2,19 @@
 using System.Threading;
 using HotChocolate.Execution.DependencyInjection;
 using HotChocolate.Execution.Instrumentation;
+using Microsoft.Extensions.DependencyInjection;
 using static HotChocolate.Execution.QueryResultBuilder;
 
 namespace HotChocolate.Execution.Processing;
 
 internal sealed class DeferredWorkScheduler : IDeferredWorkScheduler
 {
-    private readonly IFactory<OperationContextOwner> _operationContextFactory;
-    private readonly IFactory<DeferredWorkStateOwner> _deferredWorkStateFactory;
     private readonly object _stateSync = new();
+    private IFactory<OperationContextOwner> _operationContextFactory = default!;
+    private IFactory<DeferredWorkStateOwner> _deferredWorkStateFactory = default!;
     private OperationContext _parentContext = default!;
     private DeferredWorkStateOwner? _stateOwner;
 
-    public DeferredWorkScheduler(
-        IFactory<OperationContextOwner> operationContextFactory,
-        IFactory<DeferredWorkStateOwner> deferredWorkStateFactory)
-    {
-        _operationContextFactory = operationContextFactory;
-        _deferredWorkStateFactory = deferredWorkStateFactory;
-    }
-
     private DeferredWorkStateOwner StateOwner
     {
         get
@@ -45,7 +38,11 @@ private DeferredWorkStateOwner StateOwner
 
     public void Initialize(OperationContext operationContext)
     {
+        var services = operationContext.Services;
+
         _parentContext = operationContext;
+        _operationContextFactory = services.GetRequiredService<IFactory<OperationContextOwner>>();
+        _deferredWorkStateFactory = services.GetRequiredService<IFactory<DeferredWorkStateOwner>>();
     }
 
     public void InitializeFrom(OperationContext operationContext, DeferredWorkScheduler scheduler)

src/HotChocolate/Core/src/Execution/Processing/OperationContext.Execution.cs

@@ -39,7 +39,7 @@ public ResultBuilder Result
         get
         {
             AssertInitialized();
-            return _resultHelper;
+            return _resultBuilder;
         }
     }
 

src/HotChocolate/Core/src/Execution/Processing/OperationContext.Pooling.cs

@@ -16,7 +16,7 @@ internal sealed partial class OperationContext
     private readonly IFactory<ResolverTask> _resolverTaskFactory;
     private readonly WorkScheduler _workScheduler;
     private readonly DeferredWorkScheduler _deferredWorkScheduler;
-    private readonly ResultBuilder _resultHelper;
+    private readonly ResultBuilder _resultBuilder;
     private readonly PooledPathFactory _pathFactory;
     private ISchema _schema = default!;
     private IErrorHandler _errorHandler = default!;
@@ -35,15 +35,14 @@ internal sealed partial class OperationContext
     public OperationContext(
         IFactory<ResolverTask> resolverTaskFactory,
         PooledPathFactory pathFactory,
-        ResultPool resultPool,
-        ITypeConverter typeConverter,
-        DeferredWorkScheduler deferredWorkScheduler)
+        ResultBuilder resultBuilder,
+        ITypeConverter typeConverter)
     {
         _resolverTaskFactory = resolverTaskFactory;
         _pathFactory = pathFactory;
         _workScheduler = new(this);
-        _deferredWorkScheduler = deferredWorkScheduler;
-        _resultHelper = new(resultPool);
+        _deferredWorkScheduler = new();
+        _resultBuilder = resultBuilder;
         Converter = typeConverter;
     }
 
@@ -75,7 +74,7 @@ internal sealed partial class OperationContext
         IncludeFlags = _operation.CreateIncludeFlags(variables);
         _workScheduler.Initialize(batchDispatcher);
         _deferredWorkScheduler.Initialize(this);
-        _resultHelper.Initialize(_operation, _errorHandler, _diagnosticEvents);
+        _resultBuilder.Initialize(_operation, _errorHandler, _diagnosticEvents);
     }
 
     public void InitializeFrom(OperationContext context)
@@ -97,7 +96,7 @@ public void InitializeFrom(OperationContext context)
         IncludeFlags = _operation.CreateIncludeFlags(_variables);
         _workScheduler.Initialize(_batchDispatcher);
         _deferredWorkScheduler.InitializeFrom(this, context._deferredWorkScheduler);
-        _resultHelper.Initialize(_operation, _errorHandler, _diagnosticEvents);
+        _resultBuilder.Initialize(_operation, _errorHandler, _diagnosticEvents);
     }
 
     public void Clean()
@@ -106,7 +105,7 @@ public void Clean()
         {
             _pathFactory.Clear();
             _workScheduler.Clear();
-            _resultHelper.Clear();
+            _resultBuilder.Clear();
             _schema = default!;
             _errorHandler = default!;
             _activator = default!;

src/HotChocolate/Core/src/Execution/Processing/Result/ResultBuilder.cs

@@ -221,5 +221,3 @@ public int Compare(IError? x, IError? y)
         public static readonly ErrorComparer Default = new();
     }
 }
-
-

src/HotChocolate/Fusion/src/Core/Clients/GraphQLClientFactory.cs

@@ -0,0 +1,14 @@
+namespace HotChocolate.Fusion.Clients;
+
+internal sealed class GraphQLClientFactory
+{
+    private readonly Dictionary<string, IGraphQLClient> _executors;
+
+    public GraphQLClientFactory(IEnumerable<IGraphQLClient> executors)
+    {
+        _executors = executors.ToDictionary(t => t.SchemaName);
+    }
+
+    public IGraphQLClient Create(string schemaName)
+        => _executors[schemaName];
+}

src/HotChocolate/Fusion/src/Core/Execution/HttpRequestExecutor.cs → src/HotChocolate/Fusion/src/Core/Clients/GraphQLHttpClient.cs

@@ -2,24 +2,25 @@
 using System.Net.Http.Headers;
 using System.Text;
 using System.Text.Json;
+using HotChocolate.Fusion.Utilities;
 using HotChocolate.Utilities;
 
-namespace HotChocolate.Fusion.Execution;
+namespace HotChocolate.Fusion.Clients;
 
-public sealed class HttpRequestExecutor : IRemoteRequestExecutor
+public sealed class GraphQLHttpClient : IGraphQLClient
 {
     private readonly IHttpClientFactory _httpClientFactory;
     private readonly JsonRequestFormatter _formatter = new();
 
-    public HttpRequestExecutor(string schemaName, IHttpClientFactory httpClientFactory)
+    public GraphQLHttpClient(string schemaName, IHttpClientFactory httpClientFactory)
     {
         _httpClientFactory = httpClientFactory;
         SchemaName = schemaName;
     }
 
     public string SchemaName { get; }
 
-    public async Task<Response> ExecuteAsync(Request request, CancellationToken cancellationToken)
+    public async Task<GraphQLResponse> ExecuteAsync(GraphQLRequest request, CancellationToken cancellationToken)
     {
         // todo : this is just a naive dummy implementation
         using var writer = new ArrayWriter();
@@ -41,10 +42,24 @@ public async Task<Response> ExecuteAsync(Request request, CancellationToken canc
         }
 
         var document = await JsonDocument.ParseAsync(stream, cancellationToken: cancellationToken);
-        return new Response(document);
+        return new GraphQLResponse(document);
     }
 
-    private HttpRequestMessage CreateRequestMessage(ArrayWriter writer, Request request)
+    public Task<IAsyncEnumerable<GraphQLResponse>> ExecuteBatchAsync(
+        IReadOnlyList<GraphQLRequest> requests,
+        CancellationToken cancellationToken)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<IAsyncEnumerable<GraphQLResponse>> SubscribeAsync(
+        GraphQLRequest graphQLRequests,
+        CancellationToken cancellationToken)
+    {
+        throw new NotImplementedException();
+    }
+
+    private HttpRequestMessage CreateRequestMessage(ArrayWriter writer, GraphQLRequest request)
     {
         _formatter.Write(writer, request);
 

src/HotChocolate/Fusion/src/Core/Execution/Request.cs → src/HotChocolate/Fusion/src/Core/Clients/GraphQLRequest.cs

@@ -1,10 +1,10 @@
 using HotChocolate.Language;
 
-namespace HotChocolate.Fusion.Execution;
+namespace HotChocolate.Fusion.Clients;
 
-public readonly struct Request
+public readonly struct GraphQLRequest
 {
-    public Request(
+    public GraphQLRequest(
         string schemaName,
         DocumentNode document,
         ObjectValueNode? variableValues,

src/HotChocolate/Fusion/src/Core/Clients/GraphQLResponse.cs

@@ -0,0 +1,42 @@
+using System.Text.Json;
+
+namespace HotChocolate.Fusion.Clients;
+
+public sealed class GraphQLResponse : IDisposable
+{
+    private readonly JsonDocument? _document;
+
+    public GraphQLResponse(JsonDocument? document)
+    {
+        _document = document;
+
+        if (_document is not null)
+        {
+            if (_document.RootElement.TryGetProperty(ResponseProperties.Data, out var value))
+            {
+                Data = value;
+            }
+
+            if (_document.RootElement.TryGetProperty(ResponseProperties.Errors, out value))
+            {
+                Errors = value;
+            }
+
+            if (_document.RootElement.TryGetProperty(ResponseProperties.Extensions, out value))
+            {
+                Extensions = value;
+            }
+        }
+    }
+
+    public JsonElement Data { get; }
+
+    public JsonElement Errors { get; }
+
+    public JsonElement Extensions { get; }
+
+    public void Dispose()
+    {
+        _document?.Dispose();
+    }
+}

src/HotChocolate/Fusion/src/Core/Clients/IGraphQLClient.cs

@@ -0,0 +1,18 @@
+namespace HotChocolate.Fusion.Clients;
+
+public interface IGraphQLClient
+{
+    string SchemaName { get; }
+
+    Task<GraphQLResponse> ExecuteAsync(
+        GraphQLRequest request,
+        CancellationToken cancellationToken);
+
+    Task<IAsyncEnumerable<GraphQLResponse>> ExecuteBatchAsync(
+        IReadOnlyList<GraphQLRequest> requests,
+        CancellationToken cancellationToken);
+
+    Task<IAsyncEnumerable<GraphQLResponse>> SubscribeAsync(
+        GraphQLRequest graphQLRequests,
+        CancellationToken cancellationToken);
+}

src/HotChocolate/Fusion/src/Core/Clients/ResponseProperties.cs

@@ -0,0 +1,8 @@
+namespace HotChocolate.Fusion.Clients;
+
+internal static class ResponseProperties
+{
+    public const string Data = "data";
+    public const string Errors = "errors";
+    public const string Extensions = "extensions";
+}

src/HotChocolate/Fusion/src/Core/DependencyInjection/RequestExecutorBuilderExtensions.cs

@@ -0,0 +1,62 @@
+using HotChocolate.Execution.Configuration;
+using HotChocolate.Fusion.Clients;
+using HotChocolate.Fusion.Execution;
+using HotChocolate.Fusion.Metadata;
+using HotChocolate.Fusion.Pipeline;
+using HotChocolate.Fusion.Planning;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+
+// ReSharper disable once CheckNamespace
+namespace Microsoft.Extensions.DependencyInjection;
+
+public static class RequestExecutorBuilderExtensions
+{
+    public static IRequestExecutorBuilder AddGraphQLGateway(
+        this IRequestExecutorBuilder builder,
+        string serviceConfig,
+        string sdl)
+    {
+        var configuration = ServiceConfiguration.Load(serviceConfig);
+
+        return builder
+            .AddDocumentFromString(sdl)
+            .UseField(next => next)
+            .UseDefaultGatewayPipeline()
+            .ConfigureSchemaServices(
+                sc =>
+                {
+                    foreach (var schemaName in configuration.Bindings)
+                    {
+                        sc.AddSingleton<IGraphQLClient>(
+                            sp => new GraphQLHttpClient(
+                                schemaName,
+                                sp.GetApplicationService<IHttpClientFactory>()));
+                    }
+
+                    sc.TryAddSingleton(configuration);
+                    sc.TryAddSingleton<RequestPlaner>();
+                    sc.TryAddSingleton<RequirementsPlaner>();
+                    sc.TryAddSingleton<ExecutionPlanBuilder>();
+                    sc.TryAddSingleton<GraphQLClientFactory>();
+                    sc.TryAddSingleton<FederatedQueryExecutor>();
+                });
+    }
+
+    public static IRequestExecutorBuilder UseDefaultGatewayPipeline(
+        this IRequestExecutorBuilder builder)
+    {
+        return builder
+            .UseInstrumentations()
+            .UseExceptions()
+            .UseTimeout()
+            .UseDocumentCache()
+            .UseDocumentParser()
+            .UseDocumentValidation()
+            .UseOperationCache()
+            .UseOperationComplexityAnalyzer()
+            .UseOperationResolver()
+            .UseOperationVariableCoercion()
+            .UseRequest<QueryPlanMiddleware>()
+            .UseRequest<OperationExecutionMiddleware>();
+    }
+}