Changed filters and formatters to async

Author: Bart Koelman

src/JsonApiDotNetCore/Configuration/JsonApiApplicationBuilder.cs

@@ -79,18 +79,18 @@ public void AddResourceGraph(Type dbContextType, Action<ResourceGraphBuilder> co
         /// <summary>
         /// Configures built-in .NET Core MVC (things like middleware, routing). Most of this configuration can be adjusted for the developers' need.
         /// Before calling .AddJsonApi(), a developer can register their own implementation of the following services to customize startup:
-        /// <see cref="ResourceGraphBuilder"/>, <see cref="ServiceDiscoveryFacade"/>, <see cref="IJsonApiTypeMatchFilter"/>,
-        /// <see cref="IJsonApiExceptionFilter"/> and <see cref="IJsonApiRoutingConvention"/>.
+        /// <see cref="ResourceGraphBuilder"/>, <see cref="ServiceDiscoveryFacade"/>, <see cref="IAsyncResourceTypeMatchFilter"/>,
+        /// <see cref="IAsyncJsonApiExceptionFilter"/> and <see cref="IJsonApiRoutingConvention"/>.
         /// </summary>
         public void ConfigureMvc()
         {
             _mvcBuilder.AddMvcOptions(options =>
             {
                 options.EnableEndpointRouting = true;
-                options.Filters.AddService<IJsonApiExceptionFilter>();
-                options.Filters.AddService<IJsonApiTypeMatchFilter>();
-                options.Filters.AddService<IQueryStringActionFilter>();
-                options.Filters.AddService<IConvertEmptyActionResultFilter>();
+                options.Filters.AddService<IAsyncJsonApiExceptionFilter>();
+                options.Filters.AddService<IAsyncResourceTypeMatchFilter>();
+                options.Filters.AddService<IAsyncQueryStringActionFilter>();
+                options.Filters.AddService<IAsyncConvertEmptyActionResultFilter>();
                 ConfigureMvcOptions?.Invoke(options);
             });
 
@@ -154,10 +154,10 @@ private void AddMiddlewareLayer()
             _services.AddSingleton<IJsonApiOptions>(_options);
             _services.AddSingleton<IJsonApiApplicationBuilder>(this);
             _services.TryAddSingleton<IExceptionHandler, ExceptionHandler>();
-            _services.TryAddScoped<IJsonApiExceptionFilter, JsonApiExceptionFilter>();
-            _services.TryAddScoped<IJsonApiTypeMatchFilter, JsonApiTypeMatchFilter>();
-            _services.TryAddScoped<IQueryStringActionFilter, QueryStringActionFilter>();
-            _services.TryAddScoped<IConvertEmptyActionResultFilter, ConvertEmptyActionResultFilter>();
+            _services.TryAddScoped<IAsyncJsonApiExceptionFilter, AsyncJsonApiExceptionFilter>();
+            _services.TryAddScoped<IAsyncResourceTypeMatchFilter, AsyncResourceTypeMatchFilter>();
+            _services.TryAddScoped<IAsyncQueryStringActionFilter, AsyncQueryStringActionFilter>();
+            _services.TryAddScoped<IAsyncConvertEmptyActionResultFilter, AsyncConvertEmptyActionResultFilter>();
             _services.TryAddSingleton<IJsonApiInputFormatter, JsonApiInputFormatter>();
             _services.TryAddSingleton<IJsonApiOutputFormatter, JsonApiOutputFormatter>();
             _services.TryAddSingleton<IJsonApiRoutingConvention, JsonApiRoutingConvention>();

src/JsonApiDotNetCore/Middleware/AsyncConvertEmptyActionResultFilter.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.AspNetCore.Mvc.Infrastructure;
+
+namespace JsonApiDotNetCore.Middleware
+{
+    /// <inheritdoc />
+    public sealed class AsyncConvertEmptyActionResultFilter : IAsyncConvertEmptyActionResultFilter
+    {
+        /// <inheritdoc />
+        public async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next)
+        {
+            if (context == null) throw new ArgumentNullException(nameof(context));
+            if (next == null) throw new ArgumentNullException(nameof(next));
+
+            if (context.HttpContext.IsJsonApiRequest())
+            {
+                if (!(context.Result is ObjectResult objectResult) || objectResult.Value == null)
+                {
+                    if (context.Result is IStatusCodeActionResult statusCodeResult)
+                    {
+                        context.Result = new ObjectResult(null) {StatusCode = statusCodeResult.StatusCode};
+                    }
+                }
+            }
+
+            await next();
+        }
+    }
+}

src/JsonApiDotNetCore/Middleware/AsyncJsonApiExceptionFilter.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace JsonApiDotNetCore.Middleware
+{
+    /// <inheritdoc />
+    public class AsyncJsonApiExceptionFilter : IAsyncJsonApiExceptionFilter
+    {
+        private readonly IExceptionHandler _exceptionHandler;
+
+        public AsyncJsonApiExceptionFilter(IExceptionHandler exceptionHandler)
+        {
+            _exceptionHandler = exceptionHandler ?? throw new ArgumentNullException(nameof(exceptionHandler));
+        }
+
+        /// <inheritdoc />
+        public Task OnExceptionAsync(ExceptionContext context)
+        {
+            if (context == null) throw new ArgumentNullException(nameof(context));
+
+            if (context.HttpContext.IsJsonApiRequest())
+            {
+                var errorDocument = _exceptionHandler.HandleException(context.Exception);
+
+                context.Result = new ObjectResult(errorDocument)
+                {
+                    StatusCode = (int) errorDocument.GetErrorStatusCode()
+                };
+            }
+
+            return Task.CompletedTask;
+        }
+    }
+}

src/JsonApiDotNetCore/Middleware/AsyncQueryStringActionFilter.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Reflection;
+using System.Threading.Tasks;
+using JsonApiDotNetCore.Controllers.Annotations;
+using JsonApiDotNetCore.QueryStrings;
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace JsonApiDotNetCore.Middleware
+{
+    /// <inheritdoc />
+    public sealed class AsyncQueryStringActionFilter : IAsyncQueryStringActionFilter
+    {
+        private readonly IQueryStringReader _queryStringReader;
+    
+        public AsyncQueryStringActionFilter(IQueryStringReader queryStringReader)
+        {
+            _queryStringReader = queryStringReader ?? throw new ArgumentNullException(nameof(queryStringReader));
+        }
+
+        /// <inheritdoc />
+        public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
+        {
+            if (context == null) throw new ArgumentNullException(nameof(context));
+            if (next == null) throw new ArgumentNullException(nameof(next));
+
+            if (context.HttpContext.IsJsonApiRequest())
+            {
+                var disableQueryStringAttribute = context.Controller.GetType().GetCustomAttribute<DisableQueryStringAttribute>();
+                _queryStringReader.ReadAll(disableQueryStringAttribute);
+            }
+
+            await next();
+        }
+    }
+}

src/JsonApiDotNetCore/Middleware/AsyncResourceTypeMatchFilter.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Linq;
+using System.Net.Http;
+using System.Threading.Tasks;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Errors;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace JsonApiDotNetCore.Middleware
+{
+    /// <inheritdoc />
+    public sealed class AsyncResourceTypeMatchFilter : IAsyncResourceTypeMatchFilter
+    {
+        private readonly IResourceContextProvider _provider;
+
+        public AsyncResourceTypeMatchFilter(IResourceContextProvider provider)
+        {
+            _provider = provider;
+        }
+
+        /// <inheritdoc />
+        public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
+        {
+            if (context == null) throw new ArgumentNullException(nameof(context));
+            if (next == null) throw new ArgumentNullException(nameof(next));
+
+            if (context.HttpContext.IsJsonApiRequest() && IsPatchOrPostRequest(context.HttpContext.Request))
+            {
+                var deserializedType = context.ActionArguments.FirstOrDefault().Value?.GetType();
+                var targetType = context.ActionDescriptor.Parameters.FirstOrDefault()?.ParameterType;
+
+                if (deserializedType != null && targetType != null && deserializedType != targetType)
+                {
+                    var resourceFromEndpoint = _provider.GetResourceContext(targetType);
+                    var resourceFromBody = _provider.GetResourceContext(deserializedType);
+
+                    throw new ResourceTypeMismatchException(new HttpMethod(context.HttpContext.Request.Method), context.HttpContext.Request.Path,
+                        resourceFromEndpoint, resourceFromBody);
+                }
+            }
+
+            await next();
+        }
+
+        private static bool IsPatchOrPostRequest(HttpRequest request)
+        {
+            return request.Method == "PATCH" || request.Method == "POST";
+        }
+    }
+}

src/JsonApiDotNetCore/Middleware/ConvertEmptyActionResultFilter.cs

@@ -8,5 +8,5 @@ namespace JsonApiDotNetCore.Middleware
     /// This ensures our formatter is invoked, where we'll build a json:api compliant response.
     /// For details, see: https://github.com/dotnet/aspnetcore/issues/16969
     /// </summary>
-    public interface IConvertEmptyActionResultFilter : IAlwaysRunResultFilter { }
+    public interface IAsyncConvertEmptyActionResultFilter : IAsyncAlwaysRunResultFilter { }
 }

src/JsonApiDotNetCore/Middleware/IConvertEmptyActionResultFilter.cs renamed to src/JsonApiDotNetCore/Middleware/IAsyncConvertEmptyActionResultFilter.cs

@@ -0,0 +1,9 @@
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace JsonApiDotNetCore.Middleware
+{
+    /// <summary>
+    /// Application-wide exception filter that invokes <see cref="IExceptionHandler"/> for json:api requests.
+    /// </summary>
+    public interface IAsyncJsonApiExceptionFilter : IAsyncExceptionFilter { }
+}

src/JsonApiDotNetCore/Middleware/IAsyncJsonApiExceptionFilter.cs

@@ -0,0 +1,9 @@
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace JsonApiDotNetCore.Middleware
+{
+    /// <summary>
+    /// Application-wide entry point for processing json:api request query strings.
+    /// </summary>
+    public interface IAsyncQueryStringActionFilter : IAsyncActionFilter { }
+}

src/JsonApiDotNetCore/Middleware/IAsyncQueryStringActionFilter.cs

@@ -0,0 +1,9 @@
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace JsonApiDotNetCore.Middleware
+{
+    /// <summary>
+    /// Verifies the incoming resource type in json:api request body matches the resource type at the current endpoint URL.
+    /// </summary>
+    public interface IAsyncResourceTypeMatchFilter : IAsyncActionFilter { }
+}

src/JsonApiDotNetCore/Middleware/IAsyncResourceTypeMatchFilter.cs

@@ -2,5 +2,8 @@
 
 namespace JsonApiDotNetCore.Middleware
 {
+    /// <summary>
+    /// Application-wide entry point for reading json:api request bodies.
+    /// </summary>
     public interface IJsonApiInputFormatter : IInputFormatter { }
 }

src/JsonApiDotNetCore/Middleware/IJsonApiExceptionFilter.cs

@@ -2,5 +2,8 @@
 
 namespace JsonApiDotNetCore.Middleware
 {
+    /// <summary>
+    /// Application-wide entry point for writing json:api response bodies.
+    /// </summary>
     public interface IJsonApiOutputFormatter : IOutputFormatter { }
 }

src/JsonApiDotNetCore/Middleware/IJsonApiInputFormatter.cs

@@ -6,18 +6,18 @@
 
 namespace JsonApiDotNetCore.Middleware
 {
-    /// <summary>
-    /// Extensibility point for reading incoming HTTP request.
-    /// </summary>
+    /// <inheritdoc />
     public sealed class JsonApiInputFormatter : IJsonApiInputFormatter
     {
+        /// <inheritdoc />
         public bool CanRead(InputFormatterContext context)
         {
             if (context == null) throw new ArgumentNullException(nameof(context));
 
             return context.HttpContext.IsJsonApiRequest();
         }
 
+        /// <inheritdoc />
         public async Task<InputFormatterResult> ReadAsync(InputFormatterContext context)
         {
             if (context == null) throw new ArgumentNullException(nameof(context));