Add support for relay mutations.

Author: jhgg

epoxy/contrib/relay/metaclasses/__init__.py

@@ -0,0 +1,20 @@
+from ....metaclasses.mutation import MutationMeta
+
+
+class RelayMutationMeta(MutationMeta):
+    @staticmethod
+    def _process_input_attrs(registry, input_attrs):
+        input_attrs['client_mutation_id'] = registry.String
+        return input_attrs
+
+    @staticmethod
+    def _process_output_attrs(registry, output_attrs):
+        output_attrs['client_mutation_id'] = registry.String
+        return output_attrs
+
+    @staticmethod
+    def _process_resolver(resolver, input_class, obj, args, info):
+        input_obj = input_class(args.get('input'))
+        result = resolver(obj, input_obj, info)
+        result.client_mutation_id = input_obj.client_mutation_id
+        return result

epoxy/contrib/relay/metaclasses/mutation.py

@@ -1,6 +1,9 @@
 from graphql.core.type import GraphQLArgument
 from graphql.core.type.definition import GraphQLObjectType
+import six
+from ...bases.mutation import MutationBase
 from .connections import connection_args
+from .metaclasses.mutation import RelayMutationMeta
 from .utils import base64, unbase64
 
 
@@ -10,6 +13,7 @@ def __init__(self, registry, data_source):
         self.data_source = data_source
         self._node_field = None
         self._connections = {}
+        self.Mutation = self._create_mutation_type_class()
 
     @property
     def NodeField(self):
@@ -83,3 +87,21 @@ def Connection(self, name, object_type, args=None, resolver=None, **kwargs):
 
         field = self.R.Field(self.connection_definitions(name, object_type)[0], args=args, resolver=resolver, **kwargs)
         return field
+
+    def _create_mutation_type_class(self):
+        registry = self.R
+
+        class RelayRegistryMutationMeta(RelayMutationMeta):
+            @staticmethod
+            def _register(mutation_name, mutation):
+                registry._register_mutation(mutation_name, mutation)
+
+            @staticmethod
+            def _get_registry():
+                return registry
+
+        @six.add_metaclass(RelayRegistryMutationMeta)
+        class Mutation(MutationBase):
+            abstract = True
+
+        return Mutation

epoxy/contrib/relay/mixin.py

@@ -1,3 +1,4 @@
+import functools
 from graphql.core.type import GraphQLField, GraphQLNonNull
 from graphql.core.type.definition import GraphQLArgument
 
@@ -17,8 +18,11 @@ def __new__(mcs, name, bases, attrs):
         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)))
+        input_attrs = mcs._process_input_attrs(registry, dict(vars(input)))
+        output_attrs = mcs._process_output_attrs(registry, dict(vars(output)))
+
+        Input = type(name + 'Input', (registry.InputType,), input_attrs)
+        Output = type(name + 'Payload', (registry.ObjectType,), output_attrs)
         attrs['Input'] = Input
         attrs['Output'] = Output
 
@@ -36,7 +40,7 @@ def __new__(mcs, name, bases, attrs):
             args={
                 'input': GraphQLArgument(GraphQLNonNull(R[Input]))
             },
-            resolver=lambda obj, args, info: resolver(obj, Input(args.get('input')), info)
+            resolver=functools.partial(mcs._process_resolver, resolver, Input)
         )))
 
     @staticmethod
@@ -46,3 +50,15 @@ def _register(mutation_name, mutation):
     @staticmethod
     def _get_registry():
         raise NotImplementedError('_get_registry must be implemented in the sub-metaclass')
+
+    @staticmethod
+    def _process_input_attrs(registry, input_attrs):
+        return input_attrs
+
+    @staticmethod
+    def _process_output_attrs(registry, output_attrs):
+        return output_attrs
+
+    @staticmethod
+    def _process_resolver(resolver, input_class, obj, args, info):
+        return resolver(obj, input_class(args.get('input')), info)

epoxy/metaclasses/mutation.py

@@ -20,6 +20,7 @@
 
 from .bases.class_type_creator import ClassTypeCreator
 from .bases.input_type import InputTypeBase
+from .bases.mutation import MutationBase
 from .bases.object_type import ObjectTypeBase
 from .field import Field, InputField
 from .metaclasses.input_type import InputTypeMeta
@@ -216,7 +217,7 @@ class InputType(InputTypeBase):
     def _create_mutation_type_class(self):
         registry = self
 
-        class RegistryInputTypeMeta(MutationMeta):
+        class RegistryMutationMeta(MutationMeta):
             @staticmethod
             def _register(mutation_name, mutation):
                 registry._register_mutation(mutation_name, mutation)
@@ -225,11 +226,11 @@ def _register(mutation_name, mutation):
             def _get_registry():
                 return registry
 
-        @six.add_metaclass(RegistryInputTypeMeta)
-        class InputType(InputTypeBase):
+        @six.add_metaclass(RegistryMutationMeta)
+        class Mutation(MutationBase):
             abstract = True
 
-        return InputType
+        return Mutation
 
     def _register_mutation(self, mutation_name, mutation):
         assert mutation_name not in self._mutations, \

epoxy/registry.py

@@ -1,3 +1,5 @@
+import operator
+from functools import reduce
 from graphql.core import graphql
 from epoxy import TypeRegistry
 
@@ -16,6 +18,20 @@ class Output:
         def execute(self, obj, input, info):
             return self.Output(sum=input.a + input.b)
 
+    class SimpleMultiplication(R.Mutation):
+        class Input:
+            a = R.Int.List
+
+        class Output:
+            product = R.Int
+            input = R.Int.List
+
+        def execute(self, obj, input, info):
+            return self.Output(
+                input=input.a,
+                product=reduce(operator.mul, input.a[1:], input.a[0])
+            )
+
     # Dummy query -- does nothing.
     class Query(R.ObjectType):
         foo = R.String
@@ -27,6 +43,10 @@ class Query(R.ObjectType):
         simpleAddition(input: {a: 5, b: 10}) {
             sum
         }
+        simpleMultiplication(input: {a: [1, 2, 3, 4, 5]}) {
+            product
+            input
+        }
     }
     '''
 
@@ -35,5 +55,9 @@ class Query(R.ObjectType):
     assert result.data == {
         'simpleAddition': {
             'sum': 15
+        },
+        'simpleMultiplication': {
+            'product': 120,
+            'input': [1, 2, 3, 4, 5]
         }
     }

tests/test_mutation.py

@@ -0,0 +1,69 @@
+import operator
+from functools import reduce
+from graphql.core import graphql
+from epoxy import TypeRegistry
+from epoxy.contrib.relay import RelayMixin
+
+
+def test_simple_mutation():
+    R = TypeRegistry()
+    Relay = R.Mixin(RelayMixin, None)
+
+    class SimpleAddition(Relay.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)
+
+    class SimpleMultiplication(Relay.Mutation):
+        class Input:
+            a = R.Int.List
+
+        class Output:
+            product = R.Int
+            input = R.Int.List
+
+        def execute(self, obj, input, info):
+            return self.Output(
+                input=input.a,
+                product=reduce(operator.mul, input.a[1:], input.a[0])
+            )
+
+    # 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, clientMutationId: "test123"}) {
+            clientMutationId
+            sum
+        }
+        simpleMultiplication(input: {a: [1, 2, 3, 4, 5], clientMutationId: "0xdeadbeef"}) {
+            clientMutationId
+            product
+            input
+        }
+    }
+    '''
+
+    result = graphql(Schema, mutation_query)
+    assert not result.errors
+    assert result.data == {
+        'simpleAddition': {
+            'sum': 15,
+            'clientMutationId': 'test123'
+        },
+        'simpleMultiplication': {
+            'clientMutationId': '0xdeadbeef',
+            'product': 120,
+            'input': [1, 2, 3, 4, 5]
+        }
+    }