Formatted changed files

Author: xperiandri

samples/star-wars-fabulous-client/StarWars/Common.fs

@@ -9,6 +9,6 @@ module Commands =
     let IntrospectionPath = "../../../tests/FSharp.Data.GraphQL.IntegrationTests/introspection.json"
 
     type GraphQLApi = GraphQLProvider<IntrospectionPath>
-    let GetCharactersData = GraphQLApi.Operation<"queries/FetchCharacters.graphql">()
+    let GetCharactersData = GraphQLApi.Operation<"queries/FetchCharacters.graphql"> ()
 
     type Character = GraphQLApi.Operations.FetchCharacters.Types.CharactersFields.Character

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

@@ -344,7 +344,12 @@ let ``Should generate information map correctly`` () =
                          Name = "friends"
                          Alias = ValueNone
                          Fields = [
-                             FragmentField { Name = "primaryFunction"; Alias = ValueNone; TypeCondition = "Droid"; Fields = [] }
+                             FragmentField {
+                                 Name = "primaryFunction"
+                                 Alias = ValueNone
+                                 TypeCondition = "Droid"
+                                 Fields = []
+                             }
                              FragmentField { Name = "id"; Alias = ValueNone; TypeCondition = "Droid"; Fields = [] }
                              FragmentField { Name = "homePlanet"; Alias = ValueNone; TypeCondition = "Human"; Fields = [] }
                              FragmentField { Name = "id"; Alias = ValueNone; TypeCondition = "Human"; Fields = [] }
@@ -362,118 +367,118 @@ let ``Should generate information map correctly`` () =
 let ``ToQueryString escapes double quotes in string values`` () =
     let query = """query q { hero(name: "test\"quote") }"""
     let document = parse query
-    let printed = document.ToQueryString()
+    let printed = document.ToQueryString ()
     // Verify the printed query contains the escaped quote
-    Assert.Contains("\\\"", printed)
+    Assert.Contains ("\\\"", printed)
     // Verify it can be parsed back
     let reparsed = parse printed
-    equals (document.ToQueryString()) (reparsed.ToQueryString())
+    equals (document.ToQueryString ()) (reparsed.ToQueryString ())
 
 [<Fact>]
 let ``ToQueryString escapes backslashes in string values`` () =
     let query = """query q { hero(path: "C:\\Users\\test") }"""
     let document = parse query
-    let printed = document.ToQueryString()
+    let printed = document.ToQueryString ()
     // Verify the printed query contains escaped backslashes
-    Assert.Contains("\\\\", printed)
+    Assert.Contains ("\\\\", printed)
     // Verify it can be parsed back
     let reparsed = parse printed
-    equals (document.ToQueryString()) (reparsed.ToQueryString())
+    equals (document.ToQueryString ()) (reparsed.ToQueryString ())
 
 [<Fact>]
 let ``ToQueryString escapes newlines in string values`` () =
     let query = """query q { hero(text: "line1\nline2") }"""
     let document = parse query
-    let printed = document.ToQueryString()
+    let printed = document.ToQueryString ()
     // Verify the printed query contains the escaped newline within the string value
-    Assert.Contains("\\n", printed)
+    Assert.Contains ("\\n", printed)
     // Verify the string value itself doesn't contain an actual newline (it should be escaped)
     // The printed output will have formatting newlines, but the string value should have \n
-    Assert.Contains("\"line1\\nline2\"", printed)
+    Assert.Contains ("\"line1\\nline2\"", printed)
     // Verify it can be parsed back
     let reparsed = parse printed
-    equals (document.ToQueryString()) (reparsed.ToQueryString())
+    equals (document.ToQueryString ()) (reparsed.ToQueryString ())
 
 [<Fact>]
 let ``ToQueryString escapes tabs in string values`` () =
     let query = """query q { hero(text: "col1\tcol2") }"""
     let document = parse query
-    let printed = document.ToQueryString()
+    let printed = document.ToQueryString ()
     // Verify the printed query contains the escaped tab within the string value
-    Assert.Contains("\\t", printed)
-    Assert.Contains("\"col1\\tcol2\"", printed)
+    Assert.Contains ("\\t", printed)
+    Assert.Contains ("\"col1\\tcol2\"", printed)
     // Verify it can be parsed back
     let reparsed = parse printed
-    equals (document.ToQueryString()) (reparsed.ToQueryString())
+    equals (document.ToQueryString ()) (reparsed.ToQueryString ())
 
 [<Fact>]
 let ``ToQueryString escapes carriage returns in string values`` () =
     let query = """query q { hero(text: "line1\rline2") }"""
     let document = parse query
-    let printed = document.ToQueryString()
+    let printed = document.ToQueryString ()
     // Verify the printed query contains the escaped carriage return
-    Assert.Contains("\\r", printed)
+    Assert.Contains ("\\r", printed)
     // Verify it can be parsed back
     let reparsed = parse printed
-    equals (document.ToQueryString()) (reparsed.ToQueryString())
+    equals (document.ToQueryString ()) (reparsed.ToQueryString ())
 
 [<Fact>]
 let ``ToQueryString escapes backspace in string values`` () =
     let query = """query q { hero(text: "test\bback") }"""
     let document = parse query
-    let printed = document.ToQueryString()
+    let printed = document.ToQueryString ()
     // Verify the printed query contains the escaped backspace
-    Assert.Contains("\\b", printed)
+    Assert.Contains ("\\b", printed)
     // Verify it can be parsed back
     let reparsed = parse printed
-    equals (document.ToQueryString()) (reparsed.ToQueryString())
+    equals (document.ToQueryString ()) (reparsed.ToQueryString ())
 
 [<Fact>]
 let ``ToQueryString escapes form feed in string values`` () =
     let query = """query q { hero(text: "page1\fpage2") }"""
     let document = parse query
-    let printed = document.ToQueryString()
+    let printed = document.ToQueryString ()
     // Verify the printed query contains the escaped form feed
-    Assert.Contains("\\f", printed)
+    Assert.Contains ("\\f", printed)
     // Verify it can be parsed back
     let reparsed = parse printed
-    equals (document.ToQueryString()) (reparsed.ToQueryString())
+    equals (document.ToQueryString ()) (reparsed.ToQueryString ())
 
 [<Fact>]
 let ``ToQueryString escapes control characters as unicode in string values`` () =
     // Test with a control character (e.g., ASCII 0x01)
     let query = "query q { hero(text: \"test\u0001control\") }"
     let document = parse query
-    let printed = document.ToQueryString()
+    let printed = document.ToQueryString ()
     // Verify the printed query contains the unicode escape (lowercase hex)
-    Assert.Contains("\\u0001", printed)
+    Assert.Contains ("\\u0001", printed)
     // Verify it can be parsed back
     let reparsed = parse printed
-    equals (document.ToQueryString()) (reparsed.ToQueryString())
+    equals (document.ToQueryString ()) (reparsed.ToQueryString ())
 
 [<Fact>]
 let ``ToQueryString escapes multiple special characters correctly`` () =
     let query = """query q { hero(text: "quote:\"newline:\nslash:\\tab:\t") }"""
     let document = parse query
-    let printed = document.ToQueryString()
+    let printed = document.ToQueryString ()
     // Verify all escapes are present
-    Assert.Contains("\\\"", printed)
-    Assert.Contains("\\n", printed)
-    Assert.Contains("\\\\", printed)
-    Assert.Contains("\\t", printed)
+    Assert.Contains ("\\\"", printed)
+    Assert.Contains ("\\n", printed)
+    Assert.Contains ("\\\\", printed)
+    Assert.Contains ("\\t", printed)
     // Verify it can be parsed back
     let reparsed = parse printed
-    equals (document.ToQueryString()) (reparsed.ToQueryString())
+    equals (document.ToQueryString ()) (reparsed.ToQueryString ())
 
 [<Fact>]
 let ``ToQueryString produces deterministic output for escaped strings`` () =
     // This test verifies that the same query with escaped strings produces
     // the same canonical output, which is critical for documentId stability
     let query = """query Test { field(arg: "test\"quote\nline\ttab\\back") }"""
     let document = parse query
-    let printed1 = document.ToQueryString()
-    let printed2 = document.ToQueryString()
+    let printed1 = document.ToQueryString ()
+    let printed2 = document.ToQueryString ()
     equals printed1 printed2
     // Verify the documentId is deterministic
     let documentId = DocumentId.fromCanonicalQuery printed1
-    equals 64 documentId.Length  // SHA-256 hex string is always 64 chars
+    equals 64 documentId.Length // SHA-256 hex string is always 64 chars

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

@@ -12,7 +12,7 @@ let ``DocumentId.fromCanonicalQuery produces deterministic hash`` () =
     let hash1 = DocumentId.fromCanonicalQuery query
     let hash2 = DocumentId.fromCanonicalQuery query
     equals hash1 hash2
-    equals 64 hash1.Length  // SHA-256 hex string is 64 chars
+    equals 64 hash1.Length // SHA-256 hex string is 64 chars
 
 [<Fact>]
 let ``DocumentId.fromCanonicalQuery produces different hashes for different queries`` () =
@@ -34,8 +34,11 @@ let ``DocumentId.fromCanonicalQuery handles empty string`` () =
 let ``DocumentId.fromCanonicalQuery produces lowercase hex`` () =
     let query = "query Test { field }"
     let hash = DocumentId.fromCanonicalQuery query
-    equals hash (hash.ToLowerInvariant())
-    Assert.True(hash |> Seq.forall (fun c -> (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f')))
+    equals hash (hash.ToLowerInvariant ())
+    Assert.True (
+        hash
+        |> Seq.forall (fun c -> (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f'))
+    )
 
 [<Fact>]
 let ``DocumentId.fromCanonicalQuery handles special characters in strings`` () =
@@ -62,4 +65,3 @@ let ``DocumentId.fromCanonicalQuery is consistent with known SHA-256 values`` ()
     let hash = DocumentId.fromCanonicalQuery query
     // SHA-256 of "test"
     equals "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08" hash
-

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

@@ -19,23 +19,23 @@ open FSharp.Data.GraphQL.Parser
 open FSharp.Data.GraphQL.Execution
 
 type TestSubject = {
-    a: string
-    b: string
-    c: string
-    d: string
-    e: string
-    f: string
-    deep: DeepTestSubject
-    pic: int voption -> string
-    promise: Async<TestSubject>
+    a : string
+    b : string
+    c : string
+    d : string
+    e : string
+    f : string
+    deep : DeepTestSubject
+    pic : int voption -> string
+    promise : Async<TestSubject>
 }
 
 and DeepTestSubject = {
-    a: string
-    b: string
-    c: string option
-    d: string voption
-    l: string option list
+    a : string
+    b : string
+    c : string option
+    d : string voption
+    l : string option list
 }
 
 and DUArg =