Workaround for bug dotnet/roslyn#13624

Author: Bart Koelman

src/JsonApiDotNetCore/Middleware/FixedQueryFeature.cs

@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Features;
+using Microsoft.Extensions.Primitives;
+
+namespace JsonApiDotNetCore.Middleware
+{
+    /// <summary>
+    /// Replacement implementation for the ASP.NET built-in <see cref="QueryFeature" />, to workaround bug https://github.com/dotnet/aspnetcore/issues/33394.
+    /// This is identical to the built-in version, except it calls <see cref="FixedQueryHelpers.ParseNullableQuery" />.
+    /// </summary>
+    internal sealed class FixedQueryFeature : IQueryFeature
+    {
+        // Lambda hoisted to static readonly field to improve inlining https://github.com/dotnet/roslyn/issues/13624
+        private static readonly Func<IFeatureCollection, IHttpRequestFeature> NullRequestFeature = _ => null;
+
+        private FeatureReferences<IHttpRequestFeature> _features;
+
+        private string _original;
+        private IQueryCollection _parsedValues;
+
+        private IHttpRequestFeature HttpRequestFeature => _features.Fetch(ref _features.Cache, NullRequestFeature);
+
+        /// <inheritdoc />
+        public IQueryCollection Query
+        {
+            get
+            {
+                if (_features.Collection == null)
+                {
+                    if (_parsedValues == null)
+                    {
+                        _parsedValues = QueryCollection.Empty;
+                    }
+
+                    return _parsedValues;
+                }
+
+                string current = HttpRequestFeature.QueryString;
+
+                if (_parsedValues == null || !string.Equals(_original, current, StringComparison.Ordinal))
+                {
+                    _original = current;
+
+                    Dictionary<string, StringValues> result = FixedQueryHelpers.ParseNullableQuery(current);
+
+                    if (result == null)
+                    {
+                        _parsedValues = QueryCollection.Empty;
+                    }
+                    else
+                    {
+                        _parsedValues = new QueryCollection(result);
+                    }
+                }
+
+                return _parsedValues;
+            }
+            set
+            {
+                _parsedValues = value;
+
+                if (_features.Collection != null)
+                {
+                    if (value == null)
+                    {
+                        _original = string.Empty;
+                        HttpRequestFeature.QueryString = string.Empty;
+                    }
+                    else
+                    {
+                        _original = QueryString.Create(_parsedValues).ToString();
+                        HttpRequestFeature.QueryString = _original;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Initializes a new instance of <see cref="QueryFeature" />.
+        /// </summary>
+        /// <param name="features">
+        /// The <see cref="IFeatureCollection" /> to initialize.
+        /// </param>
+        public FixedQueryFeature(IFeatureCollection features)
+        {
+            ArgumentGuard.NotNull(features, nameof(features));
+
+            _features.Initalize(features);
+        }
+    }
+}

src/JsonApiDotNetCore/Middleware/FixedQueryHelpers.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.AspNetCore.WebUtilities;
+using Microsoft.Extensions.Primitives;
+
+#pragma warning disable AV1008 // Class should not be static
+#pragma warning disable AV1708 // Type name contains term that should be avoided
+#pragma warning disable AV1130 // Return type in method signature should be a collection interface instead of a concrete type
+#pragma warning disable AV1532 // Loop statement contains nested loop
+
+namespace JsonApiDotNetCore.Middleware
+{
+    /// <summary>
+    /// Replacement implementation for the ASP.NET built-in <see cref="QueryHelpers" />, to workaround bug https://github.com/dotnet/aspnetcore/issues/33394.
+    /// This is identical to the built-in version, except it properly un-escapes query string keys without a value.
+    /// </summary>
+    internal static class FixedQueryHelpers
+    {
+        /// <summary>
+        /// Parse a query string into its component key and value parts.
+        /// </summary>
+        /// <param name="queryString">
+        /// The raw query string value, with or without the leading '?'.
+        /// </param>
+        /// <returns>
+        /// A collection of parsed keys and values, null if there are no entries.
+        /// </returns>
+        public static Dictionary<string, StringValues> ParseNullableQuery(string queryString)
+        {
+            var accumulator = new KeyValueAccumulator();
+
+            if (string.IsNullOrEmpty(queryString) || queryString == "?")
+            {
+                return null;
+            }
+
+            int scanIndex = 0;
+
+            if (queryString[0] == '?')
+            {
+                scanIndex = 1;
+            }
+
+            int textLength = queryString.Length;
+            int equalIndex = queryString.IndexOf('=');
+
+            if (equalIndex == -1)
+            {
+                equalIndex = textLength;
+            }
+
+            while (scanIndex < textLength)
+            {
+                int delimiterIndex = queryString.IndexOf('&', scanIndex);
+
+                if (delimiterIndex == -1)
+                {
+                    delimiterIndex = textLength;
+                }
+
+                if (equalIndex < delimiterIndex)
+                {
+                    while (scanIndex != equalIndex && char.IsWhiteSpace(queryString[scanIndex]))
+                    {
+                        ++scanIndex;
+                    }
+
+                    string name = queryString.Substring(scanIndex, equalIndex - scanIndex);
+                    string value = queryString.Substring(equalIndex + 1, delimiterIndex - equalIndex - 1);
+                    accumulator.Append(Uri.UnescapeDataString(name.Replace('+', ' ')), Uri.UnescapeDataString(value.Replace('+', ' ')));
+                    equalIndex = queryString.IndexOf('=', delimiterIndex);
+
+                    if (equalIndex == -1)
+                    {
+                        equalIndex = textLength;
+                    }
+                }
+                else
+                {
+                    if (delimiterIndex > scanIndex)
+                    {
+                        // original code:
+                        // accumulator.Append(queryString.Substring(scanIndex, delimiterIndex - scanIndex), string.Empty);
+
+                        // replacement:
+                        string name = queryString.Substring(scanIndex, delimiterIndex - scanIndex);
+                        accumulator.Append(Uri.UnescapeDataString(name.Replace('+', ' ')), string.Empty);
+                    }
+                }
+
+                scanIndex = delimiterIndex + 1;
+            }
+
+            if (!accumulator.HasValues)
+            {
+                return null;
+            }
+
+            return accumulator.GetResults();
+        }
+    }
+}

src/JsonApiDotNetCore/Middleware/JsonApiMiddleware.cs

@@ -12,6 +12,7 @@
 using JsonApiDotNetCore.Serialization;
 using JsonApiDotNetCore.Serialization.Objects;
 using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Features;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Controllers;
 using Microsoft.AspNetCore.Routing;
@@ -78,6 +79,9 @@ public async Task InvokeAsync(HttpContext httpContext, IControllerResourceMappin
                 httpContext.RegisterJsonApiRequest();
             }
 
+            // Workaround for bug https://github.com/dotnet/aspnetcore/issues/33394
+            httpContext.Features.Set<IQueryFeature>(new FixedQueryFeature(httpContext.Features));
+
             await _next(httpContext);
         }