OpenAPI tweaks and fixes (#1748)

bkoelman · web-flow · commit f4980c334bc1 · 2025-08-01T16:04:54.000+02:00
* Improve test coverage

* Remove the need for a workaround for "dotnet swagger" (swashbuckle.aspnetcore.cli global tool)

* Fix thread safety when OpenAPI document is downloaded in parallel
diff --git a/src/JsonApiDotNetCore.OpenApi.Swashbuckle/ConfigureMvcOptions.cs b/src/JsonApiDotNetCore.OpenApi.Swashbuckle/ConfigureMvcOptions.cs
@@ -1,45 +1,29 @@
 using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.Middleware;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Options;
 
 namespace JsonApiDotNetCore.OpenApi.Swashbuckle;
 
 internal sealed class ConfigureMvcOptions : IConfigureOptions<MvcOptions>
 {
-    private readonly IJsonApiRoutingConvention _jsonApiRoutingConvention;
     private readonly JsonApiRequestFormatMetadataProvider _jsonApiRequestFormatMetadataProvider;
-    private readonly IJsonApiOptions _jsonApiOptions;
+    private readonly JsonApiOptions _jsonApiOptions;
 
-    public ConfigureMvcOptions(IJsonApiRoutingConvention jsonApiRoutingConvention, JsonApiRequestFormatMetadataProvider jsonApiRequestFormatMetadataProvider,
-        IJsonApiOptions jsonApiOptions)
+    public ConfigureMvcOptions(JsonApiRequestFormatMetadataProvider jsonApiRequestFormatMetadataProvider, IJsonApiOptions jsonApiOptions)
     {
-        ArgumentNullException.ThrowIfNull(jsonApiRoutingConvention);
         ArgumentNullException.ThrowIfNull(jsonApiRequestFormatMetadataProvider);
         ArgumentNullException.ThrowIfNull(jsonApiOptions);
 
-        _jsonApiRoutingConvention = jsonApiRoutingConvention;
         _jsonApiRequestFormatMetadataProvider = jsonApiRequestFormatMetadataProvider;
-        _jsonApiOptions = jsonApiOptions;
+        _jsonApiOptions = (JsonApiOptions)jsonApiOptions;
     }
 
     public void Configure(MvcOptions options)
     {
         ArgumentNullException.ThrowIfNull(options);
 
-        AddSwashbuckleCliCompatibility(options);
-
         options.InputFormatters.Add(_jsonApiRequestFormatMetadataProvider);
 
-        ((JsonApiOptions)_jsonApiOptions).IncludeExtensions(OpenApiMediaTypeExtension.OpenApi, OpenApiMediaTypeExtension.RelaxedOpenApi);
-    }
-
-    private void AddSwashbuckleCliCompatibility(MvcOptions options)
-    {
-        if (!options.Conventions.Any(convention => convention is IJsonApiRoutingConvention))
-        {
-            // See https://github.com/domaindrivendev/Swashbuckle.AspNetCore/issues/1957 for why this is needed.
-            options.Conventions.Insert(0, _jsonApiRoutingConvention);
-        }
+        _jsonApiOptions.IncludeExtensions(OpenApiMediaTypeExtension.OpenApi, OpenApiMediaTypeExtension.RelaxedOpenApi);
     }
 }
diff --git a/src/JsonApiDotNetCore.OpenApi.Swashbuckle/JsonApiActionDescriptorCollectionProvider.cs b/src/JsonApiDotNetCore.OpenApi.Swashbuckle/JsonApiActionDescriptorCollectionProvider.cs
@@ -1,3 +1,4 @@
+using System.Collections.Concurrent;
 using System.Net;
 using System.Reflection;
 using JsonApiDotNetCore.Configuration;
@@ -36,8 +37,10 @@ internal sealed partial class JsonApiActionDescriptorCollectionProvider : IActio
     private readonly JsonApiEndpointMetadataProvider _jsonApiEndpointMetadataProvider;
     private readonly IJsonApiOptions _options;
     private readonly ILogger<JsonApiActionDescriptorCollectionProvider> _logger;
+    private readonly ConcurrentDictionary<int, Lazy<ActionDescriptorCollection>> _versionedActionDescriptorCache = new();
 
-    public ActionDescriptorCollection ActionDescriptors => GetActionDescriptors();
+    public ActionDescriptorCollection ActionDescriptors =>
+        _versionedActionDescriptorCache.GetOrAdd(_defaultProvider.ActionDescriptors.Version, LazyGetActionDescriptors).Value;
 
     public JsonApiActionDescriptorCollectionProvider(IActionDescriptorCollectionProvider defaultProvider, IControllerResourceMapping controllerResourceMapping,
         JsonApiEndpointMetadataProvider jsonApiEndpointMetadataProvider, IJsonApiOptions options, ILogger<JsonApiActionDescriptorCollectionProvider> logger)
@@ -55,7 +58,13 @@ public JsonApiActionDescriptorCollectionProvider(IActionDescriptorCollectionProv
         _logger = logger;
     }
 
-    private ActionDescriptorCollection GetActionDescriptors()
+    private Lazy<ActionDescriptorCollection> LazyGetActionDescriptors(int version)
+    {
+        // https://andrewlock.net/making-getoradd-on-concurrentdictionary-thread-safe-using-lazy/
+        return new Lazy<ActionDescriptorCollection>(() => GetActionDescriptors(version), LazyThreadSafetyMode.ExecutionAndPublication);
+    }
+
+    private ActionDescriptorCollection GetActionDescriptors(int version)
     {
         List<ActionDescriptor> descriptors = [];
 
@@ -106,8 +115,7 @@ private ActionDescriptorCollection GetActionDescriptors()
             descriptors.Add(descriptor);
         }
 
-        int descriptorVersion = _defaultProvider.ActionDescriptors.Version;
-        return new ActionDescriptorCollection(descriptors.AsReadOnly(), descriptorVersion);
+        return new ActionDescriptorCollection(descriptors.AsReadOnly(), version);
     }
 
     internal static bool IsVisibleEndpoint(ActionDescriptor descriptor)
@@ -221,9 +229,9 @@ private ActionDescriptor[] SetEndpointMetadata(ActionDescriptor descriptor, Buil
     {
         Dictionary<RelationshipAttribute, ActionDescriptor> descriptorsByRelationship = [];
 
-        JsonApiEndpointMetadata? endpointMetadata = _jsonApiEndpointMetadataProvider.Get(descriptor);
+        JsonApiEndpointMetadata endpointMetadata = _jsonApiEndpointMetadataProvider.Get(descriptor);
 
-        switch (endpointMetadata?.RequestMetadata)
+        switch (endpointMetadata.RequestMetadata)
         {
             case AtomicOperationsRequestMetadata atomicOperationsRequestMetadata:
             {
@@ -259,7 +267,7 @@ private ActionDescriptor[] SetEndpointMetadata(ActionDescriptor descriptor, Buil
             }
         }
 
-        switch (endpointMetadata?.ResponseMetadata)
+        switch (endpointMetadata.ResponseMetadata)
         {
             case AtomicOperationsResponseMetadata atomicOperationsResponseMetadata:
             {
diff --git a/src/JsonApiDotNetCore.OpenApi.Swashbuckle/JsonApiMetadata/JsonApiEndpointMetadataProvider.cs b/src/JsonApiDotNetCore.OpenApi.Swashbuckle/JsonApiMetadata/JsonApiEndpointMetadataProvider.cs
@@ -26,17 +26,19 @@ public JsonApiEndpointMetadataProvider(IControllerResourceMapping controllerReso
         _nonPrimaryDocumentTypeFactory = nonPrimaryDocumentTypeFactory;
     }
 
-    public JsonApiEndpointMetadata? Get(ActionDescriptor descriptor)
+    public JsonApiEndpointMetadata Get(ActionDescriptor descriptor)
     {
         ArgumentNullException.ThrowIfNull(descriptor);
 
         var actionMethod = OpenApiActionMethod.Create(descriptor);
+        JsonApiEndpointMetadata? metadata = null;
 
         switch (actionMethod)
         {
             case AtomicOperationsActionMethod:
             {
-                return new JsonApiEndpointMetadata(AtomicOperationsRequestMetadata.Instance, AtomicOperationsResponseMetadata.Instance);
+                metadata = new JsonApiEndpointMetadata(AtomicOperationsRequestMetadata.Instance, AtomicOperationsResponseMetadata.Instance);
+                break;
             }
             case JsonApiActionMethod jsonApiActionMethod:
             {
@@ -45,13 +47,13 @@ public JsonApiEndpointMetadataProvider(IControllerResourceMapping controllerReso
 
                 IJsonApiRequestMetadata? requestMetadata = GetRequestMetadata(jsonApiActionMethod.Endpoint, primaryResourceType);
                 IJsonApiResponseMetadata? responseMetadata = GetResponseMetadata(jsonApiActionMethod.Endpoint, primaryResourceType);
-                return new JsonApiEndpointMetadata(requestMetadata, responseMetadata);
-            }
-            default:
-            {
-                return null;
+                metadata = new JsonApiEndpointMetadata(requestMetadata, responseMetadata);
+                break;
             }
         }
+
+        ConsistencyGuard.ThrowIf(metadata == null);
+        return metadata;
     }
 
     private IJsonApiRequestMetadata? GetRequestMetadata(JsonApiEndpoints endpoint, ResourceType primaryResourceType)
diff --git a/src/JsonApiDotNetCore.OpenApi.Swashbuckle/JsonApiRequestFormatMetadataProvider.cs b/src/JsonApiDotNetCore.OpenApi.Swashbuckle/JsonApiRequestFormatMetadataProvider.cs
@@ -1,4 +1,5 @@
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.AspNetCore.Mvc.ApiExplorer;
 using Microsoft.AspNetCore.Mvc.Formatters;
 
@@ -10,12 +11,14 @@ namespace JsonApiDotNetCore.OpenApi.Swashbuckle;
 internal sealed class JsonApiRequestFormatMetadataProvider : IInputFormatter, IApiRequestFormatMetadataProvider
 {
     /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
     public bool CanRead(InputFormatterContext context)
     {
         return false;
     }
 
     /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
     public Task<InputFormatterResult> ReadAsync(InputFormatterContext context)
     {
         throw new UnreachableException();
diff --git a/src/JsonApiDotNetCore.OpenApi.Swashbuckle/SchemaGenerationTracer.cs b/src/JsonApiDotNetCore.OpenApi.Swashbuckle/SchemaGenerationTracer.cs
@@ -1,3 +1,4 @@
+using System.Runtime.CompilerServices;
 using JsonApiDotNetCore.Resources.Annotations;
 using JsonApiDotNetCore.Serialization.Objects;
 using Microsoft.Extensions.Logging;
@@ -87,7 +88,7 @@ private static string GetSchemaTypeName(Type type)
 
     private sealed partial class SchemaGenerationTraceScope : ISchemaGenerationTraceScope
     {
-        private static readonly AsyncLocal<int> RecursionDepthAsyncLocal = new();
+        private static readonly AsyncLocal<StrongBox<int>> RecursionDepthAsyncLocal = new();
 
         private readonly ILogger _logger;
         private readonly string _schemaTypeName;
@@ -101,8 +102,10 @@ public SchemaGenerationTraceScope(ILogger logger, string schemaTypeName)
             _logger = logger;
             _schemaTypeName = schemaTypeName;
 
-            RecursionDepthAsyncLocal.Value++;
-            LogStarted(RecursionDepthAsyncLocal.Value, _schemaTypeName);
+            RecursionDepthAsyncLocal.Value ??= new StrongBox<int>(0);
+            int depth = Interlocked.Increment(ref RecursionDepthAsyncLocal.Value.Value);
+
+            LogStarted(depth, _schemaTypeName);
         }
 
         public void TraceSucceeded(string schemaId)
@@ -112,16 +115,18 @@ public void TraceSucceeded(string schemaId)
 
         public void Dispose()
         {
+            int depth = RecursionDepthAsyncLocal.Value!.Value;
+
             if (_schemaId != null)
             {
-                LogSucceeded(RecursionDepthAsyncLocal.Value, _schemaTypeName, _schemaId);
+                LogSucceeded(depth, _schemaTypeName, _schemaId);
             }
             else
             {
-                LogFailed(RecursionDepthAsyncLocal.Value, _schemaTypeName);
+                LogFailed(depth, _schemaTypeName);
             }
 
-            RecursionDepthAsyncLocal.Value--;
+            Interlocked.Decrement(ref RecursionDepthAsyncLocal.Value.Value);
         }
 
         [LoggerMessage(Level = LogLevel.Trace, SkipEnabledCheck = true, Message = "({Depth:D2}) Started for {SchemaTypeName}.")]
diff --git a/src/JsonApiDotNetCore.OpenApi.Swashbuckle/ServiceCollectionExtensions.cs b/src/JsonApiDotNetCore.OpenApi.Swashbuckle/ServiceCollectionExtensions.cs
@@ -62,7 +62,7 @@ private static void AddCustomApiExplorer(IServiceCollection services)
 
         AddApiExplorer(services);
 
-        services.AddSingleton<IConfigureOptions<MvcOptions>, ConfigureMvcOptions>();
+        services.TryAddEnumerable(ServiceDescriptor.Singleton<IConfigureOptions<MvcOptions>, ConfigureMvcOptions>());
     }
 
     private static void AddApiExplorer(IServiceCollection services)
diff --git a/src/JsonApiDotNetCore/Configuration/ApplicationBuilderExtensions.cs b/src/JsonApiDotNetCore/Configuration/ApplicationBuilderExtensions.cs
@@ -33,20 +33,6 @@ public static void UseJsonApi(this IApplicationBuilder builder)
             inverseNavigationResolver.Resolve();
         }
 
-        var jsonApiApplicationBuilder = builder.ApplicationServices.GetRequiredService<IJsonApiApplicationBuilder>();
-
-        jsonApiApplicationBuilder.ConfigureMvcOptions = options =>
-        {
-            var inputFormatter = builder.ApplicationServices.GetRequiredService<IJsonApiInputFormatter>();
-            options.InputFormatters.Insert(0, inputFormatter);
-
-            var outputFormatter = builder.ApplicationServices.GetRequiredService<IJsonApiOutputFormatter>();
-            options.OutputFormatters.Insert(0, outputFormatter);
-
-            var routingConvention = builder.ApplicationServices.GetRequiredService<IJsonApiRoutingConvention>();
-            options.Conventions.Insert(0, routingConvention);
-        };
-
         builder.UseMiddleware<JsonApiMiddleware>();
     }
 
diff --git a/src/JsonApiDotNetCore/Configuration/ConfigureMvcOptions.cs b/src/JsonApiDotNetCore/Configuration/ConfigureMvcOptions.cs
@@ -0,0 +1,38 @@
+using JsonApiDotNetCore.Middleware;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
+
+namespace JsonApiDotNetCore.Configuration;
+
+internal sealed class ConfigureMvcOptions : IConfigureOptions<MvcOptions>
+{
+    private readonly IJsonApiInputFormatter _inputFormatter;
+    private readonly IJsonApiOutputFormatter _outputFormatter;
+    private readonly IJsonApiRoutingConvention _routingConvention;
+
+    public ConfigureMvcOptions(IJsonApiInputFormatter inputFormatter, IJsonApiOutputFormatter outputFormatter, IJsonApiRoutingConvention routingConvention)
+    {
+        ArgumentNullException.ThrowIfNull(inputFormatter);
+        ArgumentNullException.ThrowIfNull(outputFormatter);
+        ArgumentNullException.ThrowIfNull(routingConvention);
+
+        _inputFormatter = inputFormatter;
+        _outputFormatter = outputFormatter;
+        _routingConvention = routingConvention;
+    }
+
+    public void Configure(MvcOptions options)
+    {
+        ArgumentNullException.ThrowIfNull(options);
+
+        options.EnableEndpointRouting = true;
+
+        options.InputFormatters.Insert(0, _inputFormatter);
+        options.OutputFormatters.Insert(0, _outputFormatter);
+        options.Conventions.Insert(0, _routingConvention);
+
+        options.Filters.AddService<IAsyncJsonApiExceptionFilter>();
+        options.Filters.AddService<IAsyncQueryStringActionFilter>();
+        options.Filters.AddService<IAsyncConvertEmptyActionResultFilter>();
+    }
+}
diff --git a/src/JsonApiDotNetCore/Configuration/IJsonApiApplicationBuilder.cs b/src/JsonApiDotNetCore/Configuration/IJsonApiApplicationBuilder.cs
diff --git a/src/JsonApiDotNetCore/Configuration/JsonApiApplicationBuilder.cs b/src/JsonApiDotNetCore/Configuration/JsonApiApplicationBuilder.cs
@@ -18,22 +18,21 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 
 namespace JsonApiDotNetCore.Configuration;
 
 /// <summary>
 /// A utility class that builds a JSON:API application. It registers all required services and allows the user to override parts of the startup
 /// configuration.
 /// </summary>
-internal sealed class JsonApiApplicationBuilder : IJsonApiApplicationBuilder
+internal sealed class JsonApiApplicationBuilder
 {
     private readonly IServiceCollection _services;
     private readonly IMvcCoreBuilder _mvcBuilder;
     private readonly JsonApiOptions _options = new();
     private readonly ResourceDescriptorAssemblyCache _assemblyCache = new();
 
-    public Action<MvcOptions>? ConfigureMvcOptions { get; set; }
-
     public JsonApiApplicationBuilder(IServiceCollection services, IMvcCoreBuilder mvcBuilder)
     {
         ArgumentNullException.ThrowIfNull(services);
@@ -105,15 +104,6 @@ public void ConfigureResourceGraph(ICollection<Type> dbContextTypes, Action<Reso
     /// </summary>
     public void ConfigureMvc()
     {
-        _mvcBuilder.AddMvcOptions(options =>
-        {
-            options.EnableEndpointRouting = true;
-            options.Filters.AddService<IAsyncJsonApiExceptionFilter>();
-            options.Filters.AddService<IAsyncQueryStringActionFilter>();
-            options.Filters.AddService<IAsyncConvertEmptyActionResultFilter>();
-            ConfigureMvcOptions?.Invoke(options);
-        });
-
         if (_options.ValidateModelState)
         {
             _mvcBuilder.AddDataAnnotations();
@@ -175,14 +165,14 @@ public void ConfigureServiceContainer(ICollection<Type> dbContextTypes)
     private void AddMiddlewareLayer()
     {
         _services.TryAddSingleton<IJsonApiOptions>(_options);
-        _services.TryAddSingleton<IJsonApiApplicationBuilder>(this);
         _services.TryAddSingleton<IExceptionHandler, ExceptionHandler>();
         _services.TryAddScoped<IAsyncJsonApiExceptionFilter, AsyncJsonApiExceptionFilter>();
         _services.TryAddScoped<IAsyncQueryStringActionFilter, AsyncQueryStringActionFilter>();
         _services.TryAddScoped<IAsyncConvertEmptyActionResultFilter, AsyncConvertEmptyActionResultFilter>();
         _services.TryAddSingleton<IJsonApiInputFormatter, JsonApiInputFormatter>();
         _services.TryAddSingleton<IJsonApiOutputFormatter, JsonApiOutputFormatter>();
         _services.TryAddSingleton<IJsonApiRoutingConvention, JsonApiRoutingConvention>();
+        _services.TryAddEnumerable(ServiceDescriptor.Singleton<IConfigureOptions<MvcOptions>, ConfigureMvcOptions>());
         _services.TryAddSingleton<IControllerResourceMapping>(provider => provider.GetRequiredService<IJsonApiRoutingConvention>());
         _services.TryAddSingleton<IJsonApiEndpointFilter, AlwaysEnabledJsonApiEndpointFilter>();
         _services.TryAddSingleton<IHttpContextAccessor, HttpContextAccessor>();
diff --git a/test/OpenApiTests/MixedControllers/MixedControllerTests.cs b/test/OpenApiTests/MixedControllers/MixedControllerTests.cs
diff --git a/test/OpenApiTests/OpenApiTestContext.cs b/test/OpenApiTests/OpenApiTestContext.cs
diff --git a/test/OpenApiTests/ResourceInheritance/ConcurrencyTests.cs b/test/OpenApiTests/ResourceInheritance/ConcurrencyTests.cs

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+using System.Collections.Concurrent;`
`1`	`2`	`using System.Net;`
`2`	`3`	`using System.Reflection;`
`3`	`4`	`using JsonApiDotNetCore.Configuration;`
`@@ -36,8 +37,10 @@ internal sealed partial class JsonApiActionDescriptorCollectionProvider : IActio`
`36`	`37`	`private readonly JsonApiEndpointMetadataProvider _jsonApiEndpointMetadataProvider;`
`37`	`38`	`private readonly IJsonApiOptions _options;`
`38`	`39`	`private readonly ILogger<JsonApiActionDescriptorCollectionProvider> _logger;`
	`40`	`+ private readonly ConcurrentDictionary<int, Lazy<ActionDescriptorCollection>> _versionedActionDescriptorCache = new();`
`39`	`41`
`40`		`- public ActionDescriptorCollection ActionDescriptors => GetActionDescriptors();`
	`42`	`+ public ActionDescriptorCollection ActionDescriptors =>`
	`43`	`+ _versionedActionDescriptorCache.GetOrAdd(_defaultProvider.ActionDescriptors.Version, LazyGetActionDescriptors).Value;`
`41`	`44`
`42`	`45`	`public JsonApiActionDescriptorCollectionProvider(IActionDescriptorCollectionProvider defaultProvider, IControllerResourceMapping controllerResourceMapping,`
`43`	`46`	`JsonApiEndpointMetadataProvider jsonApiEndpointMetadataProvider, IJsonApiOptions options, ILogger<JsonApiActionDescriptorCollectionProvider> logger)`
`@@ -55,7 +58,13 @@ public JsonApiActionDescriptorCollectionProvider(IActionDescriptorCollectionProv`
`55`	`58`	`_logger = logger;`
`56`	`59`	`}`
`57`	`60`
`58`		`- private ActionDescriptorCollection GetActionDescriptors()`
	`61`	`+ private Lazy<ActionDescriptorCollection> LazyGetActionDescriptors(int version)`
	`62`	`+ {`
	`63`	`+ // https://andrewlock.net/making-getoradd-on-concurrentdictionary-thread-safe-using-lazy/`
	`64`	`+ return new Lazy<ActionDescriptorCollection>(() => GetActionDescriptors(version), LazyThreadSafetyMode.ExecutionAndPublication);`
	`65`	`+ }`
	`66`	`+`
	`67`	`+ private ActionDescriptorCollection GetActionDescriptors(int version)`
`59`	`68`	`{`
`60`	`69`	`List<ActionDescriptor> descriptors = [];`
`61`	`70`
`@@ -106,8 +115,7 @@ private ActionDescriptorCollection GetActionDescriptors()`
`106`	`115`	`descriptors.Add(descriptor);`
`107`	`116`	`}`
`108`	`117`
`109`		`- int descriptorVersion = _defaultProvider.ActionDescriptors.Version;`
`110`		`- return new ActionDescriptorCollection(descriptors.AsReadOnly(), descriptorVersion);`
	`118`	`+ return new ActionDescriptorCollection(descriptors.AsReadOnly(), version);`
`111`	`119`	`}`
`112`	`120`
`113`	`121`	`internal static bool IsVisibleEndpoint(ActionDescriptor descriptor)`
`@@ -221,9 +229,9 @@ private ActionDescriptor[] SetEndpointMetadata(ActionDescriptor descriptor, Buil`
`221`	`229`	`{`
`222`	`230`	`Dictionary<RelationshipAttribute, ActionDescriptor> descriptorsByRelationship = [];`
`223`	`231`
`224`		`- JsonApiEndpointMetadata? endpointMetadata = _jsonApiEndpointMetadataProvider.Get(descriptor);`
	`232`	`+ JsonApiEndpointMetadata endpointMetadata = _jsonApiEndpointMetadataProvider.Get(descriptor);`
`225`	`233`
`226`		`- switch (endpointMetadata?.RequestMetadata)`
	`234`	`+ switch (endpointMetadata.RequestMetadata)`
`227`	`235`	`{`
`228`	`236`	`case AtomicOperationsRequestMetadata atomicOperationsRequestMetadata:`
`229`	`237`	`{`
`@@ -259,7 +267,7 @@ private ActionDescriptor[] SetEndpointMetadata(ActionDescriptor descriptor, Buil`
`259`	`267`	`}`
`260`	`268`	`}`
`261`	`269`
`262`		`- switch (endpointMetadata?.ResponseMetadata)`
	`270`	`+ switch (endpointMetadata.ResponseMetadata)`
`263`	`271`	`{`
`264`	`272`	`case AtomicOperationsResponseMetadata atomicOperationsResponseMetadata:`
`265`	`273`	`{`
Original file line number	Diff line number	Diff line change
`@@ -26,17 +26,19 @@ public JsonApiEndpointMetadataProvider(IControllerResourceMapping controllerReso`
`26`	`26`	`_nonPrimaryDocumentTypeFactory = nonPrimaryDocumentTypeFactory;`
`27`	`27`	`}`
`28`	`28`
`29`		`- public JsonApiEndpointMetadata? Get(ActionDescriptor descriptor)`
	`29`	`+ public JsonApiEndpointMetadata Get(ActionDescriptor descriptor)`
`30`	`30`	`{`
`31`	`31`	`ArgumentNullException.ThrowIfNull(descriptor);`
`32`	`32`
`33`	`33`	`var actionMethod = OpenApiActionMethod.Create(descriptor);`
	`34`	`+ JsonApiEndpointMetadata? metadata = null;`
`34`	`35`
`35`	`36`	`switch (actionMethod)`
`36`	`37`	`{`
`37`	`38`	`case AtomicOperationsActionMethod:`
`38`	`39`	`{`
`39`		`- return new JsonApiEndpointMetadata(AtomicOperationsRequestMetadata.Instance, AtomicOperationsResponseMetadata.Instance);`
	`40`	`+ metadata = new JsonApiEndpointMetadata(AtomicOperationsRequestMetadata.Instance, AtomicOperationsResponseMetadata.Instance);`
	`41`	`+ break;`
`40`	`42`	`}`
`41`	`43`	`case JsonApiActionMethod jsonApiActionMethod:`
`42`	`44`	`{`
`@@ -45,13 +47,13 @@ public JsonApiEndpointMetadataProvider(IControllerResourceMapping controllerReso`
`45`	`47`
`46`	`48`	`IJsonApiRequestMetadata? requestMetadata = GetRequestMetadata(jsonApiActionMethod.Endpoint, primaryResourceType);`
`47`	`49`	`IJsonApiResponseMetadata? responseMetadata = GetResponseMetadata(jsonApiActionMethod.Endpoint, primaryResourceType);`
`48`		`- return new JsonApiEndpointMetadata(requestMetadata, responseMetadata);`
`49`		`- }`
`50`		`- default:`
`51`		`- {`
`52`		`- return null;`
	`50`	`+ metadata = new JsonApiEndpointMetadata(requestMetadata, responseMetadata);`
	`51`	`+ break;`
`53`	`52`	`}`
`54`	`53`	`}`
	`54`	`+`
	`55`	`+ ConsistencyGuard.ThrowIf(metadata == null);`
	`56`	`+ return metadata;`
`55`	`57`	`}`
`56`	`58`
`57`	`59`	`private IJsonApiRequestMetadata? GetRequestMetadata(JsonApiEndpoints endpoint, ResourceType primaryResourceType)`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`using System.Diagnostics;`
	`2`	`+using System.Diagnostics.CodeAnalysis;`
`2`	`3`	`using Microsoft.AspNetCore.Mvc.ApiExplorer;`
`3`	`4`	`using Microsoft.AspNetCore.Mvc.Formatters;`
`4`	`5`
`@@ -10,12 +11,14 @@ namespace JsonApiDotNetCore.OpenApi.Swashbuckle;`
`10`	`11`	`internal sealed class JsonApiRequestFormatMetadataProvider : IInputFormatter, IApiRequestFormatMetadataProvider`
`11`	`12`	`{`
`12`	`13`	`/// <inheritdoc />`
	`14`	`+ [ExcludeFromCodeCoverage]`
`13`	`15`	`public bool CanRead(InputFormatterContext context)`
`14`	`16`	`{`
`15`	`17`	`return false;`
`16`	`18`	`}`
`17`	`19`
`18`	`20`	`/// <inheritdoc />`
	`21`	`+ [ExcludeFromCodeCoverage]`
`19`	`22`	`public Task<InputFormatterResult> ReadAsync(InputFormatterContext context)`
`20`	`23`	`{`
`21`	`24`	`throw new UnreachableException();`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+using System.Runtime.CompilerServices;`
`1`	`2`	`using JsonApiDotNetCore.Resources.Annotations;`
`2`	`3`	`using JsonApiDotNetCore.Serialization.Objects;`
`3`	`4`	`using Microsoft.Extensions.Logging;`
`@@ -87,7 +88,7 @@ private static string GetSchemaTypeName(Type type)`
`87`	`88`
`88`	`89`	`private sealed partial class SchemaGenerationTraceScope : ISchemaGenerationTraceScope`
`89`	`90`	`{`
`90`		`- private static readonly AsyncLocal<int> RecursionDepthAsyncLocal = new();`
	`91`	`+ private static readonly AsyncLocal<StrongBox<int>> RecursionDepthAsyncLocal = new();`
`91`	`92`
`92`	`93`	`private readonly ILogger _logger;`
`93`	`94`	`private readonly string _schemaTypeName;`
`@@ -101,8 +102,10 @@ public SchemaGenerationTraceScope(ILogger logger, string schemaTypeName)`
`101`	`102`	`_logger = logger;`
`102`	`103`	`_schemaTypeName = schemaTypeName;`
`103`	`104`
`104`		`- RecursionDepthAsyncLocal.Value++;`
`105`		`- LogStarted(RecursionDepthAsyncLocal.Value, _schemaTypeName);`
	`105`	`+ RecursionDepthAsyncLocal.Value ??= new StrongBox<int>(0);`
	`106`	`+ int depth = Interlocked.Increment(ref RecursionDepthAsyncLocal.Value.Value);`
	`107`	`+`
	`108`	`+ LogStarted(depth, _schemaTypeName);`
`106`	`109`	`}`
`107`	`110`
`108`	`111`	`public void TraceSucceeded(string schemaId)`
`@@ -112,16 +115,18 @@ public void TraceSucceeded(string schemaId)`
`112`	`115`
`113`	`116`	`public void Dispose()`
`114`	`117`	`{`
	`118`	`+ int depth = RecursionDepthAsyncLocal.Value!.Value;`
	`119`	`+`
`115`	`120`	`if (_schemaId != null)`
`116`	`121`	`{`
`117`		`- LogSucceeded(RecursionDepthAsyncLocal.Value, _schemaTypeName, _schemaId);`
	`122`	`+ LogSucceeded(depth, _schemaTypeName, _schemaId);`
`118`	`123`	`}`
`119`	`124`	`else`
`120`	`125`	`{`
`121`		`- LogFailed(RecursionDepthAsyncLocal.Value, _schemaTypeName);`
	`126`	`+ LogFailed(depth, _schemaTypeName);`
`122`	`127`	`}`
`123`	`128`
`124`		`- RecursionDepthAsyncLocal.Value--;`
	`129`	`+ Interlocked.Decrement(ref RecursionDepthAsyncLocal.Value.Value);`
`125`	`130`	`}`
`126`	`131`
`127`	`132`	`[LoggerMessage(Level = LogLevel.Trace, SkipEnabledCheck = true, Message = "({Depth:D2}) Started for {SchemaTypeName}.")]`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ private static void AddCustomApiExplorer(IServiceCollection services)`
`62`	`62`
`63`	`63`	`AddApiExplorer(services);`
`64`	`64`
`65`		`- services.AddSingleton<IConfigureOptions<MvcOptions>, ConfigureMvcOptions>();`
	`65`	`+ services.TryAddEnumerable(ServiceDescriptor.Singleton<IConfigureOptions<MvcOptions>, ConfigureMvcOptions>());`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`private static void AddApiExplorer(IServiceCollection services)`