[Fusion] Add Grouping for ExecutionNode

src/HotChocolate/AspNetCore/src/AspNetCore.Pipeline/ExecutorSession.cs

@@ -91,6 +91,7 @@ public async Task<IExecutionResult> ExecuteSingleAsync(
 
         var requestBuilder = OperationRequestBuilder.From(request);
         requestBuilder.SetFlags(flags);
+        requestBuilder.SetServices(context.RequestServices);
 
         await _requestInterceptor.OnCreateAsync(context, _executor, requestBuilder, context.RequestAborted);
 
@@ -116,6 +117,7 @@ public async Task<IResponseStream> ExecuteOperationBatchAsync(
             var requestBuilder = OperationRequestBuilder.From(request);
             requestBuilder.SetOperationName(operationNames[i]);
             requestBuilder.SetFlags(flags);
+            requestBuilder.SetServices(context.RequestServices);
 
             await _requestInterceptor.OnCreateAsync(context, _executor, requestBuilder, context.RequestAborted);
 
@@ -144,6 +146,7 @@ public async Task<IResponseStream> ExecuteBatchAsync(
         {
             var requestBuilder = OperationRequestBuilder.From(requests[i]);
             requestBuilder.SetFlags(flags);
+            requestBuilder.SetServices(context.RequestServices);
 
             await _requestInterceptor.OnCreateAsync(context, _executor, requestBuilder, context.RequestAborted);
 

src/HotChocolate/AspNetCore/src/AspNetCore.Pipeline/HotChocolate.AspNetCore.Pipeline.csproj

@@ -14,6 +14,7 @@
   <ItemGroup>
     <ProjectReference Include="..\Transport.Formatters\HotChocolate.Transport.Formatters.csproj" />
     <ProjectReference Include="..\Transport.Sockets\HotChocolate.Transport.Sockets.csproj" />
+    <ProjectReference Include="..\..\..\Caching\src\Caching.Memory\HotChocolate.Caching.Memory.csproj" />
   </ItemGroup>
 
   <ItemGroup>

src/HotChocolate/AspNetCore/src/AspNetCore.Pipeline/Options/GraphQLServerOptions.cs

@@ -54,5 +54,5 @@ public sealed class GraphQLServerOptions
     /// <summary>
     /// Defines if request batching is enabled.
     /// </summary>
-    public bool EnableBatching { get; set; }
+    public bool EnableBatching { get; set; } = true;
 }

src/HotChocolate/AspNetCore/src/AspNetCore.Pipeline/Subscriptions/OperationSession.cs

@@ -38,7 +38,7 @@ public OperationSession(
     public bool IsCompleted { get; private set; }
 
     public void BeginExecute(GraphQLRequest request, CancellationToken cancellationToken)
-        => SendResultsAsync(request, cancellationToken).FireAndForget();
+        => _ = SendResultsAsync(request, cancellationToken);
 
     private async Task SendResultsAsync(GraphQLRequest request, CancellationToken cancellationToken)
     {

src/HotChocolate/AspNetCore/src/AspNetCore.Pipeline/Utilities/HeaderUtilities.cs

@@ -1,7 +1,7 @@
-using System.Collections.Concurrent;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using HotChocolate.Caching.Memory;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.Primitives;
 using Microsoft.Net.Http.Headers;
@@ -13,8 +13,8 @@ namespace HotChocolate.AspNetCore.Utilities;
 /// </summary>
 internal static class HeaderUtilities
 {
-    private static readonly ConcurrentDictionary<string, CacheEntry> s_cache =
-        new(StringComparer.Ordinal);
+    private static readonly Cache<AcceptHeaderResult> s_headerCache = new(128);
+    private static readonly Cache<AcceptMediaType> s_mediaTypeCache = new(128);
 
     public static readonly AcceptMediaType[] GraphQLResponseContentTypes =
     [
@@ -42,109 +42,95 @@ public static AcceptHeaderResult GetAcceptHeader(HttpRequest request)
                 return new AcceptHeaderResult([]);
             }
 
-            string[] innerArray;
-
             if (count == 1)
             {
                 var headerValue = value[0]!;
 
-                if (TryParseMediaType(headerValue, out var parsedValue))
+                if (s_headerCache.TryGet(headerValue, out var cached))
                 {
-                    return new AcceptHeaderResult([parsedValue]);
+                    return cached;
                 }
 
-                // note: this is a workaround for now. we need to parse this properly.
-                if (headerValue.IndexOf(',', StringComparison.Ordinal) != -1)
-                {
-                    innerArray = headerValue.Split(',');
-                    goto MULTI_VALUES;
-                }
-
-                return new AcceptHeaderResult(headerValue);
-            }
+                var result = ParseHeaderValue(headerValue);
 
-            innerArray = value!;
-
-MULTI_VALUES:
-            ref var searchSpace = ref MemoryMarshal.GetReference(innerArray.AsSpan());
-            var parsedValues = new AcceptMediaType[innerArray.Length];
-            var p = 0;
-
-            for (var i = 0; i < innerArray.Length; i++)
-            {
-                var mediaType = Unsafe.Add(ref searchSpace, i);
-                if (TryParseMediaType(mediaType, out var parsedValue))
-                {
-                    parsedValues[p++] = parsedValue;
-                }
-                else
+                if (!result.HasError)
                 {
-                    return new AcceptHeaderResult(mediaType);
+                    s_headerCache.TryAdd(headerValue, result);
                 }
-            }
 
-            if (parsedValues.Length > p)
-            {
-                Array.Resize(ref parsedValues, p);
+                return result;
             }
 
-            return new AcceptHeaderResult(parsedValues);
+            return ParseMultipleHeaderValues(value!);
         }
 
         return new AcceptHeaderResult([]);
     }
 
-    private static bool TryParseMediaType(string s, out AcceptMediaType value)
+    private static AcceptHeaderResult ParseHeaderValue(string headerValue)
     {
-        MakeSpace();
-
-        // first we try to look up the parsed header in the cache.
-        // if we find it the string was a valid header value and
-        // we return it.
-        if (s_cache.TryGetValue(s, out var entry))
+        if (TryParseMediaType(headerValue, out var parsedValue))
         {
-            value = entry.Value;
-            return true;
+            return new AcceptHeaderResult([parsedValue]);
         }
 
-        // if not we will try to parse it.
-        if (MediaTypeHeaderValue.TryParse(s, out var parsedValue))
+        // note: this is a workaround for now. we need to parse this properly.
+        if (headerValue.IndexOf(',', StringComparison.Ordinal) != -1)
         {
-            entry = s_cache.GetOrAdd(s, k => new CacheEntry(k, parsedValue));
-            value = entry.Value;
-            return true;
+            return ParseMultipleHeaderValues(headerValue.Split(','));
         }
 
-        value = default;
-        return false;
+        return new AcceptHeaderResult(headerValue);
     }
 
-    private static void MakeSpace()
+    private static AcceptHeaderResult ParseMultipleHeaderValues(string[] innerArray)
     {
-        // if we reach the maximum available space we will remove around 20% of the cached items.
-        if (s_cache.Count > 100)
+        ref var searchSpace = ref MemoryMarshal.GetReference(innerArray.AsSpan());
+        var parsedValues = new AcceptMediaType[innerArray.Length];
+        var p = 0;
+
+        for (var i = 0; i < innerArray.Length; i++)
         {
-            foreach (var entry in s_cache.Values.OrderBy(t => t.CreatedAt).Take(20))
+            var mediaType = Unsafe.Add(ref searchSpace, i);
+            if (TryParseMediaType(mediaType, out var parsedValue))
             {
-                s_cache.TryRemove(entry.Key, out _);
+                parsedValues[p++] = parsedValue;
+            }
+            else
+            {
+                return new AcceptHeaderResult(mediaType);
             }
         }
+
+        if (parsedValues.Length > p)
+        {
+            Array.Resize(ref parsedValues, p);
+        }
+
+        return new AcceptHeaderResult(parsedValues);
     }
 
-    private readonly struct CacheEntry
+    private static bool TryParseMediaType(string s, out AcceptMediaType value)
     {
-        public CacheEntry(string key, MediaTypeHeaderValue value)
+        if (s_mediaTypeCache.TryGet(s, out var cached))
         {
-            Key = key;
-            Value = new AcceptMediaType(value.Type, value.SubType, value.Quality, value.Charset);
-            CreatedAt = DateTime.UtcNow;
+            value = cached;
+            return true;
         }
 
-        public string Key { get; }
-
-        public AcceptMediaType Value { get; }
+        if (MediaTypeHeaderValue.TryParse(s, out var parsedValue))
+        {
+            value = new AcceptMediaType(
+                parsedValue.Type,
+                parsedValue.SubType,
+                parsedValue.Quality,
+                parsedValue.Charset);
+            s_mediaTypeCache.TryAdd(s, value);
+            return true;
+        }
 
-        public DateTime CreatedAt { get; }
+        value = default;
+        return false;
     }
 
     internal readonly struct AcceptHeaderResult

src/HotChocolate/AspNetCore/src/Transport.Formatters/EventStreamResultFormatter.cs

@@ -318,7 +318,7 @@ private void EnsureKeepAlive()
 
             if (DateTime.UtcNow - _lastWriteTime >= s_keepAlivePeriod)
             {
-                WriteKeepAliveAsync().FireAndForget();
+                _ = WriteKeepAliveAsync();
             }
 
             async Task WriteKeepAliveAsync()

src/HotChocolate/AspNetCore/src/Transport.Formatters/JsonLinesResultFormatter.cs

@@ -272,7 +272,7 @@ private void EnsureKeepAlive()
 
             if (DateTime.UtcNow - _lastWriteTime >= s_keepAlivePeriod)
             {
-                WriteKeepAliveAsync().FireAndForget();
+                _ = WriteKeepAliveAsync();
             }
 
             async Task WriteKeepAliveAsync()

src/HotChocolate/AspNetCore/src/Transport.Http/DefaultGraphQLHttpClient.cs

@@ -1,5 +1,6 @@
 // ReSharper disable IntroduceOptionalParameters.Global
 
+using System.Diagnostics;
 using System.Net.Http.Headers;
 using System.Text;
 using System.Text.Json;
@@ -187,6 +188,8 @@ private static ByteArrayContent CreatePostContent(
         request.Body.WriteTo(jsonWriter);
         jsonWriter.Flush();
 
+        Debug.WriteLine(Encoding.UTF8.GetString(arrayWriter.WrittenSpan));
+
         var internalBuffer = PooledArrayWriterMarshal.GetUnderlyingBuffer(arrayWriter);
         var content = new ByteArrayContent(internalBuffer, 0, arrayWriter.Length);
         content.Headers.ContentType = new MediaTypeHeaderValue(ContentType.Json, "utf-8");

src/HotChocolate/AspNetCore/src/Transport.Sockets.Client/Protocols/GraphQLOverWebSocket/GraphQLOverWebSocketProtocolHandler.cs

@@ -161,7 +161,7 @@ public void TrySendCompleteMessage()
         {
             if (!_completed)
             {
-                TrySendCompleteMessageInternalAsync(socket, id).FireAndForget();
+                _ = TrySendCompleteMessageInternalAsync(socket, id);
                 _completed = true;
             }
         }

src/HotChocolate/Core/src/Execution.Abstractions/Execution/PooledRequestContext.cs

@@ -1,4 +1,3 @@
-using System.Collections.Concurrent;
 using HotChocolate.Features;
 using HotChocolate.Language;
 
@@ -47,7 +46,7 @@ public PooledRequestContext()
     public override IFeatureCollection Features => _features;
 
     /// <inheritdoc />
-    public override IDictionary<string, object?> ContextData { get; } = new ConcurrentDictionary<string, object?>();
+    public override IDictionary<string, object?> ContextData { get; } = new RequestContextData();
 
     /// <summary>
     /// Initializes the request context after renting it from the pool.