At startup, a single instance of CurrentRequestMiddleware is created, which is used to process multiple requests in parallel. Therefore it cannot contain request-specific state in its fields, because parallel requests then overwrite the state of each other. (#728)

Bart Koelman · web-flow · commit 6b16ea3119d0 · 2020-04-29T12:51:07.000+02:00
As a result of overwriting state, the FilterService is unable to find the matching CurrentRequest data, causing a NullReferenceException in its constructor.
diff --git a/src/Examples/GettingStarted/Startup.cs b/src/Examples/GettingStarted/Startup.cs
@@ -22,7 +22,9 @@ public void ConfigureServices(IServiceCollection services)
 
         public void Configure(IApplicationBuilder app, SampleDbContext context)
         {
-            context.Database.EnsureDeleted(); // indices need to be reset
+            // indices need to be reset
+            context.Database.EnsureDeleted();
+            context.Database.EnsureCreated();
             app.UseJsonApi();
         }
     }
diff --git a/src/JsonApiDotNetCore/Middleware/CurrentRequestMiddleware.cs b/src/JsonApiDotNetCore/Middleware/CurrentRequestMiddleware.cs
@@ -22,100 +22,94 @@ namespace JsonApiDotNetCore.Middleware
     public sealed class CurrentRequestMiddleware
     {
         private readonly RequestDelegate _next;
-        private HttpContext _httpContext;
-        private ICurrentRequest _currentRequest;
-        private IResourceGraph _resourceGraph;
-        private IJsonApiOptions _options;
-        private RouteValueDictionary _routeValues;
-        private IControllerResourceMapping _controllerResourceMapping;
 
         public CurrentRequestMiddleware(RequestDelegate next)
         {
             _next = next;
         }
 
         public async Task Invoke(HttpContext httpContext,
-                                 IControllerResourceMapping controllerResourceMapping,
-                                 IJsonApiOptions options,
-                                 ICurrentRequest currentRequest,
-                                 IResourceGraph resourceGraph)
+            IControllerResourceMapping controllerResourceMapping,
+            IJsonApiOptions options,
+            ICurrentRequest currentRequest,
+            IResourceGraph resourceGraph)
         {
-            _httpContext = httpContext;
-            _currentRequest = currentRequest;
-            _controllerResourceMapping = controllerResourceMapping;
-            _resourceGraph = resourceGraph;
-            _options = options;
-            _routeValues = httpContext.GetRouteData().Values;
-            var requestResource = GetCurrentEntity();
+            var routeValues = httpContext.GetRouteData().Values;
+            var requestContext = new RequestContext(httpContext, currentRequest, resourceGraph, options, routeValues,
+                controllerResourceMapping);
+
+            var requestResource = GetCurrentEntity(requestContext);
             if (requestResource != null)
             {
-                _currentRequest.SetRequestResource(requestResource);
-                _currentRequest.IsRelationshipPath = PathIsRelationship();
-                _currentRequest.BasePath = GetBasePath(requestResource.ResourceName);
-                _currentRequest.BaseId = GetBaseId();
-                _currentRequest.RelationshipId = GetRelationshipId();
+                requestContext.CurrentRequest.SetRequestResource(requestResource);
+                requestContext.CurrentRequest.IsRelationshipPath = PathIsRelationship(requestContext.RouteValues);
+                requestContext.CurrentRequest.BasePath = GetBasePath(requestContext, requestResource.ResourceName);
+                requestContext.CurrentRequest.BaseId = GetBaseId(requestContext.RouteValues);
+                requestContext.CurrentRequest.RelationshipId = GetRelationshipId(requestContext);
             }
 
-            if (await IsValidAsync())
+            if (await IsValidAsync(requestContext))
             {
-                await _next(httpContext);
+                await _next(requestContext.HttpContext);
             }
         }
 
-        private string GetBaseId()
+        private static string GetBaseId(RouteValueDictionary routeValues)
         {
-            if (_routeValues.TryGetValue("id", out object stringId))
+            if (routeValues.TryGetValue("id", out object stringId))
             {
                 return (string)stringId;
             }
 
             return null;
         }
-        private string GetRelationshipId()
+
+        private static string GetRelationshipId(RequestContext requestContext)
         {
-            if (!_currentRequest.IsRelationshipPath)
+            if (!requestContext.CurrentRequest.IsRelationshipPath)
             {
                 return null;
             }
-            var components = SplitCurrentPath();
+            var components = SplitCurrentPath(requestContext);
             var toReturn = components.ElementAtOrDefault(4);
 
             return toReturn;
         }
-        private string[] SplitCurrentPath()
+
+        private static string[] SplitCurrentPath(RequestContext requestContext)
         {
-            var path = _httpContext.Request.Path.Value;
-            var ns = $"/{_options.Namespace}";
+            var path = requestContext.HttpContext.Request.Path.Value;
+            var ns = $"/{requestContext.Options.Namespace}";
             var nonNameSpaced = path.Replace(ns, "");
             nonNameSpaced = nonNameSpaced.Trim('/');
             var individualComponents = nonNameSpaced.Split('/');
             return individualComponents;
         }
 
-        private string GetBasePath(string resourceName = null)
+        private static string GetBasePath(RequestContext requestContext, string resourceName = null)
         {
-            var r = _httpContext.Request;
-            if (_options.RelativeLinks)
+            var r = requestContext.HttpContext.Request;
+            if (requestContext.Options.RelativeLinks)
             {
-                return _options.Namespace;
+                return requestContext.Options.Namespace;
             }
 
-            var customRoute = GetCustomRoute(r.Path.Value, resourceName);
-            var toReturn = $"{r.Scheme}://{r.Host}/{_options.Namespace}";
+            var customRoute = GetCustomRoute(requestContext.Options, r.Path.Value, resourceName);
+            var toReturn = $"{r.Scheme}://{r.Host}/{requestContext.Options.Namespace}";
             if (customRoute != null)
             {
                 toReturn += $"/{customRoute}";
             }
             return toReturn;
         }
 
-        private object GetCustomRoute(string path, string resourceName)
+        private static object GetCustomRoute(IJsonApiOptions options, string path, string resourceName)
         {
             var trimmedComponents = path.Trim('/').Split('/').ToList();
             var resourceNameIndex = trimmedComponents.FindIndex(c => c == resourceName);
             var newComponents = trimmedComponents.Take(resourceNameIndex).ToArray();
             var customRoute = string.Join('/', newComponents);
-            if (customRoute == _options.Namespace)
+            if (customRoute == options.Namespace)
             {
                 return null;
             }
@@ -125,23 +119,23 @@ private object GetCustomRoute(string path, string resourceName)
             }
         }
 
-        private bool PathIsRelationship()
+        private static bool PathIsRelationship(RouteValueDictionary routeValues)
         {
-            var actionName = (string)_routeValues["action"];
+            var actionName = (string)routeValues["action"];
             return actionName.ToLowerInvariant().Contains("relationships");
         }
 
-        private async Task<bool> IsValidAsync()
+        private static async Task<bool> IsValidAsync(RequestContext requestContext)
         {
-            return await IsValidContentTypeHeaderAsync(_httpContext) && await IsValidAcceptHeaderAsync(_httpContext);
+            return await IsValidContentTypeHeaderAsync(requestContext) && await IsValidAcceptHeaderAsync(requestContext);
         }
 
-        private async Task<bool> IsValidContentTypeHeaderAsync(HttpContext context)
+        private static async Task<bool> IsValidContentTypeHeaderAsync(RequestContext requestContext)
         {
-            var contentType = context.Request.ContentType;
+            var contentType = requestContext.HttpContext.Request.ContentType;
             if (contentType != null && ContainsMediaTypeParameters(contentType))
             {
-                await FlushResponseAsync(context, new Error(HttpStatusCode.UnsupportedMediaType)
+                await FlushResponseAsync(requestContext, new Error(HttpStatusCode.UnsupportedMediaType)
                 {
                     Title = "The specified Content-Type header value is not supported.",
                     Detail = $"Please specify '{HeaderConstants.ContentType}' for the Content-Type header value."
@@ -152,9 +146,9 @@ private async Task<bool> IsValidContentTypeHeaderAsync(HttpContext context)
             return true;
         }
 
-        private async Task<bool> IsValidAcceptHeaderAsync(HttpContext context)
+        private static async Task<bool> IsValidAcceptHeaderAsync(RequestContext requestContext)
         {
-            if (context.Request.Headers.TryGetValue(HeaderConstants.AcceptHeader, out StringValues acceptHeaders) == false)
+            if (requestContext.HttpContext.Request.Headers.TryGetValue(HeaderConstants.AcceptHeader, out StringValues acceptHeaders) == false)
                 return true;
 
             foreach (var acceptHeader in acceptHeaders)
@@ -164,7 +158,7 @@ private async Task<bool> IsValidAcceptHeaderAsync(HttpContext context)
                     continue;
                 }
 
-                await FlushResponseAsync(context, new Error(HttpStatusCode.NotAcceptable)
+                await FlushResponseAsync(requestContext, new Error(HttpStatusCode.NotAcceptable)
                 {
                     Title = "The specified Accept header value is not supported.",
                     Detail = $"Please specify '{HeaderConstants.ContentType}' for the Accept header value."
@@ -195,11 +189,11 @@ private static bool ContainsMediaTypeParameters(string mediaType)
             );
         }
 
-        private async Task FlushResponseAsync(HttpContext context, Error error)
+        private static async Task FlushResponseAsync(RequestContext requestContext, Error error)
         {
-            context.Response.StatusCode = (int) error.StatusCode;
+            requestContext.HttpContext.Response.StatusCode = (int) error.StatusCode;
 
-            JsonSerializer serializer = JsonSerializer.CreateDefault(_options.SerializerSettings);
+            JsonSerializer serializer = JsonSerializer.CreateDefault(requestContext.Options.SerializerSettings);
             serializer.ApplyErrorSettings();
 
             // https://github.com/JamesNK/Newtonsoft.Json/issues/1193
@@ -212,34 +206,59 @@ private async Task FlushResponseAsync(HttpContext context, Error error)
                 }
 
                 stream.Seek(0, SeekOrigin.Begin);
-                await stream.CopyToAsync(context.Response.Body);
+                await stream.CopyToAsync(requestContext.HttpContext.Response.Body);
             }
 
-            context.Response.Body.Flush();
+            requestContext.HttpContext.Response.Body.Flush();
         }
 
         /// <summary>
         /// Gets the current entity that we need for serialization and deserialization.
         /// </summary>
         /// <returns></returns>
-        private ResourceContext GetCurrentEntity()
+        private static ResourceContext GetCurrentEntity(RequestContext requestContext)
         {
-            var controllerName = (string)_routeValues["controller"];
+            var controllerName = (string)requestContext.RouteValues["controller"];
             if (controllerName == null)
             {
                 return null;
             }
-            var resourceType = _controllerResourceMapping.GetAssociatedResource(controllerName);
-            var requestResource = _resourceGraph.GetResourceContext(resourceType);
+            var resourceType = requestContext.ControllerResourceMapping.GetAssociatedResource(controllerName);
+            var requestResource = requestContext.ResourceGraph.GetResourceContext(resourceType);
             if (requestResource == null)
             {
                 return null;
             }
-            if (_routeValues.TryGetValue("relationshipName", out object relationshipName))
+            if (requestContext.RouteValues.TryGetValue("relationshipName", out object relationshipName))
             {
-                _currentRequest.RequestRelationship = requestResource.Relationships.SingleOrDefault(r => r.PublicRelationshipName == (string)relationshipName);
+                requestContext.CurrentRequest.RequestRelationship = requestResource.Relationships.SingleOrDefault(r => r.PublicRelationshipName == (string)relationshipName);
             }
             return requestResource;
         }
+
+        private sealed class RequestContext
+        {
+            public HttpContext HttpContext { get; }
+            public ICurrentRequest CurrentRequest { get; }
+            public IResourceGraph ResourceGraph { get; }
+            public IJsonApiOptions Options { get; }
+            public RouteValueDictionary RouteValues { get; }
+            public IControllerResourceMapping ControllerResourceMapping { get; }
+
+            public RequestContext(HttpContext httpContext, 
+                ICurrentRequest currentRequest, 
+                IResourceGraph resourceGraph,
+                IJsonApiOptions options, 
+                RouteValueDictionary routeValues,
+                IControllerResourceMapping controllerResourceMapping)
+            {
+                HttpContext = httpContext;
+                CurrentRequest = currentRequest;
+                ResourceGraph = resourceGraph;
+                Options = options;
+                RouteValues = routeValues;
+                ControllerResourceMapping = controllerResourceMapping;
+            }
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,9 @@ public void ConfigureServices(IServiceCollection services)`
`22`	`22`
`23`	`23`	`public void Configure(IApplicationBuilder app, SampleDbContext context)`
`24`	`24`	`{`
`25`		`- context.Database.EnsureDeleted(); // indices need to be reset`
	`25`	`+ // indices need to be reset`
	`26`	`+ context.Database.EnsureDeleted();`
	`27`	`+ context.Database.EnsureCreated();`
`26`	`28`	`app.UseJsonApi();`
`27`	`29`	`}`
`28`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,100 +22,94 @@ namespace JsonApiDotNetCore.Middleware`
`22`	`22`	`public sealed class CurrentRequestMiddleware`
`23`	`23`	`{`
`24`	`24`	`private readonly RequestDelegate _next;`
`25`		`- private HttpContext _httpContext;`
`26`		`- private ICurrentRequest _currentRequest;`
`27`		`- private IResourceGraph _resourceGraph;`
`28`		`- private IJsonApiOptions _options;`
`29`		`- private RouteValueDictionary _routeValues;`
`30`		`- private IControllerResourceMapping _controllerResourceMapping;`
`31`	`25`
`32`	`26`	`public CurrentRequestMiddleware(RequestDelegate next)`
`33`	`27`	`{`
`34`	`28`	`_next = next;`
`35`	`29`	`}`
`36`	`30`
`37`	`31`	`public async Task Invoke(HttpContext httpContext,`
`38`		`- IControllerResourceMapping controllerResourceMapping,`
`39`		`- IJsonApiOptions options,`
`40`		`- ICurrentRequest currentRequest,`
`41`		`- IResourceGraph resourceGraph)`
	`32`	`+ IControllerResourceMapping controllerResourceMapping,`
	`33`	`+ IJsonApiOptions options,`
	`34`	`+ ICurrentRequest currentRequest,`
	`35`	`+ IResourceGraph resourceGraph)`
`42`	`36`	`{`
`43`		`- _httpContext = httpContext;`
`44`		`- _currentRequest = currentRequest;`
`45`		`- _controllerResourceMapping = controllerResourceMapping;`
`46`		`- _resourceGraph = resourceGraph;`
`47`		`- _options = options;`
`48`		`- _routeValues = httpContext.GetRouteData().Values;`
`49`		`- var requestResource = GetCurrentEntity();`
	`37`	`+ var routeValues = httpContext.GetRouteData().Values;`
	`38`	`+ var requestContext = new RequestContext(httpContext, currentRequest, resourceGraph, options, routeValues,`
	`39`	`+ controllerResourceMapping);`
	`40`	`+`
	`41`	`+ var requestResource = GetCurrentEntity(requestContext);`
`50`	`42`	`if (requestResource != null)`
`51`	`43`	`{`
`52`		`- _currentRequest.SetRequestResource(requestResource);`
`53`		`- _currentRequest.IsRelationshipPath = PathIsRelationship();`
`54`		`- _currentRequest.BasePath = GetBasePath(requestResource.ResourceName);`
`55`		`- _currentRequest.BaseId = GetBaseId();`
`56`		`- _currentRequest.RelationshipId = GetRelationshipId();`
	`44`	`+ requestContext.CurrentRequest.SetRequestResource(requestResource);`
	`45`	`+ requestContext.CurrentRequest.IsRelationshipPath = PathIsRelationship(requestContext.RouteValues);`
	`46`	`+ requestContext.CurrentRequest.BasePath = GetBasePath(requestContext, requestResource.ResourceName);`
	`47`	`+ requestContext.CurrentRequest.BaseId = GetBaseId(requestContext.RouteValues);`
	`48`	`+ requestContext.CurrentRequest.RelationshipId = GetRelationshipId(requestContext);`
`57`	`49`	`}`
`58`	`50`
`59`		`- if (await IsValidAsync())`
	`51`	`+ if (await IsValidAsync(requestContext))`
`60`	`52`	`{`
`61`		`- await _next(httpContext);`
	`53`	`+ await _next(requestContext.HttpContext);`
`62`	`54`	`}`
`63`	`55`	`}`
`64`	`56`
`65`		`- private string GetBaseId()`
	`57`	`+ private static string GetBaseId(RouteValueDictionary routeValues)`
`66`	`58`	`{`
`67`		`- if (_routeValues.TryGetValue("id", out object stringId))`
	`59`	`+ if (routeValues.TryGetValue("id", out object stringId))`
`68`	`60`	`{`
`69`	`61`	`return (string)stringId;`
`70`	`62`	`}`
`71`	`63`
`72`	`64`	`return null;`
`73`	`65`	`}`
`74`		`- private string GetRelationshipId()`
	`66`	`+`
	`67`	`+ private static string GetRelationshipId(RequestContext requestContext)`
`75`	`68`	`{`
`76`		`- if (!_currentRequest.IsRelationshipPath)`
	`69`	`+ if (!requestContext.CurrentRequest.IsRelationshipPath)`
`77`	`70`	`{`
`78`	`71`	`return null;`
`79`	`72`	`}`
`80`		`- var components = SplitCurrentPath();`
	`73`	`+ var components = SplitCurrentPath(requestContext);`
`81`	`74`	`var toReturn = components.ElementAtOrDefault(4);`
`82`	`75`
`83`	`76`	`return toReturn;`
`84`	`77`	`}`
`85`		`- private string[] SplitCurrentPath()`
	`78`	`+`
	`79`	`+ private static string[] SplitCurrentPath(RequestContext requestContext)`
`86`	`80`	`{`
`87`		`- var path = _httpContext.Request.Path.Value;`
`88`		`- var ns = $"/{_options.Namespace}";`
	`81`	`+ var path = requestContext.HttpContext.Request.Path.Value;`
	`82`	`+ var ns = $"/{requestContext.Options.Namespace}";`
`89`	`83`	`var nonNameSpaced = path.Replace(ns, "");`
`90`	`84`	`nonNameSpaced = nonNameSpaced.Trim('/');`
`91`	`85`	`var individualComponents = nonNameSpaced.Split('/');`
`92`	`86`	`return individualComponents;`
`93`	`87`	`}`
`94`	`88`
`95`		`- private string GetBasePath(string resourceName = null)`
	`89`	`+ private static string GetBasePath(RequestContext requestContext, string resourceName = null)`
`96`	`90`	`{`
`97`		`- var r = _httpContext.Request;`
`98`		`- if (_options.RelativeLinks)`
	`91`	`+ var r = requestContext.HttpContext.Request;`
	`92`	`+ if (requestContext.Options.RelativeLinks)`
`99`	`93`	`{`
`100`		`- return _options.Namespace;`
	`94`	`+ return requestContext.Options.Namespace;`
`101`	`95`	`}`
`102`	`96`
`103`		`- var customRoute = GetCustomRoute(r.Path.Value, resourceName);`
`104`		`- var toReturn = $"{r.Scheme}://{r.Host}/{_options.Namespace}";`
	`97`	`+ var customRoute = GetCustomRoute(requestContext.Options, r.Path.Value, resourceName);`
	`98`	`+ var toReturn = $"{r.Scheme}://{r.Host}/{requestContext.Options.Namespace}";`
`105`	`99`	`if (customRoute != null)`
`106`	`100`	`{`
`107`	`101`	`toReturn += $"/{customRoute}";`
`108`	`102`	`}`
`109`	`103`	`return toReturn;`
`110`	`104`	`}`
`111`	`105`
`112`		`- private object GetCustomRoute(string path, string resourceName)`
	`106`	`+ private static object GetCustomRoute(IJsonApiOptions options, string path, string resourceName)`
`113`	`107`	`{`
`114`	`108`	`var trimmedComponents = path.Trim('/').Split('/').ToList();`
`115`	`109`	`var resourceNameIndex = trimmedComponents.FindIndex(c => c == resourceName);`
`116`	`110`	`var newComponents = trimmedComponents.Take(resourceNameIndex).ToArray();`
`117`	`111`	`var customRoute = string.Join('/', newComponents);`
`118`		`- if (customRoute == _options.Namespace)`
	`112`	`+ if (customRoute == options.Namespace)`
`119`	`113`	`{`
`120`	`114`	`return null;`
`121`	`115`	`}`
`@@ -125,23 +119,23 @@ private object GetCustomRoute(string path, string resourceName)`
`125`	`119`	`}`
`126`	`120`	`}`
`127`	`121`
`128`		`- private bool PathIsRelationship()`
	`122`	`+ private static bool PathIsRelationship(RouteValueDictionary routeValues)`
`129`	`123`	`{`
`130`		`- var actionName = (string)_routeValues["action"];`
	`124`	`+ var actionName = (string)routeValues["action"];`
`131`	`125`	`return actionName.ToLowerInvariant().Contains("relationships");`
`132`	`126`	`}`
`133`	`127`
`134`		`- private async Task<bool> IsValidAsync()`
	`128`	`+ private static async Task<bool> IsValidAsync(RequestContext requestContext)`
`135`	`129`	`{`
`136`		`- return await IsValidContentTypeHeaderAsync(_httpContext) && await IsValidAcceptHeaderAsync(_httpContext);`
	`130`	`+ return await IsValidContentTypeHeaderAsync(requestContext) && await IsValidAcceptHeaderAsync(requestContext);`
`137`	`131`	`}`
`138`	`132`
`139`		`- private async Task<bool> IsValidContentTypeHeaderAsync(HttpContext context)`
	`133`	`+ private static async Task<bool> IsValidContentTypeHeaderAsync(RequestContext requestContext)`
`140`	`134`	`{`
`141`		`- var contentType = context.Request.ContentType;`
	`135`	`+ var contentType = requestContext.HttpContext.Request.ContentType;`
`142`	`136`	`if (contentType != null && ContainsMediaTypeParameters(contentType))`
`143`	`137`	`{`
`144`		`- await FlushResponseAsync(context, new Error(HttpStatusCode.UnsupportedMediaType)`
	`138`	`+ await FlushResponseAsync(requestContext, new Error(HttpStatusCode.UnsupportedMediaType)`
`145`	`139`	`{`
`146`	`140`	`Title = "The specified Content-Type header value is not supported.",`
`147`	`141`	`Detail = $"Please specify '{HeaderConstants.ContentType}' for the Content-Type header value."`
`@@ -152,9 +146,9 @@ private async Task<bool> IsValidContentTypeHeaderAsync(HttpContext context)`
`152`	`146`	`return true;`
`153`	`147`	`}`
`154`	`148`
`155`		`- private async Task<bool> IsValidAcceptHeaderAsync(HttpContext context)`
	`149`	`+ private static async Task<bool> IsValidAcceptHeaderAsync(RequestContext requestContext)`
`156`	`150`	`{`
`157`		`- if (context.Request.Headers.TryGetValue(HeaderConstants.AcceptHeader, out StringValues acceptHeaders) == false)`
	`151`	`+ if (requestContext.HttpContext.Request.Headers.TryGetValue(HeaderConstants.AcceptHeader, out StringValues acceptHeaders) == false)`
`158`	`152`	`return true;`
`159`	`153`
`160`	`154`	`foreach (var acceptHeader in acceptHeaders)`
`@@ -164,7 +158,7 @@ private async Task<bool> IsValidAcceptHeaderAsync(HttpContext context)`
`164`	`158`	`continue;`
`165`	`159`	`}`
`166`	`160`
`167`		`- await FlushResponseAsync(context, new Error(HttpStatusCode.NotAcceptable)`
	`161`	`+ await FlushResponseAsync(requestContext, new Error(HttpStatusCode.NotAcceptable)`
`168`	`162`	`{`
`169`	`163`	`Title = "The specified Accept header value is not supported.",`
`170`	`164`	`Detail = $"Please specify '{HeaderConstants.ContentType}' for the Accept header value."`
`@@ -195,11 +189,11 @@ private static bool ContainsMediaTypeParameters(string mediaType)`
`195`	`189`	`);`
`196`	`190`	`}`
`197`	`191`
`198`		`- private async Task FlushResponseAsync(HttpContext context, Error error)`
	`192`	`+ private static async Task FlushResponseAsync(RequestContext requestContext, Error error)`
`199`	`193`	`{`
`200`		`- context.Response.StatusCode = (int) error.StatusCode;`
	`194`	`+ requestContext.HttpContext.Response.StatusCode = (int) error.StatusCode;`
`201`	`195`
`202`		`- JsonSerializer serializer = JsonSerializer.CreateDefault(_options.SerializerSettings);`
	`196`	`+ JsonSerializer serializer = JsonSerializer.CreateDefault(requestContext.Options.SerializerSettings);`
`203`	`197`	`serializer.ApplyErrorSettings();`
`204`	`198`
`205`	`199`	`// https://github.com/JamesNK/Newtonsoft.Json/issues/1193`
`@@ -212,34 +206,59 @@ private async Task FlushResponseAsync(HttpContext context, Error error)`
`212`	`206`	`}`
`213`	`207`
`214`	`208`	`stream.Seek(0, SeekOrigin.Begin);`
`215`		`- await stream.CopyToAsync(context.Response.Body);`
	`209`	`+ await stream.CopyToAsync(requestContext.HttpContext.Response.Body);`
`216`	`210`	`}`
`217`	`211`
`218`		`- context.Response.Body.Flush();`
	`212`	`+ requestContext.HttpContext.Response.Body.Flush();`
`219`	`213`	`}`
`220`	`214`
`221`	`215`	`/// <summary>`
`222`	`216`	`/// Gets the current entity that we need for serialization and deserialization.`
`223`	`217`	`/// </summary>`
`224`	`218`	`/// <returns></returns>`
`225`		`- private ResourceContext GetCurrentEntity()`
	`219`	`+ private static ResourceContext GetCurrentEntity(RequestContext requestContext)`
`226`	`220`	`{`
`227`		`- var controllerName = (string)_routeValues["controller"];`
	`221`	`+ var controllerName = (string)requestContext.RouteValues["controller"];`
`228`	`222`	`if (controllerName == null)`
`229`	`223`	`{`
`230`	`224`	`return null;`
`231`	`225`	`}`
`232`		`- var resourceType = _controllerResourceMapping.GetAssociatedResource(controllerName);`
`233`		`- var requestResource = _resourceGraph.GetResourceContext(resourceType);`
	`226`	`+ var resourceType = requestContext.ControllerResourceMapping.GetAssociatedResource(controllerName);`
	`227`	`+ var requestResource = requestContext.ResourceGraph.GetResourceContext(resourceType);`
`234`	`228`	`if (requestResource == null)`
`235`	`229`	`{`
`236`	`230`	`return null;`
`237`	`231`	`}`
`238`		`- if (_routeValues.TryGetValue("relationshipName", out object relationshipName))`
	`232`	`+ if (requestContext.RouteValues.TryGetValue("relationshipName", out object relationshipName))`
`239`	`233`	`{`
`240`		`- _currentRequest.RequestRelationship = requestResource.Relationships.SingleOrDefault(r => r.PublicRelationshipName == (string)relationshipName);`
	`234`	`+ requestContext.CurrentRequest.RequestRelationship = requestResource.Relationships.SingleOrDefault(r => r.PublicRelationshipName == (string)relationshipName);`
`241`	`235`	`}`
`242`	`236`	`return requestResource;`
`243`	`237`	`}`
	`238`	`+`
	`239`	`+ private sealed class RequestContext`
	`240`	`+ {`
	`241`	`+ public HttpContext HttpContext { get; }`
	`242`	`+ public ICurrentRequest CurrentRequest { get; }`
	`243`	`+ public IResourceGraph ResourceGraph { get; }`
	`244`	`+ public IJsonApiOptions Options { get; }`
	`245`	`+ public RouteValueDictionary RouteValues { get; }`
	`246`	`+ public IControllerResourceMapping ControllerResourceMapping { get; }`
	`247`	`+`
	`248`	`+ public RequestContext(HttpContext httpContext,`
	`249`	`+ ICurrentRequest currentRequest,`
	`250`	`+ IResourceGraph resourceGraph,`
	`251`	`+ IJsonApiOptions options,`
	`252`	`+ RouteValueDictionary routeValues,`
	`253`	`+ IControllerResourceMapping controllerResourceMapping)`
	`254`	`+ {`
	`255`	`+ HttpContext = httpContext;`
	`256`	`+ CurrentRequest = currentRequest;`
	`257`	`+ ResourceGraph = resourceGraph;`
	`258`	`+ Options = options;`
	`259`	`+ RouteValues = routeValues;`
	`260`	`+ ControllerResourceMapping = controllerResourceMapping;`
	`261`	`+ }`
	`262`	`+ }`
`244`	`263`	`}`
`245`	`264`	`}`