Implementation of automatic runtime types.

Code refactor and clean-up.
More tests!

Author: jhgg

epoxy/bases/class_type_creator.py

@@ -0,0 +1,19 @@
+from ..thunk import ResolveThunk, ThunkList
+
+
+class ClassTypeCreator(object):
+    def __init__(self, registry, class_type_creator):
+        self._registry = registry
+        self._class_type_creator = class_type_creator
+
+    def __getattr__(self, item):
+        return self[item]
+
+    def __getitem__(self, item):
+        if isinstance(item, tuple):
+            type_thunk = ThunkList([ResolveThunk(self._registry._resolve_type, i) for i in item])
+
+        else:
+            type_thunk = ThunkList([ResolveThunk(self._registry._resolve_type, item)])
+
+        return self._class_type_creator(type_thunk)

epoxy/metaclasses/interface.py

@@ -3,22 +3,21 @@
 from graphql.core.type.definition import GraphQLInterfaceType
 from ..utils.get_declared_fields import get_declared_fields
 from ..utils.make_default_resolver import make_default_resolver
-from ..utils.ref_holder import RefHolder
+from ..utils.weak_ref_holder import WeakRefHolder
 from ..utils.yank_potential_fields import yank_potential_fields
 
 
 class InterfaceMeta(type):
     def __new__(mcs, name, bases, attrs):
-        if attrs.get('abstract'):
+        if attrs.pop('abstract', False):
             return super(InterfaceMeta, mcs).__new__(mcs, name, bases, attrs)
 
-        class_ref = RefHolder()
+        class_ref = WeakRefHolder()
         declared_fields = get_declared_fields(name, yank_potential_fields(attrs))
         interface = GraphQLInterfaceType(
             name,
             fields=partial(mcs._build_field_map, class_ref, declared_fields),
             description=attrs.get('__doc__'),
-            resolve_type=lambda: None
         )
 
         mcs._register(interface, declared_fields)

epoxy/metaclasses/object_type.py

@@ -4,7 +4,7 @@
 from ..utils.get_declared_fields import get_declared_fields
 from ..utils.make_default_resolver import make_default_resolver
 from ..utils.no_implementation_registration import no_implementation_registration
-from ..utils.ref_holder import RefHolder
+from ..utils.weak_ref_holder import WeakRefHolder
 from ..utils.yank_potential_fields import yank_potential_fields
 
 
@@ -13,8 +13,10 @@ def __new__(mcs, name, bases, attrs):
         if attrs.pop('abstract', False):
             return super(ObjectTypeMeta, mcs).__new__(mcs, name, bases, attrs)
 
-        class_ref = RefHolder()
+        class_ref = WeakRefHolder()
+        registry = mcs._get_registry()
         declared_fields = get_declared_fields(name, yank_potential_fields(attrs))
+
         with no_implementation_registration():
             object_type = GraphQLObjectType(
                 name,
@@ -23,10 +25,12 @@ def __new__(mcs, name, bases, attrs):
                 interfaces=mcs._get_interfaces()
             )
 
-        mcs._register(object_type)
+            object_type.is_type_of = registry._create_is_type_of(object_type)
+
         cls = super(ObjectTypeMeta, mcs).__new__(mcs, name, bases, attrs)
+        mcs._register(object_type, cls)
+        cls._registry = registry
         cls.T = object_type
-        cls._registry = mcs._get_registry()
         class_ref.set(cls)
 
         return cls

epoxy/metaclasses/union.py

@@ -0,0 +1,41 @@
+from collections import OrderedDict
+from functools import partial
+from graphql.core.type import GraphQLObjectType
+from graphql.core.type.definition import GraphQLInterfaceType, GraphQLUnionType
+from ..utils.get_declared_fields import get_declared_fields
+from ..utils.make_default_resolver import make_default_resolver
+from ..utils.no_implementation_registration import no_implementation_registration
+from ..utils.weak_ref_holder import WeakRefHolder
+from ..utils.yank_potential_fields import yank_potential_fields
+
+
+class ObjectTypeMeta(type):
+    def __new__(mcs, name, bases, attrs):
+        if attrs.pop('abstract', False):
+            return super(ObjectTypeMeta, mcs).__new__(mcs, name, bases, attrs)
+
+        with no_implementation_registration():
+            union_type = GraphQLUnionType(
+                name,
+                types=mcs._get_types()
+                description=attrs.get('__doc__'),
+            )
+
+        mcs._register(union_type)
+        cls = super(ObjectTypeMeta, mcs).__new__(mcs, name, bases, attrs)
+        cls.T = union_type
+        cls._registry = mcs._get_registry()
+
+        return cls
+
+    @staticmethod
+    def _register(union_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 _get_types():
+        return None

epoxy/registry.py

@@ -1,5 +1,6 @@
+from collections import defaultdict
 from enum import Enum
-
+from functools import partial
 from graphql.core.type import (
     GraphQLBoolean,
     GraphQLEnumType,
@@ -19,6 +20,7 @@
 
 import six
 from .bases.object_type import ObjectTypeBase
+from .bases.class_type_creator import ClassTypeCreator
 from .field import Field
 from .metaclasses.interface import InterfaceMeta
 from .metaclasses.object_type import ObjectTypeMeta
@@ -44,8 +46,10 @@ def __init__(self):
         self._registered_types = {}
         self._added_impl_types = set()
         self._interface_declared_fields = {}
+        self._registered_types_can_be = defaultdict(set)
         self.ObjectType = self._create_object_type_class()
-        self.Implements = self._create_implement_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()
 
         for type in builtin_scalars:
@@ -66,8 +70,13 @@ def register(self, t):
     @register.register(GraphQLInputObjectType)
     @register.register(GraphQLScalarType)
     def register_(self, t):
-        assert t.name not in ('ObjectType', 'Implements', 'Interface')
-        assert t.name not in self._registered_types
+        assert not t.name.startswith('_'), \
+            'Registered type name cannot start with an "_".'
+        assert t.name not in ('ObjectType', 'Implements', 'Interface', 'Schema'), \
+            'You cannot register a type named "{}".'.format(type.name)
+        assert t.name not in self._registered_types, \
+            'There is already a registered type named "{}".'.format(type.name)
+
         self._registered_types[t.name] = t
         return t
 
@@ -103,8 +112,9 @@ def _create_object_type_class(self, interface_thunk=None):
 
         class RegistryObjectTypeMeta(ObjectTypeMeta):
             @staticmethod
-            def _register(object_type):
+            def _register(object_type, type_class):
                 registry.register(object_type)
+                registry._registered_types_can_be[object_type].add(type_class)
 
             @staticmethod
             def _get_registry():
@@ -123,25 +133,6 @@ class ObjectType(ObjectTypeBase):
 
         return ObjectType
 
-    def _create_implement_type_class(self):
-        registry = self
-
-        class Implements(object):
-            def __getattr__(self, item):
-                return self[item]
-
-            def __getitem__(self, item):
-                if isinstance(item, tuple):
-                    type_thunk = ThunkList([ResolveThunk(registry._resolve_type, i) for i in item])
-
-                else:
-                    type_thunk = ThunkList([ResolveThunk(registry._resolve_type, item)])
-
-                return registry._create_object_type_class(type_thunk)
-
-        implements = Implements()
-        return implements
-
     def _create_interface_type_class(self):
         registry = self
 
@@ -160,18 +151,41 @@ class Interface(six.with_metaclass(RegistryInterfaceMeta)):
 
         return Interface
 
+    def _create_union_type_class(self, types_thunk):
+        registry = self
+
+        class RegistryUnionMeta(UnionMeta):
+            @staticmethod
+            def _register(union):
+                registry.register(union)
+
+            @staticmethod
+            def _get_registry():
+                return registry
+
+        class Union(six.with_metaclass(RegistryUnionMeta)):
+            abstract = True
+
+            @staticmethod
+            def _get_types():
+                return TransformThunkList(types_thunk, get_named_type)
+
+        return Union
+
+    def _create_is_type_of(self, type):
+        return partial(self._is_type_of, type)
+
+    def _is_type_of(self, type, obj, info):
+        return obj.__class__ in self._registered_types_can_be[type]
+
     def _add_interface_declared_fields(self, interface, attrs):
         self._interface_declared_fields[interface] = attrs
 
     def _get_interface_declared_fields(self, interface):
         return self._interface_declared_fields.get(interface, {})
 
-    def _add_impl_to_interfaces(self, *types):
-        type_map = {}
-        for type in types:
-            type_map = type_map_reducer(type_map, type)
-
-        for type in type_map:
+    def _add_impl_to_interfaces(self):
+        for type in self._registered_types.values():
             if not isinstance(type, GraphQLObjectType):
                 continue
 
@@ -185,10 +199,10 @@ def _add_impl_to_interfaces(self, *types):
 
                 interface._impls.append(type)
 
-    def schema(self, query, mutation=None):
+    def Schema(self, query, mutation=None):
         query = self[query]()
         mutation = self[mutation]()
-        self._add_impl_to_interfaces(query, mutation)
+        self._add_impl_to_interfaces()
         return GraphQLSchema(query=query, mutation=mutation)
 
     def type(self, name):

epoxy/thunk.py

@@ -36,7 +36,7 @@ def __init__(self, getter, item):
         self.item = item
 
     def _resolve(self, item):
-        if callable(item):
+        if callable(item) and not hasattr(item, 'T'):
             return self._resolve(item())
 
         return maybe_callable(self.getter(item))

epoxy/utils/maybe_callable.py

@@ -1,5 +1,5 @@
 def maybe_callable(obj):
-    if callable(obj):
+    if callable(obj) and not hasattr(obj, 'T'):
         return obj()
 
     return obj

epoxy/utils/ref_holder.py epoxy/utils/weak_ref_holder.pyepoxy/utils/ref_holder.py renamed to epoxy/utils/weak_ref_holder.py

@@ -1,12 +1,14 @@
 from weakref import ReferenceType, ref
 
 
-class RefHolder(object):
-    ref = None
+class WeakRefHolder(object):
+    __slots__ = 'ref',
 
     def __init__(self, ref=None):
         if ref is not None:
             self.set(ref)
+        else:
+            self.ref = None
 
     def _delete_ref(self, ref):
         if ref is self.ref:

tests/test_graphql_object_interoperability.py

@@ -0,0 +1,28 @@
+from collections import namedtuple
+from graphql.core import graphql
+from graphql.core.type import GraphQLObjectType, GraphQLField, GraphQLString
+from epoxy.registry import TypeRegistry
+
+
+def test_resolves_regular_graphql_type():
+    BuiltInType = GraphQLObjectType(
+        name='BuiltInType',
+        fields={
+            'someString': GraphQLField(GraphQLString)
+        }
+    )
+
+    BuiltInTypeTuple = namedtuple('BuiltInTypeData', 'someString')
+
+    R = TypeRegistry()
+
+    class Query(R.ObjectType):
+        built_in_type = R.Field(BuiltInType)
+
+        def resolve_built_in_type(self, obj, args, info):
+            return BuiltInTypeTuple('Hello World. I am a string.')
+
+    schema = R.Schema(R.Query)
+    result = graphql(schema, '{ builtInType { someString } }')
+    assert not result.errors
+    assert result.data == {'builtInType': {'someString': 'Hello World. I am a string.'}}

tests/test_interfaces.py

@@ -1,3 +1,4 @@
+from graphql.core import graphql
 from epoxy.registry import TypeRegistry
 
 
@@ -132,3 +133,48 @@ class Human(R.Implements[R.Character, Bean]):
     human = Human.T
     fields = human.get_fields()
     assert list(fields.keys()) == ['id', 'name', 'friendsWith', 'livesRemaining', 'real', 'hero', 'homePlanet']
+
+
+def test_runtime_type_resolution():
+    R = TypeRegistry()
+
+    class Pet(R.Interface):
+        name = R.String
+
+    class Dog(R.Implements.Pet):
+        bark = R.String
+
+    class Cat(R.Implements.Pet):
+        meow = R.String
+
+    class Query(R.ObjectType):
+        pets = R.Pet.List
+
+    schema = R.Schema(Query)
+
+    data = Query(pets=[
+        Dog(name='Clifford', bark='Really big bark, because it\'s a really big dog.'),
+        Cat(name='Garfield', meow='Lasagna')
+    ])
+
+    result = graphql(schema, '''
+        {
+            pets {
+                name
+                __typename
+                ... on Dog {
+                    bark
+                }
+
+                ... on Cat {
+                    meow
+                }
+            }
+        }
+
+    ''', data)
+    assert not result.errors
+    assert result.data == {
+        'pets': [{'__typename': 'Dog', 'bark': "Really big bark, because it's a really big dog.", 'name': 'Clifford'},
+                 {'__typename': 'Cat', 'meow': 'Lasagna', 'name': 'Garfield'}]
+    }