Merge pull request #197 from graphql-dotnet/fix-numeric-deserializetion-in-extensions

Fix numeric deserializetion in extensions

Author: rose-a

src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs renamed to src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs

@@ -1,49 +1,41 @@
 using System;
 using System.Collections.Generic;
+using System.Runtime.InteropServices;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace GraphQL.Client.Serializer.Newtonsoft
 {
-    public class GraphQLExtensionsConverter : JsonConverter<GraphQLExtensionsType>
+    public class MapConverter : JsonConverter<Map>
     {
-        public override void WriteJson(JsonWriter writer, GraphQLExtensionsType value, JsonSerializer serializer) =>
+        public override void WriteJson(JsonWriter writer, Map value, JsonSerializer serializer) =>
             throw new NotImplementedException(
                 "This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
 
-        public override GraphQLExtensionsType ReadJson(JsonReader reader, Type objectType, GraphQLExtensionsType existingValue,
+        public override Map ReadJson(JsonReader reader, Type objectType, Map existingValue,
             bool hasExistingValue, JsonSerializer serializer)
         {
             var rootToken = JToken.ReadFrom(reader);
             if (rootToken is JObject)
             {
-                return ReadDictionary<GraphQLExtensionsType>(rootToken);
+                return ReadDictionary<Map>(rootToken);
             }
             else
                 throw new ArgumentException("This converter can only parse when the root element is a JSON Object.");
         }
 
         private object ReadToken(JToken? token) =>
-            token.Type switch
+            token switch
             {
-                JTokenType.Undefined => null,
-                JTokenType.None => null,
-                JTokenType.Null => null,
-                JTokenType.Object => ReadDictionary<Dictionary<string, object>>(token),
-                JTokenType.Array => ReadArray(token),
-                JTokenType.Integer => token.Value<int>(),
-                JTokenType.Float => token.Value<double>(),
-                JTokenType.Raw => token.Value<string>(),
-                JTokenType.String => token.Value<string>(),
-                JTokenType.Uri => token.Value<string>(),
-                JTokenType.Boolean => token.Value<bool>(),
-                JTokenType.Date => token.Value<DateTime>(),
-                JTokenType.Bytes => token.Value<byte[]>(),
-                JTokenType.Guid => token.Value<Guid>(),
-                JTokenType.TimeSpan => token.Value<TimeSpan>(),
-                JTokenType.Constructor => throw new ArgumentOutOfRangeException(nameof(token.Type), "cannot deserialize a JSON constructor"),
-                JTokenType.Property => throw new ArgumentOutOfRangeException(nameof(token.Type), "cannot deserialize a JSON property"),
-                JTokenType.Comment => throw new ArgumentOutOfRangeException(nameof(token.Type), "cannot deserialize a JSON comment"),
+                JObject jObject => ReadDictionary<Dictionary<string, object>>(jObject),
+                JArray jArray => ReadArray(jArray),
+                JValue jValue => jValue.Value,
+                JConstructor _ => throw new ArgumentOutOfRangeException(nameof(token.Type),
+                    "cannot deserialize a JSON constructor"),
+                JProperty _ => throw new ArgumentOutOfRangeException(nameof(token.Type),
+                    "cannot deserialize a JSON property"),
+                JContainer _ => throw new ArgumentOutOfRangeException(nameof(token.Type),
+                    "cannot deserialize a JSON comment"),
                 _ => throw new ArgumentOutOfRangeException(nameof(token.Type))
             };
 
@@ -69,6 +61,8 @@ private IEnumerable<object> ReadArray(JToken element)
             }
         }
 
+        private object ReadNumber(JToken token) => ((JValue) token).Value;
+
         private bool IsUnsupportedJTokenType(JTokenType type) => type == JTokenType.Constructor || type == JTokenType.Property || type == JTokenType.Comment;
     }
 }

src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs

@@ -31,7 +31,7 @@ public NewtonsoftJsonSerializer(JsonSerializerSettings jsonSerializerSettings)
         }
 
         // deserialize extensions to Dictionary<string, object>
-        private void ConfigureMandatorySerializerOptions() => JsonSerializerSettings.Converters.Insert(0, new GraphQLExtensionsConverter());
+        private void ConfigureMandatorySerializerOptions() => JsonSerializerSettings.Converters.Insert(0, new MapConverter());
 
         public string SerializeToString(GraphQLRequest request) => JsonConvert.SerializeObject(request, JsonSerializerSettings);
 

src/GraphQL.Client.Serializer.SystemTextJson/GraphQLExtensionsConverter.cs renamed to src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs

@@ -13,9 +13,9 @@ namespace GraphQL.Client.Serializer.SystemTextJson
     /// <remarks>
     /// Taken and modified from GraphQL.SystemTextJson.ObjectDictionaryConverter (GraphQL.NET)
     /// </remarks>
-    public class GraphQLExtensionsConverter : JsonConverter<GraphQLExtensionsType>
+    public class MapConverter : JsonConverter<Map>
     {
-        public override GraphQLExtensionsType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        public override Map Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
             using var doc = JsonDocument.ParseValue(ref reader);
 
@@ -24,10 +24,10 @@ public override GraphQLExtensionsType Read(ref Utf8JsonReader reader, Type typeT
                 throw new ArgumentException("This converter can only parse when the root element is a JSON Object.");
             }
 
-            return ReadDictionary<GraphQLExtensionsType>(doc.RootElement);
+            return ReadDictionary<Map>(doc.RootElement);
         }
 
-        public override void Write(Utf8JsonWriter writer, GraphQLExtensionsType value, JsonSerializerOptions options)
+        public override void Write(Utf8JsonWriter writer, Map value, JsonSerializerOptions options)
             => throw new NotImplementedException(
                 "This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
 

src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs

@@ -30,7 +30,7 @@ public SystemTextJsonSerializer(JsonSerializerOptions options)
         private void ConfigureMandatorySerializerOptions()
         {
             // deserialize extensions to Dictionary<string, object>
-            Options.Converters.Insert(0, new GraphQLExtensionsConverter());
+            Options.Converters.Insert(0, new MapConverter());
             // allow the JSON field "data" to match the property "Data" even without JsonNamingPolicy.CamelCase
             Options.PropertyNameCaseInsensitive = true;
         }

src/GraphQL.Primitives/GraphQLError.cs

@@ -34,7 +34,7 @@ public class GraphQLError : IEquatable<GraphQLError?>
         /// The extensions of the error
         /// </summary> 
         [DataMember(Name = "extensions")]
-        public GraphQLExtensionsType? Extensions { get; set; }
+        public Map? Extensions { get; set; }
 
         /// <summary>
         /// Returns a value that indicates whether this instance is equal to a specified object

src/GraphQL.Primitives/GraphQLExtensionsType.cs

@@ -16,7 +16,7 @@ public class GraphQLResponse<T> : IEquatable<GraphQLResponse<T>?>
         public GraphQLError[]? Errors { get; set; }
 
         [DataMember(Name = "extensions")]
-        public GraphQLExtensionsType? Extensions { get; set; }
+        public Map? Extensions { get; set; }
 
         public override bool Equals(object? obj) => Equals(obj as GraphQLResponse<T>);
 

src/GraphQL.Primitives/GraphQLResponse.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace GraphQL
+{
+
+    /// <summary>
+    /// A type equivalent to a javascript map. Create a custom json converter for this class to customize your serializers behaviour
+    /// </summary>
+    public class Map : Dictionary<string, object> { }
+}

src/GraphQL.Primitives/Map.cs

@@ -18,13 +18,13 @@ public IEnumerator<object[]> GetEnumerator()
                     Errors = new[] {
                         new GraphQLError {
                             Message = "Throttled",
-                            Extensions = new GraphQLExtensionsType {
+                            Extensions = new Map {
                                 {"code", "THROTTLED" },
                                 {"documentation", "https://help.shopify.com/api/graphql-admin-api/graphql-admin-api-rate-limits" }
                             }
                         }
                     },
-                    Extensions = new GraphQLExtensionsType {
+                    Extensions = new Map {
                         {"cost", new Dictionary<string, object> {
                             {"requestedQueryCost", 992},
                             {"actualQueryCost", null},

tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs

@@ -10,7 +10,8 @@ public class ChatQuery : ObjectGraphType
 
         public static readonly Dictionary<string, object> TestExtensions = new Dictionary<string, object> {
             {"extension1", "hello world"},
-            {"another extension", 4711}
+            {"another extension", 4711},
+            {"long", 19942590700}
         };
 
         // properties for unit testing