Make SchemaId deterministic using SHA-256 hash of introspection schema JSON

Agent-Logs-Url: https://github.com/fsprojects/FSharp.Data.GraphQL/sessions/ce0fba11-9043-452f-b948-e03c8b644f26

Co-authored-by: xperiandri <2365592+xperiandri@users.noreply.github.com>

Author: Copilot

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.fromCanonicalQuery (queryAst.ToQueryString()); SchemaId = SchemaId.fromIntrospectionSchema schema }
                                 let refMaker = lazy Validation.Ast.validateDocument schema queryAst
                                 if clientQueryValidation then
                                     refMaker.Force

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

@@ -161,7 +161,7 @@ type Executor<'Root>(schema: ISchema<'Root>, middlewares : IExecutorMiddleware s
                             ErrorKind.Validation
                         )]
                 do!
-                    let schemaId = schema.Introspected.GetHashCode()
+                    let schemaId = SchemaId.fromIntrospectionSchema schema.Introspected
                     let key = { DocumentId = documentId; SchemaId = schemaId }
                     let producer = fun () -> Validation.Ast.validateDocument schema.Introspected ast
                     validationCache.GetOrAdd producer key

src/FSharp.Data.GraphQL.Shared/AstExtensions.fs

@@ -104,7 +104,22 @@ type Document with
     /// <param name="options">Specify custom printing voptions for the query string.</param>
     member x.ToQueryString ([<Optional; DefaultParameterValue (QueryStringPrintingOptions.None)>] options : QueryStringPrintingOptions) =
         let sb = PaddedStringBuilder ()
-        let withQuotes (s : string) = "\"" + s + "\""
+        let escapeGraphQLString (s : string) =
+            let escaped = StringBuilder(s.Length + 2)
+            escaped.Append('"') |> ignore
+            for c in s do
+                match c with
+                | '"' -> escaped.Append("\\\"") |> ignore
+                | '\\' -> escaped.Append("\\\\") |> ignore
+                | '\b' -> escaped.Append("\\b") |> ignore
+                | '\f' -> escaped.Append("\\f") |> ignore
+                | '\n' -> escaped.Append("\\n") |> ignore
+                | '\r' -> escaped.Append("\\r") |> ignore
+                | '\t' -> escaped.Append("\\t") |> ignore
+                | c when c < '\u0020' -> escaped.AppendFormat("\\u{0:x4}", int c) |> ignore
+                | c -> escaped.Append(c) |> ignore
+            escaped.Append('"').ToString()
+        let withQuotes = escapeGraphQLString
         let rec printValue x =
             let printObjectValue (name, value) =
                 sb.Append (name)

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

@@ -1,12 +1,19 @@
 module FSharp.Data.GraphQL.DocumentId
 
 open System.Globalization
+open System.Runtime.CompilerServices
 open System.Security.Cryptography
 open System.Text
 
 let private formatByteAsLowerHex (value : byte) =
     value.ToString("x2", CultureInfo.InvariantCulture)
 
+/// <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 queryBytes = Encoding.UTF8.GetBytes canonicalQuery
     use sha256 = SHA256.Create()

src/FSharp.Data.GraphQL.Shared/ValidationResultCache.fs

@@ -1,18 +1,42 @@
 namespace FSharp.Data.GraphQL.Validation
 
 open FSharp.Data.GraphQL
+open FSharp.Data.GraphQL.Types.Introspection
 open System
+open System.Security.Cryptography
+open System.Text
+open System.Text.Json
 
 type ValidationResultKey =
     { DocumentId : string
-      SchemaId : int }
+      SchemaId : string }
 
 type ValidationResultProducer =
     unit -> ValidationResult<GQLProblemDetails>
 
 type IValidationResultCache =
     abstract GetOrAdd : ValidationResultProducer -> ValidationResultKey -> ValidationResult<GQLProblemDetails>
 
+module SchemaId =
+    let private formatByteAsLowerHex (value : byte) =
+        value.ToString("x2", System.Globalization.CultureInfo.InvariantCulture)
+    
+    /// <summary>
+    /// Computes a deterministic schema identifier from an introspection schema.
+    /// </summary>
+    /// <param name="introspectionSchema">The introspection schema to hash.</param>
+    /// <returns>A lowercase hexadecimal SHA-256 hash string that uniquely identifies the schema structure.</returns>
+    let fromIntrospectionSchema (introspectionSchema : IntrospectionSchema) =
+        let options = JsonSerializerOptions()
+        options.WriteIndented <- false
+        options.DefaultIgnoreCondition <- System.Text.Json.Serialization.JsonIgnoreCondition.Never
+        let json = JsonSerializer.Serialize(introspectionSchema, options)
+        let jsonBytes = Encoding.UTF8.GetBytes json
+        use sha256 = SHA256.Create()
+        let hash = sha256.ComputeHash jsonBytes
+        hash
+        |> Seq.map formatByteAsLowerHex
+        |> String.concat ""
 
 /// An in-memory cache for the results of schema/document validations, with a lifetime of 30 seconds.
 type MemoryValidationResultCache () =