Handle complex input types

Author: nparrish

graphene/types/inputobjecttype.py

@@ -1,11 +1,14 @@
 from collections import OrderedDict
 
 from .base import BaseOptions, BaseType
+from .field import Field
 from .inputfield import InputField
+from .objecttype import ObjectType
+from .scalars import Scalar
+from .structures import List, NonNull
 from .unmountedtype import UnmountedType
 from .utils import yank_fields_from_attrs
 
-
 # For static type checking with Mypy
 MYPY = False
 if MYPY:
@@ -24,11 +27,29 @@ class Meta:
     def __init__(self, *args, **kwargs):
         dict.__init__(self, *args, **kwargs)
         for key in self._meta.fields.keys():
-            setattr(self, key, self.get(key, None))
+            field = getattr(self, key, None)
+            if field is None or self.get(key, None) is None:
+                value = None
+            else:
+                value = InputObjectTypeContainer._get_typed_field_value(field, self[key])
+            setattr(self, key, value)
 
     def __init_subclass__(cls, *args, **kwargs):
         pass
 
+    @staticmethod
+    def _get_typed_field_value(field_or_type, value):
+        if isinstance(field_or_type, NonNull):
+            return InputObjectTypeContainer._get_typed_field_value(field_or_type.of_type, value)
+        elif isinstance(field_or_type, List):
+            return [
+                InputObjectTypeContainer._get_typed_field_value(field_or_type.of_type, v)
+                for v in value
+            ]
+        elif hasattr(field_or_type, '_meta') and hasattr(field_or_type._meta, 'container'):
+            return field_or_type._meta.container(value)
+        else:
+            return value
 
 class InputObjectType(UnmountedType, BaseType):
     '''

graphene/types/tests/test_typemap.py

@@ -4,14 +4,15 @@
                           GraphQLInputObjectType, GraphQLInterfaceType,
                           GraphQLObjectType, GraphQLString)
 
+from ..structures import List, NonNull
 from ..dynamic import Dynamic
 from ..enum import Enum
 from ..field import Field
 from ..inputfield import InputField
 from ..inputobjecttype import InputObjectType
 from ..interface import Interface
 from ..objecttype import ObjectType
-from ..scalars import String
+from ..scalars import String, Int
 from ..typemap import TypeMap
 
 
@@ -119,10 +120,18 @@ def resolve_foo(self, args, info):
 
 
 def test_inputobject():
+    class OtherObjectType(InputObjectType):
+        thingy = NonNull(Int)
+
+    class MyInnerObjectType(InputObjectType):
+        some_field = String()
+        some_other_field = List(OtherObjectType)
+
     class MyInputObjectType(InputObjectType):
         '''Description'''
         foo_bar = String(description='Field description')
         bar = String(name='gizmo')
+        baz = NonNull(MyInnerObjectType)
         own = InputField(lambda: MyInputObjectType)
 
         def resolve_foo_bar(self, args, info):
@@ -136,14 +145,23 @@ def resolve_foo_bar(self, args, info):
     assert graphql_type.description == 'Description'
 
     # Container
-    container = graphql_type.create_container({'bar': 'oh!'})
+    container = graphql_type.create_container({
+        'bar': 'oh!',
+        'baz': {
+            'some_other_field': [{'thingy': 1}, {'thingy': 2}]
+        }
+    })
     assert isinstance(container, MyInputObjectType)
     assert 'bar' in container
     assert container.bar == 'oh!'
     assert 'foo_bar' not in container
+    assert container.foo_bar is None
+    assert container.baz.some_field is None
+    assert container.baz.some_other_field[0].thingy == 1
+    assert container.baz.some_other_field[1].thingy == 2
 
     fields = graphql_type.fields
-    assert list(fields.keys()) == ['fooBar', 'gizmo', 'own']
+    assert list(fields.keys()) == ['fooBar', 'gizmo', 'baz', 'own']
     own_field = fields['own']
     assert own_field.type == graphql_type
     foo_field = fields['fooBar']