Cleanup

Author: tobias-tengler

src/HotChocolate/AspNetCore/src/AspNetCore/Warmup/RequestExecutorWarmupService.cs

@@ -14,7 +14,7 @@ public async Task StartAsync(CancellationToken cancellationToken)
         foreach (var schemaName in provider.SchemaNames)
         {
             var setup = await executorOptionsMonitor.GetAsync(schemaName, cancellationToken);
-            var options = CreateSchemaOptions(setup);
+            var options = setup.CreateSchemaOptions();
 
             if (!options.LazyInitialization)
             {
@@ -32,16 +32,4 @@ private async Task WarmupAsync(string schemaName, CancellationToken cancellation
     {
         await provider.GetExecutorAsync(schemaName, cancellationToken).ConfigureAwait(false);
     }
-
-    private static SchemaOptions CreateSchemaOptions(RequestExecutorSetup setup)
-    {
-        var options = new SchemaOptions();
-
-        foreach (var configure in setup.SchemaOptionModifiers)
-        {
-            configure(options);
-        }
-
-        return options;
-    }
 }

src/HotChocolate/Core/src/Execution/Configuration/DefaultRequestExecutorOptionsMonitor.cs

@@ -3,6 +3,7 @@
 
 namespace HotChocolate.Execution.Configuration;
 
+// TODO: Do we still need this?
 internal sealed class DefaultRequestExecutorOptionsMonitor(
     IOptionsMonitor<RequestExecutorSetup> optionsMonitor,
     IEnumerable<IRequestExecutorOptionsProvider> optionsProviders)

src/HotChocolate/Core/src/Execution/Configuration/RequestExecutorSetup.cs

@@ -134,4 +134,16 @@ public void CopyTo(RequestExecutorSetup options)
             options.DefaultPipelineFactory = DefaultPipelineFactory;
         }
     }
+
+    internal SchemaOptions CreateSchemaOptions()
+    {
+        var options = new SchemaOptions();
+
+        foreach (var configure in SchemaOptionModifiers)
+        {
+            configure(options);
+        }
+
+        return options;
+    }
 }

src/HotChocolate/Core/src/Execution/DependencyInjection/RequestExecutorBuilderExtensions.Caches.cs

@@ -0,0 +1,33 @@
+using HotChocolate;
+using HotChocolate.Execution.Caching;
+using HotChocolate.Execution.Configuration;
+using HotChocolate.Language;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Options;
+
+namespace Microsoft.Extensions.DependencyInjection;
+
+public static partial class RequestExecutorBuilderExtensions
+{
+    internal static IRequestExecutorBuilder AddDocumentCache(this IRequestExecutorBuilder builder)
+    {
+        builder.Services.TryAddKeyedSingleton<IDocumentCache>(
+            builder.Name,
+            static (sp, schemaName) =>
+            {
+                var optionsMonitor = sp.GetRequiredService<IOptionsMonitor<RequestExecutorSetup>>();
+                var setup = optionsMonitor.Get((string)schemaName!);
+                var options = setup.CreateSchemaOptions();
+
+                return new DefaultDocumentCache(options.OperationDocumentCacheSize);
+            });
+
+        return builder.ConfigureSchemaServices(
+            static (applicationServices, s) =>
+                s.AddSingleton<IDocumentCache>(schemaServices =>
+                {
+                    var schemaName = schemaServices.GetRequiredService<ISchemaDefinition>().Name;
+                    return applicationServices.GetRequiredKeyedService<IDocumentCache>(schemaName);
+                }));
+    }
+}

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

@@ -155,6 +155,8 @@ private static DefaultRequestExecutorBuilder CreateBuilder(
         builder.TryAddTypeInterceptor<DataLoaderRootFieldTypeInterceptor>();
         builder.TryAddTypeInterceptor<RequirementsTypeInterceptor>();
 
+        builder.AddDocumentCache();
+
         if (!services.Any(t =>
             t.ServiceType == typeof(SchemaName)
             && t.ImplementationInstance is SchemaName s

src/HotChocolate/Core/src/Execution/HotChocolate.Execution.csproj

@@ -229,6 +229,9 @@
     <Compile Update="RequestExecutorManager.Warmup.cs">
       <DependentUpon>RequestExecutorManager.cs</DependentUpon>
     </Compile>
+    <Compile Update="DependencyInjection\RequestExecutorBuilderExtensions.Caches.cs">
+      <DependentUpon>RequestExecutorBuilderExtensions.cs</DependentUpon>
+    </Compile>
   </ItemGroup>
 
   <ItemGroup>

src/HotChocolate/Core/src/Execution/RequestExecutorManager.cs

@@ -172,7 +172,7 @@ await _optionsMonitor.GetAsync(schemaName, cancellationToken)
         }
 
         var schemaServices =
-            await CreateSchemaServicesAsync(context, setup, options, typeModuleChangeMonitor, cancellationToken)
+            await CreateSchemaServicesAsync(context, setup, typeModuleChangeMonitor, cancellationToken)
                 .ConfigureAwait(false);
 
         var registeredExecutor = new RegisteredExecutor(
@@ -242,7 +242,6 @@ private static async Task RunEvictionEvents(RegisteredExecutor registeredExecuto
     private async Task<ServiceProvider> CreateSchemaServicesAsync(
         ConfigurationContext context,
         RequestExecutorSetup setup,
-        SchemaOptions schemaOptions,
         TypeModuleChangeMonitor typeModuleChangeMonitor,
         CancellationToken cancellationToken)
     {
@@ -269,7 +268,6 @@ await typeModuleChangeMonitor.ConfigureAsync(context, cancellationToken)
 
         serviceCollection.AddSingleton(new SchemaVersionInfo(version));
 
-        serviceCollection.AddSingleton(schemaOptions);
         serviceCollection.AddSingleton(executorOptions);
         serviceCollection.AddSingleton<IRequestExecutorOptionsAccessor>(
             static sp => sp.GetRequiredService<RequestExecutorOptions>());
@@ -285,7 +283,7 @@ await typeModuleChangeMonitor.ConfigureAsync(context, cancellationToken)
         serviceCollection.AddSingleton<IPreparedOperationCache>(
             static sp =>
             {
-                var options = sp.GetRequiredService<SchemaOptions>();
+                var options = sp.GetRequiredService<ISchemaDefinition>().GetOptions();
                 return new DefaultPreparedOperationCache(options.PreparedOperationCacheSize);
             });
 
@@ -294,12 +292,6 @@ await typeModuleChangeMonitor.ConfigureAsync(context, cancellationToken)
             static sp => sp.GetRootServiceProvider().GetRequiredService<ParserOptions>());
         serviceCollection.AddSingleton(
             static sp => sp.GetRootServiceProvider().GetRequiredService<IDocumentHashProvider>());
-        serviceCollection.AddSingleton<IDocumentCache>(
-            static sp =>
-            {
-                var options = sp.GetRequiredService<SchemaOptions>();
-                return new DefaultDocumentCache(options.OperationDocumentCacheSize);
-            });
 
         serviceCollection.TryAddDiagnosticEvents();
         serviceCollection.TryAddOperationExecutors();

src/HotChocolate/Core/src/Types/Extensions/SchemaExtensions.cs

@@ -1,4 +1,5 @@
 using System.Diagnostics.CodeAnalysis;
+using HotChocolate.Features;
 using HotChocolate.Language;
 using HotChocolate.Types;
 using TypeThrowHelper = HotChocolate.Utilities.ThrowHelper;
@@ -295,4 +296,18 @@ public static ITypeSystemMember GetMember(
 
         throw TypeThrowHelper.Schema_GetMember_TypeNotFound(coordinate);
     }
+
+    /// <summary>
+    /// Gets the <see cref="IReadOnlySchemaOptions"/> of the <paramref name="schema"/>.
+    /// </summary>
+    /// <param name="schema">
+    /// The schema to get the options for.
+    /// </param>
+    /// <returns>
+    /// The schema options.
+    /// </returns>
+    internal static IReadOnlySchemaOptions GetOptions(this ISchemaDefinition schema)
+    {
+        return schema.Features.GetRequired<IReadOnlySchemaOptions>();
+    }
 }

src/HotChocolate/Core/src/Types/SchemaBuilder.cs

@@ -36,6 +36,7 @@ private SchemaBuilder()
         typeInterceptors.TryAdd(new MiddlewareValidationTypeInterceptor());
         typeInterceptors.TryAdd(new SemanticNonNullTypeInterceptor());
         typeInterceptors.TryAdd(new StoreGlobalPagingOptionsTypeInterceptor());
+        typeInterceptors.TryAdd(new StoreGlobalSchemaOptionsTypeInterceptor());
 
         Features.Set(typeInterceptors);
     }

src/HotChocolate/Core/src/Types/StoreGlobalSchemaOptionsTypeInterceptor.cs

@@ -0,0 +1,18 @@
+using HotChocolate.Configuration;
+using HotChocolate.Types.Descriptors.Configurations;
+
+namespace HotChocolate;
+
+internal sealed class StoreGlobalSchemaOptionsTypeInterceptor : TypeInterceptor
+{
+    public override void OnBeforeCompleteType(
+        ITypeCompletionContext completionContext,
+        TypeSystemConfiguration configuration)
+    {
+        if (configuration is SchemaTypeConfiguration schemaDef)
+        {
+            var options = completionContext.DescriptorContext.Options;
+            schemaDef.Features.Set(options);
+        }
+    }
+}