Reworked the dictionary serializer to allow for a more flexible AnyType. (#6367)

Author: michaelstaib

.github/workflows/codeql-analysis.yml

@@ -49,9 +49,14 @@ jobs:
         # By default, queries listed here will override any specified in a config file.
         # Prefix the list here with "+" to use these queries and those in the config file.
         # queries: ./path/to/local/query, your-org/your-repo/queries@main
-        
+
     - name: Setup .NET Core SDK
-      uses: actions/setup-dotnet@v1.9.0
+      uses: actions/setup-dotnet@v3
+      with:
+        dotnet-version: |
+          6.x
+          7.x
+          8.x
 
     - name: Build
       run: |

src/HotChocolate/Core/src/Types/Utilities/ObjectToDictionaryConverter.cs

@@ -1,39 +1,35 @@
+using System.Linq;
 using System;
 using System.Collections;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Dynamic;
 using System.Reflection;
 
 namespace HotChocolate.Utilities;
 
-internal class ObjectToDictionaryConverter
+internal class ObjectToDictionaryConverter(ITypeConverter converter)
 {
-    private readonly ITypeConverter _converter;
-    private readonly ConcurrentDictionary<Type, List<PropertyInfo>> _properties = new();
-
-    public ObjectToDictionaryConverter(ITypeConverter converter)
-    {
-        _converter = converter
-            ?? throw new ArgumentNullException(nameof(converter));
-    }
+    private readonly ITypeConverter _converter = converter ?? throw new ArgumentNullException(nameof(converter));
+    private readonly ConcurrentDictionary<Type, PropertyInfo[]> _properties = new();
 
     public object Convert(object obj)
     {
-        if (obj is null)
+        if(obj is null)
         {
             throw new ArgumentNullException(nameof(obj));
         }
 
         object value = null;
-        Action<object> setValue = v => value = v;
-        VisitValue(obj, setValue, new HashSet<object>());
+        void SetValue(object v) => value = v;
+        VisitValue(obj, SetValue, new HashSet<object>());
         return value;
     }
 
     private void VisitValue(
         object obj,
         Action<object> setValue,
-        ISet<object> processed)
+        HashSet<object> processed)
     {
         if (obj is null)
         {
@@ -81,19 +77,56 @@ private void VisitValue(
     private void VisitObject(
         object obj,
         Action<object> setValue,
-        ISet<object> processed)
+        HashSet<object> processed)
     {
         if (processed.Add(obj))
         {
-            var dict = new Dictionary<string, object>();
-            setValue(dict);
+            var current = new Dictionary<string, object>();
+            setValue(current);
 
-            if (obj is IReadOnlyDictionary<string, object> d)
+            if (obj is Dictionary<string, object> dict1)
+            {
+                foreach (var item in dict1)
+                {
+                    void SetField(object v) => current[item.Key] = v;
+                    VisitValue(item.Value, SetField, processed);
+                }
+            }
+            else if (obj is IDictionary<string, object> dict2)
+            {
+                foreach (var item in dict2)
+                {
+                    void SetField(object v) => current[item.Key] = v;
+                    VisitValue(item.Value, SetField, processed);
+                }
+            }
+            else if (obj is IReadOnlyDictionary<string, object> dict3)
             {
-                foreach (var item in d)
+                foreach (var item in dict3)
                 {
-                    Action<object> setField = v => dict[item.Key] = v;
-                    VisitValue(item.Value, setField, processed);
+                    void SetField(object v) => current[item.Key] = v;
+                    VisitValue(item.Value, SetField, processed);
+                }
+            }
+            else if (obj is IDictionary dict4)
+            {
+                foreach (var item in dict4)
+                {
+                    if (item is DictionaryEntry entry)
+                    {
+                        void SetField(object v) => current[entry.Key.ToString()!] = v;
+                        VisitValue(entry.Value, SetField, processed);
+                    }
+                    else if (item is KeyValuePair<string, object> pair)
+                    {
+                        void SetField(object v) => current[pair.Key] = v;
+                        VisitValue(pair.Value, SetField, processed);
+                    }
+                    else
+                    {
+                        throw new NotSupportedException(
+                            $"The dictionary entry type `{item.GetType().FullName}` is not supported.");
+                    }
                 }
             }
             else
@@ -102,8 +135,8 @@ private void VisitObject(
                 {
                     var name = property.GetGraphQLName();
                     var value = property.GetValue(obj);
-                    Action<object> setField = v => dict[name] = v;
-                    VisitValue(value, setField, processed);
+                    void SetField(object v) => current[name] = v;
+                    VisitValue(value, SetField, processed);
                 }
             }
         }
@@ -112,28 +145,29 @@ private void VisitObject(
     private void VisitList(
         ICollection list,
         Action<object> setValue,
-        ISet<object> processed)
+        HashSet<object> processed)
     {
         var valueList = new List<object>();
         setValue(valueList);
 
-        Action<object> addItem = item => valueList.Add(item);
+        void AddItem(object item) => valueList.Add(item);
 
         foreach (var element in list)
         {
-            VisitValue(element, addItem, processed);
+            VisitValue(element, AddItem, processed);
         }
     }
 
-    private IReadOnlyList<PropertyInfo> GetProperties(object value)
+    private ReadOnlySpan<PropertyInfo> GetProperties(object value)
     {
         var type = value.GetType();
+
         if (!_properties.TryGetValue(type, out var properties))
         {
-            properties = new List<PropertyInfo>(
-                ReflectionUtils.GetProperties(type).Values);
+            properties = ReflectionUtils.GetProperties(type).Values.ToArray();
             _properties.TryAdd(type, properties);
         }
+
         return properties;
     }
 }

src/HotChocolate/Core/test/Types.Tests/Types/Scalars/AnyTypeTests.cs

@@ -1,12 +1,13 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Dynamic;
 using System.Threading.Tasks;
 using HotChocolate.Execution;
 using HotChocolate.Language;
 using HotChocolate.Tests;
 using Microsoft.Extensions.DependencyInjection;
 using Snapshooter.Xunit;
-using Xunit;
 using static HotChocolate.Tests.TestHelper;
 
 namespace HotChocolate.Types;
@@ -1096,8 +1097,8 @@ public void Deserialize_List()
         // assert
         Assert.Collection(
             Assert.IsType<object[]>(value)!,
-            x => Assert.Equal("Foo",x),
-            x => Assert.Equal("Bar",x));
+            x => Assert.Equal("Foo", x),
+            x => Assert.Equal("Bar", x));
     }
 
     [Fact]
@@ -1110,6 +1111,43 @@ await ExpectValid(
             .MatchSnapshotAsync();
     }
 
+    [Fact]
+    public async Task UseExpandoObjectWithAny()
+    {
+        Snapshot.FullName();
+        await ExpectValid(
+                "{ something }",
+                configure: c => c.AddQueryType<SomeQuery>())
+            .MatchSnapshotAsync();
+    }
+    
+    [Fact]
+    public async Task UseImmutableDictWithAny()
+    {
+        Snapshot.FullName();
+        await ExpectValid(
+                "{ somethingImmutable }",
+                configure: c => c.AddQueryType<SomeQuery>())
+            .MatchSnapshotAsync();
+    }
+
+    public class SomeQuery
+    {
+        [GraphQLType<AnyType>]
+        public object GetSomething()
+        {
+            dynamic obj = new ExpandoObject();
+            obj.a = "Foo";
+            return obj;
+        }
+        
+        [GraphQLType<AnyType>]
+        public ImmutableDictionary<string, object> GetSomethingImmutable()
+        {
+            return ImmutableDictionary<string, object>.Empty.Add("a", "Foo");
+        }
+    }
+
     public class Foo
     {
         public Bar Bar { get; set; } = new Bar();

src/HotChocolate/Core/test/Types.Tests/Types/Scalars/__snapshots__/AnyTypeTests.UseExpandoObjectWithAny.snap

@@ -0,0 +1,7 @@
+{
+  "data": {
+    "something": {
+      "a": "Foo"
+    }
+  }
+}

src/HotChocolate/Core/test/Types.Tests/Types/Scalars/__snapshots__/AnyTypeTests.UseImmutableDictWithAny.snap

@@ -0,0 +1,7 @@
+{
+  "data": {
+    "somethingImmutable": {
+      "a": "Foo"
+    }
+  }
+}