Properly handle parsing of large request documents

src/HotChocolate/Language/src/Language.Web/DocumentHashProviderBase.cs

@@ -39,10 +39,42 @@ public OperationDocumentHash ComputeHash(ReadOnlySpan<byte> document)
 #endif
     }
 
+    public OperationDocumentHash ComputeHash(ReadOnlySequence<byte> document)
+    {
+        if (document.IsSingleSegment)
+        {
+#if NETSTANDARD2_0
+            return ComputeHash(document.First.Span);
+#else
+            return ComputeHash(document.FirstSpan);
+#endif
+        }
+
+#if NETSTANDARD2_0
+        var length = checked((int)document.Length);
+        var rented = ArrayPool<byte>.Shared.Rent(length);
+
+        try
+        {
+            document.CopyTo(rented);
+            return ComputeHash(rented.AsSpan(0, length));
+        }
+        finally
+        {
+            ArrayPool<byte>.Shared.Return(rented);
+        }
+#else
+        var hash = ComputeHash(document, Format);
+        return new OperationDocumentHash(hash, Name, Format);
+#endif
+    }
+
 #if NETSTANDARD2_0
     protected abstract byte[] ComputeHash(byte[] document, int length);
 #else
     protected abstract string ComputeHash(ReadOnlySpan<byte> document, HashFormat format);
+
+    protected abstract string ComputeHash(ReadOnlySequence<byte> document, HashFormat format);
 #endif
 
     protected static string FormatHash(ReadOnlySpan<byte> hash, HashFormat format)

src/HotChocolate/Language/src/Language.Web/IDocumentHashProvider.cs

@@ -1,3 +1,5 @@
+using System.Buffers;
+
 namespace HotChocolate.Language;
 
 /// <summary>
@@ -21,4 +23,11 @@ public interface IDocumentHashProvider
     /// <param name="document">The GraphQL operation document.</param>
     /// <returns>The hash of the GraphQL operation document.</returns>
     OperationDocumentHash ComputeHash(ReadOnlySpan<byte> document);
+
+    /// <summary>
+    /// Computes the hash of a GraphQL operation document.
+    /// </summary>
+    /// <param name="document">The GraphQL operation document.</param>
+    /// <returns>The hash of the GraphQL operation document.</returns>
+    OperationDocumentHash ComputeHash(ReadOnlySequence<byte> document);
 }

src/HotChocolate/Language/src/Language.Web/MD5DocumentHashProvider.cs

@@ -1,4 +1,5 @@
 #if NET8_0_OR_GREATER
+using System.Buffers;
 using System.Runtime.CompilerServices;
 #endif
 using System.Security.Cryptography;
@@ -38,5 +39,26 @@ protected override string ComputeHash(ReadOnlySpan<byte> document, HashFormat fo
 
         return FormatHash(hashSpan, format);
     }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    protected override string ComputeHash(ReadOnlySequence<byte> document, HashFormat format)
+    {
+        using var incrementalHash = IncrementalHash.CreateHash(HashAlgorithmName.MD5);
+
+        foreach (var segment in document)
+        {
+            incrementalHash.AppendData(segment.Span);
+        }
+
+        Span<byte> hashBytes = stackalloc byte[16];
+        incrementalHash.TryGetHashAndReset(hashBytes, out var written);
+
+        if (written < 16)
+        {
+            hashBytes = hashBytes[..written];
+        }
+
+        return FormatHash(hashBytes, format);
+    }
 #endif
 }

src/HotChocolate/Language/src/Language.Web/Sha1DocumentHashProvider.cs

@@ -1,4 +1,5 @@
 #if NET8_0_OR_GREATER
+using System.Buffers;
 using System.Runtime.CompilerServices;
 #endif
 using System.Security.Cryptography;
@@ -40,5 +41,26 @@ protected override string ComputeHash(ReadOnlySpan<byte> document, HashFormat fo
 
         return FormatHash(hashSpan, format);
     }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    protected override string ComputeHash(ReadOnlySequence<byte> document, HashFormat format)
+    {
+        using var incrementalHash = IncrementalHash.CreateHash(HashAlgorithmName.SHA1);
+
+        foreach (var segment in document)
+        {
+            incrementalHash.AppendData(segment.Span);
+        }
+
+        Span<byte> hashBytes = stackalloc byte[20];
+        incrementalHash.TryGetHashAndReset(hashBytes, out var written);
+
+        if (written < 20)
+        {
+            hashBytes = hashBytes[..written];
+        }
+
+        return FormatHash(hashBytes, format);
+    }
 #endif
 }

src/HotChocolate/Language/src/Language.Web/Sha256DocumentHashProvider.cs

@@ -1,4 +1,5 @@
 #if NET8_0_OR_GREATER
+using System.Buffers;
 using System.Runtime.CompilerServices;
 #endif
 using System.Security.Cryptography;
@@ -42,5 +43,26 @@ protected override string ComputeHash(ReadOnlySpan<byte> document, HashFormat fo
 
         return FormatHash(hashSpan, format);
     }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    protected override string ComputeHash(ReadOnlySequence<byte> document, HashFormat format)
+    {
+        using var incrementalHash = IncrementalHash.CreateHash(HashAlgorithmName.SHA256);
+
+        foreach (var segment in document)
+        {
+            incrementalHash.AppendData(segment.Span);
+        }
+
+        Span<byte> hashBytes = stackalloc byte[32];
+        incrementalHash.TryGetHashAndReset(hashBytes, out var written);
+
+        if (written < 32)
+        {
+            hashBytes = hashBytes[..written];
+        }
+
+        return FormatHash(hashBytes, format);
+    }
 #endif
 }

src/HotChocolate/Language/src/Language.Web/Utf8GraphQLRequestParser.cs

@@ -166,7 +166,8 @@ private readonly GraphQLRequest ParseRequest(ref Utf8JsonReader reader, Operatio
         ErrorHandlingMode? errorHandlingMode = null;
         JsonDocument? variables = null;
         JsonDocument? extensions = null;
-        ReadOnlySpan<byte> documentBody = default;
+        ReadOnlySequence<byte> documentSequence = default;
+        ReadOnlySpan<byte> documentSpan = default;
         var isDocumentEscaped = false;
 
         while (reader.Read() && reader.TokenType != JsonTokenType.EndObject)
@@ -183,7 +184,15 @@ private readonly GraphQLRequest ParseRequest(ref Utf8JsonReader reader, Operatio
                 if (reader.TokenType == JsonTokenType.String)
                 {
                     isDocumentEscaped = reader.ValueIsEscaped;
-                    documentBody = reader.ValueSpan;
+
+                    if (reader.HasValueSequence)
+                    {
+                        documentSequence = reader.ValueSequence;
+                    }
+                    else
+                    {
+                        documentSpan = reader.ValueSpan;
+                    }
                 }
                 else if (reader.TokenType == JsonTokenType.Null)
                 {
@@ -312,7 +321,7 @@ private readonly GraphQLRequest ParseRequest(ref Utf8JsonReader reader, Operatio
         }
 
         // Handle persisted queries via extensions
-        if (documentBody.IsEmpty
+        if (documentSpan.IsEmpty
             && documentId.IsEmpty
             && _useCache
             && extensions is not null
@@ -323,10 +332,19 @@ private readonly GraphQLRequest ParseRequest(ref Utf8JsonReader reader, Operatio
         }
 
         // Parse the GraphQL document if provided
-        if (!documentBody.IsEmpty)
+        if (!documentSpan.IsEmpty)
         {
             ParseDocument(
-                documentBody,
+                documentSpan,
+                isDocumentEscaped,
+                ref document,
+                ref documentHash,
+                ref documentId);
+        }
+        else if (!documentSequence.IsEmpty)
+        {
+            ParseDocument(
+                documentSequence,
                 isDocumentEscaped,
                 ref document,
                 ref documentHash,
@@ -406,6 +424,62 @@ private readonly void ParseDocument(
         }
     }
 
+    private readonly void ParseDocument(
+        ReadOnlySequence<byte> documentBody,
+        bool isEscaped,
+        ref DocumentNode? document,
+        ref OperationDocumentHash documentHash,
+        ref OperationDocumentId documentId)
+    {
+        // When we need to unescape, escape sequences can span segment boundaries,
+        // so we must work with contiguous memory. Delegate to the span-based overload
+        // which already handles unescaping.
+        if (isEscaped)
+        {
+            var length = checked((int)documentBody.Length);
+            var rented = s_bytePool.Rent(length);
+
+            try
+            {
+                documentBody.CopyTo(rented);
+                ParseDocument(rented.AsSpan(0, length), isEscaped, ref document, ref documentHash, ref documentId);
+            }
+            finally
+            {
+                s_bytePool.Return(rented);
+            }
+
+            return;
+        }
+
+        if (_useCache)
+        {
+            if (documentId.HasValue && _cache!.TryGetDocument(documentId.Value, out var cachedDocument))
+            {
+                document = cachedDocument.Body;
+                documentHash = cachedDocument.Hash;
+            }
+            else if (documentBody.Length > 0)
+            {
+                var hash = _hashProvider!.ComputeHash(documentBody);
+                documentHash = hash;
+
+                document = _cache!.TryGetDocument(hash.Value, out cachedDocument)
+                    ? cachedDocument.Body
+                    : Utf8GraphQLParser.Parse(documentBody, _options);
+
+                if (documentId.IsEmpty)
+                {
+                    documentId = new OperationDocumentId(hash.Value);
+                }
+            }
+        }
+        else
+        {
+            document = Utf8GraphQLParser.Parse(documentBody, _options);
+        }
+    }
+
     private readonly bool TryExtractHash(JsonDocument? extensions, out string hash)
         => TryExtractHashInternal(extensions, _hashProvider, out hash);
 

src/HotChocolate/Language/test/Language.Web.Tests/MD5DocumentHashProviderTests.cs

@@ -1,3 +1,5 @@
+using System.Buffers;
+
 namespace HotChocolate.Language;
 
 public class MD5DocumentHashProviderTests
@@ -29,4 +31,60 @@ public void HashAsHex()
             .Add(hash.Value)
             .MatchInline("900150983cd24fb0d6963f7d28e17f72");
     }
+
+    [Fact]
+    public void HashSequenceSingleSegmentAsBase64()
+    {
+        var content = new ReadOnlySequence<byte>("abc"u8.ToArray());
+        var hashProvider = new MD5DocumentHashProvider(HashFormat.Base64);
+
+        var hash = hashProvider.ComputeHash(content);
+
+        Snapshot
+            .Create()
+            .Add(hash.Value)
+            .MatchInline("kAFQmDzST7DWlj99KOF_cg");
+    }
+
+    [Fact]
+    public void HashSequenceMultiSegmentAsBase64()
+    {
+        var content = SequenceHelper.CreateMultiSegment("abc"u8.ToArray());
+        var hashProvider = new MD5DocumentHashProvider(HashFormat.Base64);
+
+        var hash = hashProvider.ComputeHash(content);
+
+        Snapshot
+            .Create()
+            .Add(hash.Value)
+            .MatchInline("kAFQmDzST7DWlj99KOF_cg");
+    }
+
+    [Fact]
+    public void HashSequenceSingleSegmentAsHex()
+    {
+        var content = new ReadOnlySequence<byte>("abc"u8.ToArray());
+        var hashProvider = new MD5DocumentHashProvider(HashFormat.Hex);
+
+        var hash = hashProvider.ComputeHash(content);
+
+        Snapshot
+            .Create()
+            .Add(hash.Value)
+            .MatchInline("900150983cd24fb0d6963f7d28e17f72");
+    }
+
+    [Fact]
+    public void HashSequenceMultiSegmentAsHex()
+    {
+        var content = SequenceHelper.CreateMultiSegment("abc"u8.ToArray());
+        var hashProvider = new MD5DocumentHashProvider(HashFormat.Hex);
+
+        var hash = hashProvider.ComputeHash(content);
+
+        Snapshot
+            .Create()
+            .Add(hash.Value)
+            .MatchInline("900150983cd24fb0d6963f7d28e17f72");
+    }
 }

src/HotChocolate/Language/test/Language.Web.Tests/SequenceHelper.cs

@@ -0,0 +1,38 @@
+using System.Buffers;
+
+namespace HotChocolate.Language;
+
+internal static class SequenceHelper
+{
+    public static ReadOnlySequence<byte> CreateMultiSegment(byte[] data)
+    {
+        if (data.Length < 2)
+        {
+            return new ReadOnlySequence<byte>(data);
+        }
+
+        var mid = data.Length / 2;
+        var first = new MemorySegment(data.AsMemory(0, mid));
+        var last = first.Append(data.AsMemory(mid));
+
+        return new ReadOnlySequence<byte>(first, 0, last, last.Memory.Length);
+    }
+
+    private sealed class MemorySegment : ReadOnlySequenceSegment<byte>
+    {
+        public MemorySegment(ReadOnlyMemory<byte> memory)
+        {
+            Memory = memory;
+        }
+
+        public MemorySegment Append(ReadOnlyMemory<byte> memory)
+        {
+            var segment = new MemorySegment(memory)
+            {
+                RunningIndex = RunningIndex + Memory.Length
+            };
+            Next = segment;
+            return segment;
+        }
+    }
+}