refactor: express both Link parsing and the parameter check as the queries they are

CodeQL flagged two loops that filter their sequence implicitly (cs/linq/missed-where,
alerts 293 and 294). Both are mine: 294 is this PR's parameter check, and 293 is the
Link-header loop on master — #264 cleared cs/linq/missed-select there and CodeQL
immediately raised missed-where on the same loop, so the guard-on-the-way-in shape
traded one alert for another rather than fixing the cause.

Splitting the parse of a single RFC 8288 link-value into its own method leaves
ParseLinkHeaderNext reading as what it actually is — the first rel="next" target, if
any — and removes the whole class of finding instead of moving it. The parameter check
becomes the FirstOrDefault it always was; a default KeyValuePair has a null Key, which
is precisely the "no complex parameter" answer.

Behaviour is unchanged: Http 60/60, AspNetCore 159/159.

The explanatory comment moved from between `=>` and the expression into the XML doc —
dotnet format rejects a comment in that position, and it belongs with the rest of the
method's documentation anyway.

Author: thiagoluga

src/Integrations/NeoReports.AspNetCore/NeoReportsEndpointRouteBuilderExtensions.cs

@@ -1299,22 +1299,18 @@ private static IResult SchemaProblem(HttpContext http, Exception ex, string sour
     /// they are left alone here.
     /// </para>
     /// </summary>
+    /// <para>
+    /// <see cref="PrimitiveObjectConverter"/> turns every scalar into a CLR primitive and leaves
+    /// exactly the structured values as a <see cref="JsonElement"/>, so the value-kind check below is
+    /// the whole test. <c>FirstOrDefault</c> over a <see cref="KeyValuePair{TKey,TValue}"/> yields a
+    /// default pair — <c>Key</c> null — when nothing matches, which is the "no complex parameter"
+    /// answer.
+    /// </para>
     /// <param name="parameters">The normalized parameter bag.</param>
-    private static string? FirstComplexParameter(IReadOnlyDictionary<string, object?>? parameters)
-    {
-        if (parameters is null)
-            return null;
-
-        foreach (KeyValuePair<string, object?> pair in parameters)
-        {
-            // PrimitiveObjectConverter turns every scalar into a CLR primitive and leaves exactly the
-            // structured values as a JsonElement, so this is the whole test.
-            if (pair.Value is JsonElement { ValueKind: JsonValueKind.Array or JsonValueKind.Object })
-                return pair.Key;
-        }
-
-        return null;
-    }
+    private static string? FirstComplexParameter(IReadOnlyDictionary<string, object?>? parameters) =>
+        parameters?
+            .FirstOrDefault(pair => pair.Value is JsonElement { ValueKind: JsonValueKind.Array or JsonValueKind.Object })
+            .Key;
 
     private static IReadOnlyDictionary<string, object?>? NormalizeJsonValues(
         IReadOnlyDictionary<string, object?>? parameters)

src/Sources/NeoReports.Sources.Http/HttpBatchSource.cs

@@ -207,35 +207,39 @@ private static IEnumerable<string> SplitLinkValues(string headerValue)
         if (!response.Headers.TryGetValues("Link", out IEnumerable<string>? values))
             return null;
 
-        foreach (string headerValue in values)
+        // Parsing one link-value is a separate concern from picking the one we want, so it lives in
+        // its own method and this reads as what it is: the first rel="next" target, if any.
+        return values
+            .SelectMany(SplitLinkValues)
+            .Select(ParseLinkValue)
+            .FirstOrDefault(parsed => parsed.IsNext)
+            .Target;
+    }
+
+    /// <summary>
+    /// Parses one RFC 8288 link-value into its target URI and whether it is the <c>next</c> relation.
+    /// A value that does not match the grammar yields <c>(null, false)</c> rather than throwing —
+    /// a <c>Link</c> header may legitimately carry relations this source does not understand.
+    /// </summary>
+    private static (string? Target, bool IsNext) ParseLinkValue(string link)
+    {
+        string[] parts = link.Split(';');
+        if (parts.Length < 2)
+            return (null, false);
+
+        string urlPart = parts[0].Trim();
+        if (urlPart.Length < 2 || urlPart[0] != '<' || urlPart[^1] != '>')
+            return (null, false);
+
+        bool isNext = parts.Skip(1).Any(p =>
         {
-            foreach (string link in SplitLinkValues(headerValue))
-            {
-                // Guarded on the way in rather than assigned then checked: a bare `var parts =
-                // link.Split(...)` as the loop's first statement reads to CodeQL as a map that should
-                // have been a .Select, which this loop cannot be — it has two guards and an early
-                // return (alert cs/linq/missed-select, opened by the Link-parsing fix in #262).
-                if (link.Split(';') is not { Length: >= 2 } parts)
-                    continue;
-
-                string urlPart = parts[0].Trim();
-                if (urlPart.Length < 2 || urlPart[0] != '<' || urlPart[^1] != '>')
-                    continue;
-
-                bool isNext = parts.Skip(1).Any(p =>
-                {
-                    string[] kv = p.Trim().Split('=', 2);
-                    return kv.Length == 2
-                        && kv[0].Trim().Equals("rel", StringComparison.OrdinalIgnoreCase)
-                        && kv[1].Trim().Trim('"').Equals("next", StringComparison.OrdinalIgnoreCase);
-                });
-
-                if (isNext)
-                    return urlPart[1..^1];
-            }
-        }
+            string[] kv = p.Trim().Split('=', 2);
+            return kv.Length == 2
+                && kv[0].Trim().Equals("rel", StringComparison.OrdinalIgnoreCase)
+                && kv[1].Trim().Trim('"').Equals("next", StringComparison.OrdinalIgnoreCase);
+        });
 
-        return null;
+        return (urlPart[1..^1], isNext);
     }
 
     private BatchResult<T> BuildCursorResult(List<T> records, JsonElement responseRoot, HttpCursorState state)