Optimized check for maximum include depth (single pass).

Author: Bart Koelman

src/JsonApiDotNetCore/Internal/Queries/Parsing/IncludeParser.cs

@@ -19,19 +19,19 @@ public IncludeParser(IResourceContextProvider resourceContextProvider,
             _validateSingleRelationshipCallback = validateSingleRelationshipCallback;
         }
 
-        public IncludeExpression Parse(string source, ResourceContext resourceContextInScope)
+        public IncludeExpression Parse(string source, ResourceContext resourceContextInScope, int? maximumDepth)
         {
             _resourceContextInScope = resourceContextInScope ?? throw new ArgumentNullException(nameof(resourceContextInScope));
             Tokenize(source);
 
-            var expression = ParseInclude();
+            var expression = ParseInclude(maximumDepth);
 
             AssertTokenStackIsEmpty();
 
             return expression;
         }
 
-        protected IncludeExpression ParseInclude()
+        protected IncludeExpression ParseInclude(int? maximumDepth)
         {
             ResourceFieldChainExpression firstChain =
                 ParseFieldChain(FieldChainRequirements.IsRelationship, "Relationship name expected.");
@@ -49,9 +49,26 @@ protected IncludeExpression ParseInclude()
                 chains.Add(nextChain);
             }
 
+            ValidateMaximumIncludeDepth(maximumDepth, chains);
+
             return IncludeChainConverter.FromRelationshipChains(chains);
         }
 
+        private static void ValidateMaximumIncludeDepth(int? maximumDepth, List<ResourceFieldChainExpression> chains)
+        {
+            if (maximumDepth != null)
+            {
+                foreach (var chain in chains)
+                {
+                    if (chain.Fields.Count > maximumDepth)
+                    {
+                        var path = string.Join('.', chain.Fields.Select(field => field.PublicName));
+                        throw new QueryParseException($"Including '{path}' exceeds the maximum inclusion depth of {maximumDepth}.");
+                    }
+                }
+            }
+        }
+
         protected override IReadOnlyCollection<ResourceFieldAttribute> OnResolveFieldChain(string path, FieldChainRequirements chainRequirements)
         {
             return ChainResolver.ResolveRelationshipChain(_resourceContextInScope, path, _validateSingleRelationshipCallback);

src/JsonApiDotNetCore/Internal/QueryStrings/IncludeQueryStringParameterReader.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using JsonApiDotNetCore.Configuration;
 using JsonApiDotNetCore.Controllers;
 using JsonApiDotNetCore.Exceptions;
@@ -75,31 +74,7 @@ public void Read(string parameterName, StringValues parameterValue)
 
         private IncludeExpression GetInclude(string parameterValue)
         {
-            IncludeExpression include = _includeParser.Parse(parameterValue, RequestResource);
-
-            ValidateMaximumIncludeDepth(include);
-
-            return include;
-        }
-
-        private void ValidateMaximumIncludeDepth(IncludeExpression include)
-        {
-            if (_options.MaximumIncludeDepth != null)
-            {
-                var chains = IncludeChainConverter.GetRelationshipChains(include);
-
-                foreach (var chain in chains)
-                {
-                    if (chain.Fields.Count > _options.MaximumIncludeDepth)
-                    {
-                        var path = string.Join('.', chain.Fields.Select(field => field.PublicName));
-
-                        throw new InvalidQueryStringParameterException(_lastParameterName,
-                            "Including at the requested depth is not allowed.",
-                            $"Including '{path}' exceeds the maximum inclusion depth of {_options.MaximumIncludeDepth}.");
-                    }
-                }
-            }
+            return _includeParser.Parse(parameterValue, RequestResource, _options.MaximumIncludeDepth);
         }
 
         public IReadOnlyCollection<ExpressionInScope> GetConstraints()

test/JsonApiDotNetCoreExampleTests/IntegrationTests/Includes/IncludeTests.cs

@@ -833,7 +833,7 @@ public async Task Cannot_exceed_configured_maximum_inclusion_depth()
 
             responseDocument.Errors.Should().HaveCount(1);
             responseDocument.Errors[0].StatusCode.Should().Be(HttpStatusCode.BadRequest);
-            responseDocument.Errors[0].Title.Should().Be("Including at the requested depth is not allowed.");
+            responseDocument.Errors[0].Title.Should().Be("The specified include is invalid.");
             responseDocument.Errors[0].Detail.Should().Be("Including 'articles.revisions' exceeds the maximum inclusion depth of 1.");
             responseDocument.Errors[0].Source.Parameter.Should().Be("include");
         }