Improved query normalization

Author: xperiandri

src/FSharp.Data.GraphQL.Client.DesignTime/ProvidedTypesHelper.fs

@@ -799,7 +799,7 @@ module internal Provider =
                                     match validationResult with
                                     | ValidationError msgs -> failwith (formatValidationExceptionMessage msgs)
                                     | Success -> ()
-                                let key = { DocumentId = DocumentId.fromCanonicalQuery (queryAst.ToQueryString()); SchemaId = schema.GetHashCode() }
+                                let key = { DocumentId = DocumentId.fromCanonicalQueryUnsafe (queryAst.ToQueryString()); SchemaId = schema.GetHashCode() }
                                 let refMaker = lazy Validation.Ast.validateDocument schema queryAst
                                 if clientQueryValidation then
                                     refMaker.Force

src/FSharp.Data.GraphQL.Server/Executor.fs

@@ -142,7 +142,7 @@ type Executor<'Root>(schema: ISchema<'Root>, middlewares : IExecutorMiddleware s
         eval (executionPlan, data, variables, getInputContext)
 
     let createExecutionPlan (ast: Document, operationName: string option, meta : Metadata) =
-        let documentId = DocumentId.fromCanonicalQuery (ast.ToQueryString())
+        let documentId = DocumentId.fromCanonicalQueryUnsafe (ast.ToQueryString())
         result {
             match findOperation ast operationName with
             | Some operation ->

src/FSharp.Data.GraphQL.Shared/Helpers/DocumentId.fs

@@ -7,15 +7,38 @@ open System.Text
 
 let private formatByteAsLowerHex (value : byte) = value.ToString ("x2", CultureInfo.InvariantCulture)
 
+let internal fromCanonicalQueryUnsafe (canonicalQuery : string) =
+    let queryBytes = Encoding.UTF8.GetBytes canonicalQuery
+    use sha256 = SHA256.Create ()
+    let hash = sha256.ComputeHash queryBytes
+    hash |> Seq.map formatByteAsLowerHex |> String.concat ""
+
+
 /// <summary>
 /// Computes a deterministic document identifier from a canonical GraphQL query string.
 /// </summary>
 /// <param name="canonicalQuery">The canonical GraphQL query string (must already be properly escaped according to GraphQL specification).</param>
 /// <returns>A lowercase hexadecimal SHA-256 hash string that uniquely identifies the document content.</returns>
 [<CompiledName("FromCanonicalQuery")>]
 let fromCanonicalQuery (canonicalQuery : string) =
-    let normalizedCanonicalQuery = canonicalQuery.Replace("\r\n", "\n").Replace ("\r", "\n")
-    let queryBytes = Encoding.UTF8.GetBytes normalizedCanonicalQuery
-    use sha256 = SHA256.Create ()
-    let hash = sha256.ComputeHash queryBytes
-    hash |> Seq.map formatByteAsLowerHex |> String.concat ""
+    let normalizedCanonicalQuery =
+        let crIndex = canonicalQuery.IndexOf '\r'
+        if crIndex < 0 then
+            canonicalQuery
+        else
+            let sb = StringBuilder (canonicalQuery.Length)
+            sb.Append (canonicalQuery, 0, crIndex) |> ignore
+            let mutable i = crIndex
+            while i < canonicalQuery.Length do
+                let c = canonicalQuery[i]
+                if c = '\r' then
+                    sb.Append '\n' |> ignore
+                    if i + 1 < canonicalQuery.Length && canonicalQuery[i + 1] = '\n' then
+                        i <- i + 2
+                    else
+                        i <- i + 1
+                else
+                    sb.Append c |> ignore
+                    i <- i + 1
+            sb.ToString ()
+    fromCanonicalQueryUnsafe normalizedCanonicalQuery

tests/FSharp.Data.GraphQL.Tests/DocumentIdTests.fs

@@ -6,6 +6,30 @@ module FSharp.Data.GraphQL.Tests.DocumentIdTests
 open Xunit
 open FSharp.Data.GraphQL
 
+[<Fact>]
+let ``DocumentId.fromCanonicalQueryUnsafe produces deterministic hash`` () =
+    let query = "query Example { a b }"
+    let hash1 = DocumentId.fromCanonicalQueryUnsafe query
+    let hash2 = DocumentId.fromCanonicalQueryUnsafe query
+    equals hash1 hash2
+    equals 64 hash1.Length // SHA-256 hex string is 64 chars
+
+[<Fact>]
+let ``DocumentId.fromCanonicalQueryUnsafe produces different hashes for different queries`` () =
+    let query1 = "query Example1 { a }"
+    let query2 = "query Example2 { b }"
+    let hash1 = DocumentId.fromCanonicalQueryUnsafe query1
+    let hash2 = DocumentId.fromCanonicalQueryUnsafe query2
+    notEquals hash1 hash2
+
+[<Fact>]
+let ``DocumentId.fromCanonicalQueryUnsafe handles empty string`` () =
+    let query = ""
+    let hash = DocumentId.fromCanonicalQueryUnsafe query
+    equals 64 hash.Length
+    // SHA-256 of empty string
+    equals "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" hash
+
 [<Fact>]
 let ``DocumentId.fromCanonicalQuery produces deterministic hash`` () =
     let query = "query Example { a b }"