Initial implementation of mutations.

Author: jhgg

README.md

@@ -263,10 +263,10 @@ Epoxy also supports defining mutations. Making a Mutation a Relay mutation is as
 ```python
 
 class AddFriend(R.Mutation):
-    class Input(R.InputType):
+    class Input:
         human_to_add = R.ID.NonNull
 
-    class Output(R.OutputType):
+    class Output:
         new_friends_list = R.Human.List
 
     @R.resolve_with_args

epoxy/argument.py

@@ -0,0 +1,14 @@
+from graphql.core.type import GraphQLArgument
+from .utils.gen_id import gen_id
+
+
+class Argument(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_argument(self, registry):
+        return GraphQLArgument(registry[self.type](), self.default_value, self.description)

epoxy/bases/mutation.py

@@ -0,0 +1,3 @@
+class MutationBase(object):
+    def __init__(self):
+        pass

epoxy/metaclasses/mutation.py

@@ -0,0 +1,48 @@
+from graphql.core.type import GraphQLField, GraphQLNonNull
+from graphql.core.type.definition import GraphQLArgument
+
+
+class MutationMeta(type):
+    def __new__(mcs, name, bases, attrs):
+        if attrs.pop('abstract', False):
+            return super(MutationMeta, mcs).__new__(mcs, name, bases, attrs)
+
+        registry = mcs._get_registry()
+
+        input = attrs.pop('Input')
+        output = attrs.pop('Output')
+
+        assert input and not hasattr(input, 'T'), 'A mutation must define a class named "Input" inside of it that ' \
+                                                  'does not subclass an R.InputType'
+        assert output and not hasattr(output, 'T'), 'A mutation must define a class named "Output" inside of it that ' \
+                                                    'does not subclass an R.ObjectType'
+
+        Input = type(name + 'Input', (registry.InputType,), dict(vars(input)))
+        Output = type(name + 'Payload', (registry.ObjectType,), dict(vars(output)))
+        attrs['Input'] = Input
+        attrs['Output'] = Output
+
+        cls = super(MutationMeta, mcs).__new__(mcs, name, bases, attrs)
+        cls._registry = registry
+        instance = cls()
+        resolver = getattr(instance, 'execute')
+        assert resolver and callable(resolver), 'A mutation must define a function named "execute" that will execute ' \
+                                                'the mutation.'
+
+        mutation_name = name[0].lower() + name[1:]
+
+        mcs._register(mutation_name, registry.with_resolved_types(lambda R: GraphQLField(
+            type=R[Output],
+            args={
+                'input': GraphQLArgument(GraphQLNonNull(R[Input]))
+            },
+            resolver=lambda obj, args, info: resolver(obj, Input(args.get('input')), info)
+        )))
+
+    @staticmethod
+    def _register(mutation_name, mutation):
+        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')

epoxy/registry.py

@@ -1,4 +1,4 @@
-from collections import defaultdict
+from collections import defaultdict, OrderedDict
 from enum import Enum
 from functools import partial
 from graphql.core.type import (
@@ -21,6 +21,7 @@
 from .bases.class_type_creator import ClassTypeCreator
 from .bases.input_type import InputTypeBase
 from .bases.object_type import ObjectTypeBase
+from epoxy.metaclasses.mutation import MutationMeta
 from .field import Field, InputField
 from .metaclasses.input_type import InputTypeMeta
 from .metaclasses.interface import InterfaceMeta
@@ -46,6 +47,8 @@ class TypeRegistry(object):
         'ObjectType', 'InputType', 'Union' 'Interface', 'Implements',
         # Functions
         'Schema', 'Register', 'Mixin',
+        # Mutations
+        'Mutation', 'Mutations',
         # Fields
         'Field', 'InputField',
     ])
@@ -65,6 +68,8 @@ def __init__(self):
         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()
+        self.Mutation = self._create_mutation_type_class()
+        self._mutations = {}
 
         for type in builtin_scalars:
             self.Register(type)
@@ -111,6 +116,9 @@ def _resolve_type(self, item):
         return value
 
     def __getattr__(self, item):
+        if item.startswith('_'):
+            raise AttributeError(item)
+
         return RootTypeThunk(self, self._resolve_type, item)
 
     def __getitem__(self, item):
@@ -205,6 +213,44 @@ class InputType(InputTypeBase):
 
         return InputType
 
+    def _create_mutation_type_class(self):
+        registry = self
+
+        class RegistryInputTypeMeta(MutationMeta):
+            @staticmethod
+            def _register(mutation_name, mutation):
+                registry._register_mutation(mutation_name, mutation)
+
+            @staticmethod
+            def _get_registry():
+                return registry
+
+        @six.add_metaclass(RegistryInputTypeMeta)
+        class InputType(InputTypeBase):
+            abstract = True
+
+        return InputType
+
+    def _register_mutation(self, mutation_name, mutation):
+        assert mutation_name not in self._mutations, \
+            'There is already a registered mutation named "{}".'.format(mutation_name)
+
+        self._mutations[mutation_name] = mutation
+
+    @property
+    def Mutations(self):
+        if not self._mutations:
+            raise TypeError("No mutations have been registered.")
+
+        mutations = OrderedDict()
+        for k in sorted(self._mutations.keys()):
+            mutations[k] = self._mutations[k]()
+
+        return GraphQLObjectType(
+            name='Mutations',
+            fields=mutations
+        )
+
     def _create_is_type_of(self, type):
         return partial(self._is_type_of, type)
 
@@ -261,7 +307,7 @@ def types(self, *names):
         return self[names]
 
     def with_resolved_types(self, thunk):
-        assert isinstance(thunk, callable)
+        assert callable(thunk)
         return partial(thunk, self._proxy)
 
 
@@ -273,6 +319,9 @@ def __getitem__(self, item):
         return self._registry[item]()
 
     def __getattr__(self, item):
+        if item.startswith('_'):
+            raise AttributeError(item)
+
         return self._registry[item]()
 
 

tests/test_mutation.py

@@ -0,0 +1,39 @@
+from graphql.core import graphql
+from epoxy import TypeRegistry
+
+
+def test_simple_mutation():
+    R = TypeRegistry()
+
+    class SimpleAddition(R.Mutation):
+        class Input:
+            a = R.Int
+            b = R.Int
+
+        class Output:
+            sum = R.Int
+
+        def execute(self, obj, input, info):
+            return self.Output(sum=input.a + input.b)
+
+    # Dummy query -- does nothing.
+    class Query(R.ObjectType):
+        foo = R.String
+
+    Schema = R.Schema(R.Query, R.Mutations)
+
+    mutation_query = '''
+    mutation testSimpleAdd {
+        simpleAddition(input: {a: 5, b: 10}) {
+            sum
+        }
+    }
+    '''
+
+    result = graphql(Schema, mutation_query)
+    assert not result.errors
+    assert result.data == {
+        'simpleAddition': {
+            'sum': 15
+        }
+    }