Implementation of input types.

Author: jhgg

epoxy/bases/input_type.py

@@ -0,0 +1,29 @@
+class InputTypeBase(object):
+    T = None
+    _field_attr_map = None
+
+    def __init__(self, arg_value=None):
+        if arg_value is None:
+            return
+
+        if self._field_attr_map is None:
+            raise RuntimeError("You cannot construct type {} until it is used in a created Schema.".format(
+                self.T
+            ))
+
+        for attr_name, (field_name, field) in self._field_attr_map.items():
+            if field_name in arg_value:
+                setattr(self, attr_name, arg_value[field_name])
+
+            else:
+                setattr(self, attr_name, field.default_value)
+
+    def __repr__(self):
+        if self._field_attr_map is None:
+            return '<{}>'.format(self.T)
+
+        return '<{} {}>'.format(
+            self.T,
+            ' '.join('{}={!r}'.format(field_name, getattr(self, field_name))
+                     for field_name in self._field_attr_map.keys())
+        )

epoxy/field.py

@@ -1,4 +1,4 @@
-from graphql.core.type import GraphQLField
+from graphql.core.type import GraphQLField, GraphQLInputObjectField
 from .utils.gen_id import gen_id
 
 
@@ -15,3 +15,16 @@ def __init__(self, type, description=None, args=None, name=None, resolver=None,
 
     def to_field(self, registry, resolver):
         return GraphQLField(registry[self.type](), args=self.args, resolver=resolver)
+
+
+class InputField(object):
+    def __init__(self, type, description=None, default_value=None, name=None, _counter=None):
+        self.name = name
+        self.type = type
+        self.description = description
+        self.default_value = default_value
+        self._counter = _counter or gen_id()
+
+    def to_field(self, registry):
+        return GraphQLInputObjectField(registry[self.type](), default_value=self.default_value,
+                                       description=self.description)

epoxy/metaclasses/input_type.py

@@ -0,0 +1,59 @@
+from collections import OrderedDict
+from functools import partial
+from graphql.core.type.definition import GraphQLInputObjectType
+from ..field import InputField
+from ..utils.get_declared_fields import get_declared_fields
+from ..utils.weak_ref_holder import WeakRefHolder
+from ..utils.yank_potential_fields import yank_potential_fields
+
+
+class InputTypeMeta(type):
+    def __new__(mcs, name, bases, attrs):
+        if attrs.pop('abstract', False):
+            return super(InputTypeMeta, mcs).__new__(mcs, name, bases, attrs)
+
+        name = attrs.pop('_name', name)
+        class_ref = WeakRefHolder()
+        declared_fields = get_declared_fields(name, yank_potential_fields(attrs, InputField), InputField)
+        interface = GraphQLInputObjectType(
+            name,
+            fields=partial(mcs._build_field_map, class_ref, declared_fields),
+            description=attrs.get('__doc__'),
+        )
+
+        mcs._register(interface)
+        cls = super(InputTypeMeta, mcs).__new__(mcs, name, bases, attrs)
+        cls.T = interface
+        cls._registry = mcs._get_registry()
+        class_ref.set(cls)
+
+        return cls
+
+    @staticmethod
+    def _register(object_type):
+        raise NotImplementedError('_register must be implemented in the sub-metaclass')
+
+    @staticmethod
+    def _get_registry():
+        raise NotImplementedError('_get_registry must be implemented in the sub-metaclass')
+
+    @staticmethod
+    def _build_field_map(class_ref, fields):
+        cls = class_ref.get()
+        if not cls:
+            return
+
+        registry = cls._registry
+        field_map = OrderedDict()
+        field_attr_map = OrderedDict()
+
+        for field_attr_name, field in fields:
+            graphql_field = field_map[field.name] = field.to_field(registry)
+
+            if field_attr_name in field_attr_map:
+                del field_attr_map[field_attr_name]
+
+            field_attr_map[field_attr_name] = (field.name, graphql_field)
+
+        cls._field_attr_map = field_attr_map
+        return field_map

epoxy/registry.py

@@ -19,8 +19,10 @@
 import six
 
 from .bases.class_type_creator import ClassTypeCreator
+from .bases.input_type import InputTypeBase
 from .bases.object_type import ObjectTypeBase
-from .field import Field
+from .field import Field, InputField
+from .metaclasses.input_type import InputTypeMeta
 from .metaclasses.interface import InterfaceMeta
 from .metaclasses.object_type import ObjectTypeMeta
 from .metaclasses.union import UnionMeta
@@ -39,8 +41,17 @@
 
 
 class TypeRegistry(object):
-    # Fields
+    _reserved_names = frozenset([
+        # Types
+        'ObjectType', 'InputType', 'Union' 'Interface', 'Implements',
+        # Functions
+        'Schema', 'Register', 'Mixin',
+        # Fields
+        'Field', 'InputField',
+    ])
+
     Field = Field
+    InputField = InputField
 
     def __init__(self):
         self._registered_types = {}
@@ -50,6 +61,7 @@ def __init__(self):
         self._pending_types_can_be = defaultdict(set)
         self._proxy = ResolvedRegistryProxy(self)
         self.ObjectType = self._create_object_type_class()
+        self.InputType = self._create_input_type_class()
         self.Implements = ClassTypeCreator(self, self._create_object_type_class)
         self.Union = ClassTypeCreator(self, self._create_union_type_class)
         self.Interface = self._create_interface_type_class()
@@ -75,7 +87,7 @@ def Register(self, t):
     def register_(self, t):
         assert not t.name.startswith('_'), \
             'Registered type name cannot start with an "_".'
-        assert t.name not in ('ObjectType', 'Implements', 'Interface', 'Schema', 'Register'), \
+        assert t.name not in self._reserved_names, \
             'You cannot register a type named "{}".'.format(t.name)
         assert t.name not in self._registered_types, \
             'There is already a registered type named "{}".'.format(t.name)
@@ -175,6 +187,24 @@ class Union(six.with_metaclass(RegistryUnionMeta)):
 
         return Union
 
+    def _create_input_type_class(self):
+        registry = self
+
+        class RegistryInputTypeMeta(InputTypeMeta):
+            @staticmethod
+            def _register(input_type):
+                registry.Register(input_type)
+
+            @staticmethod
+            def _get_registry():
+                return registry
+
+        @six.add_metaclass(RegistryInputTypeMeta)
+        class InputType(InputTypeBase):
+            abstract = True
+
+        return InputType
+
     def _create_is_type_of(self, type):
         return partial(self._is_type_of, type)
 

epoxy/utils/get_declared_fields.py

@@ -7,23 +7,21 @@
 from ..utils.to_camel_case import to_camel_case
 
 
-def get_declared_fields(type_name, attrs):
+def get_declared_fields(type_name, attrs, field_class=Field):
     fields = []
 
     for field_attr_name, obj in list(attrs.items()):
-        if isinstance(obj, Field):
+        if isinstance(obj, field_class):
             field = copy.copy(obj)
             field.name = first_of(field.name, to_camel_case(field_attr_name))
             # Bind field.type to the maybe scope.
             field.type = (lambda field_type: lambda: maybe_t(maybe_callable(field_type)))(field.type)
             fields.append((field_attr_name, field))
 
-            continue
-
-        if isinstance(obj, TypeThunk):
+        elif isinstance(obj, TypeThunk):
             counter = obj._counter
 
-            field = Field(obj, name=to_camel_case(field_attr_name), _counter=counter, **(obj._kwargs or {}))
+            field = field_class(obj, name=to_camel_case(field_attr_name), _counter=counter, **(obj._kwargs or {}))
             fields.append((field_attr_name, field))
 
     fields.sort(key=lambda f: f[1]._counter)

epoxy/utils/yank_potential_fields.py

@@ -2,14 +2,15 @@
 from ..thunk import TypeThunk
 
 
-def yank_potential_fields(attrs):
+def yank_potential_fields(attrs, field_class=Field):
     field_attrs = {}
+    potential_types = (field_class, TypeThunk)
 
     for field_attr_name, obj in list(attrs.items()):
         if field_attr_name == 'T':
             continue
 
-        if isinstance(obj, (Field, TypeThunk)):
+        if isinstance(obj, potential_types):
             field_attrs[field_attr_name] = attrs.pop(field_attr_name)
 
     return field_attrs

tests/test_input_type.py

@@ -0,0 +1,67 @@
+from graphql.core import graphql
+from graphql.core.type import GraphQLArgument, GraphQLInputObjectType, GraphQLString
+from graphql.core.type.scalars import GraphQLInt
+from epoxy import TypeRegistry
+
+
+def test_input_type_creation():
+    R = TypeRegistry()
+
+    class SimpleInput(R.InputType):
+        a = R.Int
+        b = R.Int
+        some_underscore = R.String
+        some_from_field = R.InputField(R.String, default_value='Hello World')
+
+    input_type = SimpleInput.T
+    assert input_type is R.SimpleInput()
+    assert isinstance(input_type, GraphQLInputObjectType)
+    fields = input_type.get_fields()
+    assert list(fields.keys()) == ['a', 'b', 'someUnderscore', 'someFromField']
+    assert [field.name for field in fields.values()] == ['a', 'b', 'someUnderscore', 'someFromField']
+
+    assert fields['a'].type == GraphQLInt
+    assert fields['b'].type == GraphQLInt
+    assert fields['someUnderscore'].type == GraphQLString
+    assert fields['someFromField'].type == GraphQLString
+    assert fields['someFromField'].default_value == 'Hello World'
+
+    input_value = SimpleInput({
+        'a': 1,
+        'someUnderscore': 'hello',
+    })
+
+    assert input_value.a == 1
+    assert input_value.b is None
+    assert input_value.some_underscore == 'hello'
+    assert input_value.some_from_field == 'Hello World'
+
+
+def test_input_type():
+    R = TypeRegistry()
+
+    class SimpleInput(R.InputType):
+        a = R.Int
+        b = R.Int
+
+    class Query(R.ObjectType):
+        f = R.String(args={
+            'input': GraphQLArgument(R.SimpleInput())
+        })
+
+        def resolve_f(self, obj, args, info):
+            input = SimpleInput(args['input'])
+            return "I was given {i.a} and {i.b}".format(i=input)
+
+    Schema = R.Schema(R.Query)
+    query = '''
+    {
+        f(input: {a: 1, b: 2})
+    }
+    '''
+
+    result = graphql(Schema, query)
+    assert not result.errors
+    assert result.data == {
+        'f': "I was given 1 and 2"
+    }

tests/test_register_reserved_name.py

@@ -0,0 +1,18 @@
+from graphql.core.type import GraphQLField, GraphQLObjectType
+from graphql.core.type import GraphQLString
+from epoxy import TypeRegistry
+from pytest import raises
+
+
+def test_reserved_names():
+    R = TypeRegistry()
+
+    for name in R._reserved_names:
+        type = GraphQLObjectType(
+            name=name,
+            fields={'a': GraphQLField(GraphQLString)}
+        )
+        with raises(AssertionError) as excinfo:
+            R(type)
+
+        assert str(excinfo.value) == 'You cannot register a type named "{}".'.format(name)