Scope OperationCache to RequestExecutor (#8055)

Co-authored-by: Michael Staib <michael@chillicream.com>

Author: tobias-tengler

src/HotChocolate/Core/src/Execution/Caching/PreparedOperationCacheOptions.cs

@@ -0,0 +1,6 @@
+namespace HotChocolate.Execution.Caching;
+
+internal sealed class PreparedOperationCacheOptions
+{
+    public int Capacity { get; set; } = 100;
+}

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

@@ -166,8 +166,8 @@ internal static IServiceCollection TryAddDefaultCaches(
     {
         services.TryAddSingleton<IDocumentCache>(
             _ => new DefaultDocumentCache());
-        services.TryAddSingleton<IPreparedOperationCache>(
-            _ => new DefaultPreparedOperationCache());
+        services.TryAddSingleton<PreparedOperationCacheOptions>(
+            _ => new PreparedOperationCacheOptions { Capacity = 100 });
         return services;
     }
 

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

@@ -163,15 +163,6 @@ private static IRequestExecutorBuilder CreateBuilder(
 
         builder.Services.AddValidation(schemaName);
 
-        builder.Configure(
-            (sp, e) =>
-            {
-                e.OnRequestExecutorEvictedHooks.Add(
-                    // when ever we evict this schema we will clear the caches.
-                    new OnRequestExecutorEvictedAction(
-                        _ => sp.GetRequiredService<IPreparedOperationCache>().Clear()));
-            });
-
         builder.TryAddNoOpTransactionScopeHandler();
         builder.TryAddTypeInterceptor<DataLoaderRootFieldTypeInterceptor>();
         builder.TryAddTypeInterceptor<RequirementsTypeInterceptor>();
@@ -193,11 +184,9 @@ public static IServiceCollection AddOperationCache(
         this IServiceCollection services,
         int capacity = 100)
     {
-        services.RemoveAll<IPreparedOperationCache>();
-
-        services.AddSingleton<IPreparedOperationCache>(
-            _ => new DefaultPreparedOperationCache(capacity));
-
+        services.RemoveAll<PreparedOperationCacheOptions>();
+        services.AddSingleton<PreparedOperationCacheOptions>(
+            _ => new PreparedOperationCacheOptions{ Capacity = capacity });
         return services;
     }
 

src/HotChocolate/Core/src/Execution/Pipeline/OperationCacheMiddleware.cs

@@ -10,9 +10,10 @@ internal sealed class OperationCacheMiddleware
     private readonly IExecutionDiagnosticEvents _diagnosticEvents;
     private readonly IPreparedOperationCache _operationCache;
 
-    private OperationCacheMiddleware(RequestDelegate next,
+    private OperationCacheMiddleware(
+        RequestDelegate next,
         [SchemaService] IExecutionDiagnosticEvents diagnosticEvents,
-        IPreparedOperationCache operationCache)
+        [SchemaService] IPreparedOperationCache operationCache)
     {
         _next = next ??
             throw new ArgumentNullException(nameof(next));
@@ -64,7 +65,7 @@ public static RequestCoreMiddleware Create()
         => (core, next) =>
         {
             var diagnosticEvents = core.SchemaServices.GetRequiredService<IExecutionDiagnosticEvents>();
-            var cache = core.Services.GetRequiredService<IPreparedOperationCache>();
+            var cache = core.SchemaServices.GetRequiredService<IPreparedOperationCache>();
             var middleware = new OperationCacheMiddleware(next, diagnosticEvents, cache);
             return context => middleware.InvokeAsync(context);
         };

src/HotChocolate/Core/src/Execution/RequestExecutorResolver.cs

@@ -3,6 +3,7 @@
 using System.Reflection.Metadata;
 using HotChocolate.Configuration;
 using HotChocolate.Execution;
+using HotChocolate.Execution.Caching;
 using HotChocolate.Execution.Configuration;
 using HotChocolate.Execution.Errors;
 using HotChocolate.Execution.Instrumentation;
@@ -237,6 +238,10 @@ await typeModuleChangeMonitor.ConfigureAsync(context, cancellationToken)
         serviceCollection.AddSingleton<IPersistedOperationOptionsAccessor>(
             static s => s.GetRequiredService<RequestExecutorOptions>());
 
+        serviceCollection.AddSingleton<IPreparedOperationCache>(
+            _ => new DefaultPreparedOperationCache(
+                _applicationServices.GetRequiredService<PreparedOperationCacheOptions>().Capacity));
+
         serviceCollection.AddSingleton<IErrorHandler, DefaultErrorHandler>();
 
         serviceCollection.TryAddDiagnosticEvents();

src/HotChocolate/Core/test/Execution.Tests/PreparedOperationCacheTests.cs

@@ -0,0 +1,30 @@
+using HotChocolate.Execution.Caching;
+using HotChocolate.Types;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace HotChocolate.Execution;
+
+public class PreparedOperationCacheTests
+{
+    [Fact]
+    public async Task Operation_Cache_Should_Have_Configured_Capacity()
+    {
+        // arrange
+        var operationCacheCapacity = 517;
+        var services = new ServiceCollection();
+        services.AddOperationCache(operationCacheCapacity);
+        services
+            .AddGraphQL()
+            .AddQueryType(d => d.Field("foo").Resolve(""));
+        var provider = services.BuildServiceProvider();
+        var resolver = provider.GetRequiredService<IRequestExecutorResolver>();
+
+        // act
+        var executor = await resolver.GetRequestExecutorAsync();
+        var operationCache = executor.Services.GetCombinedServices()
+            .GetRequiredService<IPreparedOperationCache>();
+
+        // assert
+        Assert.Equal(operationCache.Capacity, operationCacheCapacity);
+    }
+}

src/HotChocolate/Core/test/Execution.Tests/RequestExecutorResolverTests.cs

@@ -0,0 +1,34 @@
+using HotChocolate.Execution.Caching;
+using HotChocolate.Types;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace HotChocolate.Execution;
+
+public class RequestExecutorResolverTests
+{
+    [Fact]
+    public async Task Operation_Cache_Should_Be_Scoped_To_Executor()
+    {
+        // arrange
+        var services = new ServiceCollection();
+        services
+            .AddGraphQL()
+            .AddQueryType(d => d.Field("foo").Resolve(""));
+        var provider = services.BuildServiceProvider();
+        var resolver = provider.GetRequiredService<IRequestExecutorResolver>();
+
+        // act
+        var firstExecutor = await resolver.GetRequestExecutorAsync();
+        var firstOperationCache = firstExecutor.Services.GetCombinedServices()
+            .GetRequiredService<IPreparedOperationCache>();
+
+        resolver.EvictRequestExecutor();
+
+        var secondExecutor = await resolver.GetRequestExecutorAsync();
+        var secondOperationCache = secondExecutor.Services.GetCombinedServices()
+            .GetRequiredService<IPreparedOperationCache>();
+
+        // assert
+        Assert.NotEqual(secondOperationCache, firstOperationCache);
+    }
+}

src/HotChocolate/Core/test/Execution.Tests/WarmupRequestTests.cs

@@ -34,9 +34,9 @@ public async Task Warmup_Request_Warms_Up_Caches()
         // assert 1
         Assert.IsType<WarmupExecutionResult>(warmupResult);
 
-        var provider = executor.Services.GetCombinedServices();
-        var documentCache = provider.GetRequiredService<IDocumentCache>();
-        var operationCache = provider.GetRequiredService<IPreparedOperationCache>();
+        var documentCache = executor.Services.GetCombinedServices()
+            .GetRequiredService<IDocumentCache>();
+        var operationCache = executor.Services.GetRequiredService<IPreparedOperationCache>();
 
         Assert.True(documentCache.TryGetDocument(documentId, out _));
         Assert.Equal(1, operationCache.Count);