[v0.2.1] Argument key translation from camelCase in GraphQL world to the original casing specified.

Author: jhgg

Diff for: README.md

@@ -40,7 +40,7 @@ class Query(R.ObjectType):
 
     def resolve_human(self, obj, args, info):
         """This will be used as the description of the field Query.human."""
-        return Human(5, 'Bob', [Human(6, 'Bill')]
+        return Human(id=5, name='Bob', friends=[Human(id=6, name='Bill')]
 
 ```
 

Diff for: epoxy/types/field.py

@@ -1,11 +1,10 @@
 from collections import OrderedDict
-
 from graphql.core.type import GraphQLField, GraphQLInputObjectField
-
 from ..types.argument import Argument
 from ..utils.gen_id import gen_id
 from ..utils.thunk import TypeThunk
 from ..utils.to_camel_case import to_camel_case
+from ..utils.wrap_resolver_translating_arguments import wrap_resolver_translating_arguments
 
 
 class Field(object):
@@ -20,13 +19,19 @@ def __init__(self, type, description=None, args=None, name=None, resolver=None,
         self._counter = _counter or gen_id()
 
     def to_field(self, registry, resolver):
-        return GraphQLField(registry[self.type](), args=self.get_arguments(registry), resolver=resolver)
+        args, arguments_to_original_case = self.get_arguments(registry)
+
+        if arguments_to_original_case:
+            resolver = wrap_resolver_translating_arguments(resolver, arguments_to_original_case)
+
+        return GraphQLField(registry[self.type](), args=args, resolver=resolver)
 
     def get_arguments(self, registry):
         if not self.args:
-            return None
+            return None, None
 
         arguments = []
+        arguments_to_original_case = {}
 
         for k, argument in self.args.items():
             if isinstance(argument, TypeThunk):
@@ -35,16 +40,29 @@ def get_arguments(self, registry):
             elif not isinstance(argument, Argument):
                 raise ValueError('Unknown argument value type %r' % argument)
 
+            camel_cased_name = to_camel_case(k)
+            if camel_cased_name in arguments_to_original_case:
+                raise ValueError(
+                    'Argument %s already exists as %s' %
+                    (k, arguments_to_original_case[camel_cased_name])
+                )
+
+            arguments_to_original_case[camel_cased_name] = k
             arguments.append((
-                to_camel_case(k), argument
+                camel_cased_name, argument
             ))
 
         if not isinstance(self.args, OrderedDict):
             arguments.sort(
                 key=lambda i: i[1]._counter
             )
 
-        return OrderedDict([(k, v.to_argument(registry)) for k, v in arguments])
+        # Remove things that wouldn't perform any meaningful translation.
+        for k, v in list(arguments_to_original_case.items()):
+            if k == v:
+                del arguments_to_original_case[k]
+
+        return OrderedDict([(k, v.to_argument(registry)) for k, v in arguments]), arguments_to_original_case
 
 
 class InputField(object):

Diff for: epoxy/utils/wrap_resolver_translating_arguments.py

@@ -0,0 +1,17 @@
+from collections import OrderedDict
+
+from six import wraps
+
+
+def wrap_resolver_translating_arguments(resolver, arguments_to_original_case):
+    translate_key = arguments_to_original_case.get
+
+    @wraps(resolver)
+    def wrapped(obj, args, info):
+        new_args = OrderedDict() if isinstance(args, OrderedDict) else {}
+        for k in args:
+            new_args[translate_key(k, k)] = args[k]
+
+        return resolver(obj, new_args, info)
+
+    return wrapped

Diff for: setup.py

@@ -11,7 +11,7 @@
 
 setup(
     name='graphql-epoxy',
-    version='0.2',
+    version='0.2.1',
     description='GraphQL implementation for Python',
     url='https://github.com/graphql-python/graphql-core',
     download_url='https://github.com/graphql-python/graphql-core/releases',

Diff for: tests/test_arguments.py

@@ -1,7 +1,7 @@
 from collections import OrderedDict
-
+from pytest import raises
+from graphql.core import graphql
 from graphql.core.type import GraphQLString, GraphQLInt, GraphQLID, GraphQLNonNull
-
 from epoxy.registry import TypeRegistry
 from epoxy.types.argument import Argument
 
@@ -88,3 +88,50 @@ class Query(R.ObjectType):
     query_type = R.Query()
     check_args(TestInputType.T, query_type.get_fields()['int'].args)
     check_args(TestInputType.T, query_type.get_fields()['intFromField'].args)
+
+
+def test_resolved_args_will_be_translated_to_original_casing():
+    R = TypeRegistry()
+
+    class Query(R.ObjectType):
+        argument_keys = R.String.List(args={
+            'foo': R.String,
+            'foo_bar': R.String
+        })
+
+        def resolve_argument_keys(self, obj, args, info):
+            return list(sorted(args.keys()))
+
+    Schema = R.Schema(R.Query)
+    result = graphql(Schema, '''
+    {
+        argumentKeys(foo: "Hello", fooBar: "World")
+    }
+    ''')
+
+    assert not result.errors
+
+    assert result.data == {
+        'argumentKeys': ['foo', 'foo_bar']
+    }
+
+
+def test_will_recognize_casing_conversion_conflicts():
+    R = TypeRegistry()
+
+    class Query(R.ObjectType):
+        argument_keys = R.String.List(args={
+            'foo_bar': R.String,
+            'fooBar': R.String
+        })
+
+        def resolve_argument_keys(self, obj, args, info):
+            return list(sorted(args.keys()))
+
+    with raises(ValueError) as excinfo:
+        Schema = R.Schema(R.Query)
+
+    assert str(excinfo.value) in (
+        'Argument foo_bar already exists as fooBar',
+        'Argument fooBar already exists as foo_bar',
+    )