Fixed: Type discovery now correctly discovers argument types. (#344)

Author: michaelstaib

src/Abstractions/GraphQLDescriptionAttribute.cs

@@ -0,0 +1,24 @@
+using System;
+
+namespace HotChocolate
+{
+    [AttributeUsage(AttributeTargets.Class
+        | AttributeTargets.Property
+        | AttributeTargets.Method
+        | AttributeTargets.Parameter)]
+    public sealed class GraphQLDescriptionAttribute
+        : Attribute
+    {
+        public GraphQLDescriptionAttribute(string description)
+        {
+            if (string.IsNullOrEmpty(description))
+            {
+                throw new ArgumentNullException(nameof(description));
+            }
+
+            Description = description;
+        }
+
+        public string Description { get; }
+    }
+}

src/Abstractions/GraphQLNameAttribute.cs

@@ -4,7 +4,8 @@ namespace HotChocolate
 {
     [AttributeUsage(AttributeTargets.Class
         | AttributeTargets.Property
-        | AttributeTargets.Method)]
+        | AttributeTargets.Method
+        | AttributeTargets.Parameter)]
     public sealed class GraphQLNameAttribute
         : Attribute
     {

src/Abstractions/GraphQLNonNullAttribute.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace HotChocolate
+{
+    [AttributeUsage(AttributeTargets.Property
+        | AttributeTargets.Method)]
+    public sealed class GraphQLNonNullAttribute
+        : Attribute
+    {
+        public bool ElementIsNullable { get; set; } = false;
+        public bool IsNullable { get; set; } = false;
+    }
+}

src/Abstractions/GraphQLTypeAttribute.cs

@@ -0,0 +1,22 @@
+using System;
+
+namespace HotChocolate
+{
+    [AttributeUsage(AttributeTargets.Property
+        | AttributeTargets.Method)]
+    public sealed class GraphQLTypeAttribute
+        : Attribute
+    {
+        public GraphQLTypeAttribute(Type type)
+        {
+            if (type == null)
+            {
+                throw new ArgumentNullException(nameof(type));
+            }
+
+            Type = type;
+        }
+
+        public Type Type { get; }
+    }
+}

src/Core.Tests/Execution/Utilities/VariableValueBuilderTests.cs

@@ -278,6 +278,30 @@ public void CreateValues_ObjectAsDictionary_Object()
             Assert.Equal(BarEnum.B, bar.F.B);
         }
 
+        [Fact]
+        public void CreateValues_ListOfObject_ListOfString()
+        {
+            // arrange
+            Schema schema = CreateSchema();
+            OperationDefinitionNode operation = CreateQuery(
+                "query test($test: [String]) { a }");
+
+            var variableValues = new Dictionary<string, object>();
+            variableValues.Add("test", new List<object> { "a", "b" });
+
+            var resolver = new VariableValueBuilder(schema, operation);
+
+            // act
+            VariableCollection coercedVariableValues =
+                resolver.CreateValues(variableValues);
+
+            // assert
+            string[] list = coercedVariableValues.GetVariable<string[]>("test");
+            Assert.Collection(list,
+                t => Assert.Equal("a", t),
+                t => Assert.Equal("b", t));
+        }
+
         [Fact]
         public void CreateValues_SerializedDecimal_Decimal()
         {

src/Core/Execution/Utilities/DictionaryToObjectConverter.cs

@@ -10,7 +10,7 @@ namespace HotChocolate.Execution
     internal class DictionaryToObjectConverter
         : QueryResultVisitor<DeserializationContext>
     {
-        public override void VisitObject(
+        protected override void VisitObject(
             ICollection<KeyValuePair<string, object>> dictionary,
             DeserializationContext context)
         {

src/Core/Execution/Utilities/QueryResultVisitor.cs

@@ -9,7 +9,23 @@ namespace HotChocolate.Execution
 {
     internal abstract class QueryResultVisitor<TContext>
     {
-        public virtual void VisitObject(
+        public virtual void Visit(object value, TContext context)
+        {
+            if (value is IDictionary<string, object> dictionary)
+            {
+                VisitObject(dictionary, context);
+            }
+            else if (value is IList<object> list)
+            {
+                VisitList(list, context);
+            }
+            else
+            {
+                VisitValue(value, context);
+            }
+        }
+
+        protected virtual void VisitObject(
             ICollection<KeyValuePair<string, object>> dictionary,
             TContext context)
         {
@@ -38,21 +54,5 @@ protected virtual void VisitValue(object value, TContext context)
         {
 
         }
-
-        protected virtual void Visit(object value, TContext context)
-        {
-            if (value is IDictionary<string, object> dictionary)
-            {
-                VisitObject(dictionary, context);
-            }
-            else if (value is IList<object> list)
-            {
-                VisitList(list, context);
-            }
-            else
-            {
-                VisitValue(value, context);
-            }
-        }
     }
 }

src/Core/Execution/Utilities/VariableValueBuilder.cs

@@ -47,7 +47,7 @@ public VariableCollection CreateValues(
                 _operation.VariableDefinitions)
             {
                 Variable variable = CreateVariable(variableDefinition);
-                CoerceVariableValue(values, ref variable);
+                variable = CoerceVariableValue(values, variable);
                 coercedValues[variable.Name] = variable.ParseLiteral();
             }
 
@@ -73,35 +73,14 @@ private Variable CreateVariable(
                 variableName));
         }
 
-        private void CoerceVariableValue(
+        private Variable CoerceVariableValue(
             IReadOnlyDictionary<string, object> variableValues,
-            ref Variable variable)
+            Variable variable)
         {
             IValueNode valueNode = null;
             if (variableValues.TryGetValue(variable.Name, out var rawValue))
             {
-                object value = rawValue;
-
-                if (rawValue is ICollection<KeyValuePair<string, object>> dict)
-                {
-                    var ctx = new DeserializationContext();
-                    ctx.Type = variable.Type.ClrType;
-
-                    var converter = new DictionaryToObjectConverter();
-                    converter.VisitObject(dict, ctx);
-                    value = ctx.Object;
-                }
-
-                if (!(value is IValueNode)
-                    && variable.Type is ISerializableType st
-                    && !variable.Type.ClrType.IsInstanceOfType(value))
-                {
-                    value = st.Deserialize(value);
-                }
-
-                valueNode = (value is IValueNode v)
-                    ? v
-                    : variable.Type.ParseValue(value);
+                valueNode = Normalize(variable, rawValue);
             }
             else
             {
@@ -113,9 +92,36 @@ private void CoerceVariableValue(
 
             CheckForNullValueViolation(variable);
             CheckForInvalidValueType(variable);
+
+            return variable;
         }
 
+        private IValueNode Normalize(Variable variable, object rawValue)
+        {
+            object value = rawValue;
+
+            if (rawValue is ICollection<KeyValuePair<string, object>>
+                || rawValue is IList<object>)
+            {
+                var ctx = new DeserializationContext();
+                ctx.Type = variable.Type.ClrType;
+
+                var converter = new DictionaryToObjectConverter();
+                converter.Visit(rawValue, ctx);
+                value = ctx.Object;
+            }
 
+            if (!(value is IValueNode)
+                && variable.Type is ISerializableType st
+                && !variable.Type.ClrType.IsInstanceOfType(value))
+            {
+                value = st.Deserialize(value);
+            }
+
+            return (value is IValueNode v)
+                ? v
+                : variable.Type.ParseValue(value);
+        }
 
         private IValueNode CleanUpValue(IInputType type, IValueNode value)
         {