Syntax for object type arguments.

Author: jhgg

epoxy/contrib/relay/connections/__init__.py

@@ -1,10 +1,12 @@
-from graphql.core.type import GraphQLArgument, GraphQLInt, GraphQLString
+from graphql.core.type import GraphQLInt, GraphQLString
+
+from ....argument import Argument
 
 __author__ = 'jake'
 
 connection_args = {
-    'before': GraphQLArgument(GraphQLString),
-    'after': GraphQLArgument(GraphQLString),
-    'first': GraphQLArgument(GraphQLInt),
-    'last': GraphQLArgument(GraphQLInt),
+    'before': Argument(GraphQLString),
+    'after': Argument(GraphQLString),
+    'first': Argument(GraphQLInt),
+    'last': Argument(GraphQLInt),
 }

epoxy/contrib/relay/mixin.py

@@ -1,4 +1,3 @@
-from graphql.core.type import GraphQLArgument
 from graphql.core.type.definition import GraphQLObjectType
 import six
 from ...bases.mutation import MutationBase
@@ -21,10 +20,7 @@ def NodeField(self):
             self.R.Node,
             description='Fetches an object given its ID',
             args={
-                'id': GraphQLArgument(
-                    self.R.ID.NonNull(),
-                    description='The ID of an object'
-                )
+                'id': self.R.ID.NonNull(description='The ID of an object')
             },
             resolver=lambda obj, args, info: self.fetch_node(args.get('id'), info)
         )

epoxy/field.py

@@ -1,5 +1,11 @@
+from collections import OrderedDict
+
 from graphql.core.type import GraphQLField, GraphQLInputObjectField
+
+from .argument import Argument
+from .thunk import TypeThunk
 from .utils.gen_id import gen_id
+from .utils.to_camel_case import to_camel_case
 
 
 class Field(object):
@@ -14,7 +20,31 @@ 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.args, resolver=resolver)
+        return GraphQLField(registry[self.type](), args=self.get_arguments(registry), resolver=resolver)
+
+    def get_arguments(self, registry):
+        if not self.args:
+            return None
+
+        arguments = []
+
+        for k, argument in self.args.items():
+            if isinstance(argument, TypeThunk):
+                argument = Argument(argument, _counter=argument._counter, **(argument._kwargs or {}))
+
+            elif not isinstance(argument, Argument):
+                raise ValueError('Unknown argument value type %r' % argument)
+
+            arguments.append((
+                to_camel_case(k), 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])
 
 
 class InputField(object):

epoxy/registry.py

@@ -58,13 +58,13 @@ class TypeRegistry(object):
     InputField = InputField
 
     def __init__(self):
-        self._registered_types = {}
+        self._registered_types = OrderedDict()
         self._added_impl_types = set()
         self._interface_declared_fields = {}
         self._registered_types_can_be = defaultdict(set)
         self._pending_types_can_be = defaultdict(set)
         self._proxy = ResolvedRegistryProxy(self)
-        self._mutations = {}
+        self._mutations = OrderedDict()
         self.ObjectType = self._create_object_type_class()
         self.InputType = self._create_input_type_class()
         self.Implements = ClassTypeCreator(self, self._create_object_type_class)

tests/test_arguments.py

@@ -0,0 +1,88 @@
+from collections import OrderedDict
+from graphql.core.type import GraphQLString, GraphQLInt, GraphQLID, GraphQLNonNull
+from epoxy.argument import Argument
+from epoxy.registry import TypeRegistry
+
+make_args = lambda R: {
+    'a': R.Int,
+    'b_cool': R.String,
+    'c': R.ID.NonNull,
+    'd': Argument(R.String, default_value="hello world"),
+    'z': R.String(default_value="hello again", description="This is a description"),
+    'x': R.Int(default_value=7),
+    'y': Argument(GraphQLString),
+    'q': R.TestInputType,
+    'w': Argument(R.TestInputType)
+}
+
+make_ordered_dict_args = lambda R: OrderedDict([
+    ('a', R.Int),
+    ('b_cool', R.String),
+    ('c', R.ID.NonNull),
+    ('d', Argument(R.String, default_value="hello world")),
+    ('z', R.String(default_value="hello again", description="This is a description")),
+    ('x', R.Int(default_value=7)),
+    ('y', Argument(GraphQLString)),
+    ('q', R.TestInputType),
+    ('w', Argument(R.TestInputType)),
+])
+
+
+def check_args(test_input_type, args):
+    expected_keys = ['a', 'bCool', 'c', 'd', 'z', 'x', 'y', 'q', 'w']
+    keys = [a.name for a in args]
+
+    assert keys == expected_keys
+
+    a, b, c, d, z, x, y, q, w = args
+
+    assert a.type is GraphQLInt
+    assert b.type is GraphQLString
+    assert isinstance(c.type, GraphQLNonNull)
+    assert c.type.of_type is GraphQLID
+    assert d.type is GraphQLString
+    assert d.default_value == "hello world"
+    assert z.type is GraphQLString
+    assert z.default_value == "hello again"
+    assert z.description == "This is a description"
+    assert x.type is GraphQLInt
+    assert x.default_value == 7
+    assert y.type is GraphQLString
+    assert q.type is test_input_type
+    assert w.type is test_input_type
+
+
+def test_args_will_magically_order():
+    R = TypeRegistry()
+
+    class TestInputType(R.InputType):
+        a = R.Int
+        b = R.Int
+
+    class Query(R.ObjectType):
+        int = R.Int(
+            args=make_args(R)
+        )
+        int_from_field = R.Field(R.Int, args=make_args(R))
+
+    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_args_can_also_use_ordered_dict():
+    R = TypeRegistry()
+
+    class TestInputType(R.InputType):
+        a = R.Int
+        b = R.Int
+
+    class Query(R.ObjectType):
+        int = R.Int(
+            args=make_ordered_dict_args(R)
+        )
+        int_from_field = R.Field(R.Int, args=make_ordered_dict_args(R))
+
+    query_type = R.Query()
+    check_args(TestInputType.T, query_type.get_fields()['int'].args)
+    check_args(TestInputType.T, query_type.get_fields()['intFromField'].args)

tests/test_input_type.py

@@ -46,7 +46,7 @@ class SimpleInput(R.InputType):
 
     class Query(R.ObjectType):
         f = R.String(args={
-            'input': GraphQLArgument(R.SimpleInput())
+            'input': R.SimpleInput
         })
 
         def resolve_f(self, obj, args, info):

tests/test_starwars/schema.py

@@ -22,6 +22,7 @@ def resolve_friends(self, obj, args, info):
         from .data import get_friends
         return get_friends(obj)
 
+
 class Human(R.Implements.Character):
     home_planet = R.String
 
@@ -32,16 +33,16 @@ class Droid(R.Implements.Character):
 
 class Query(R.ObjectType):
     # Args API will change.
-    hero = R.Field(R.Character, args={
-        'episode': GraphQLArgument(R.Episode())
+    hero = R.Character(args={
+        'episode': R.Episode
     })
 
-    human = R.Field(R.Human, args={
-        'id': GraphQLArgument(R.String())
+    human = R.Human(args={
+        'id': R.String
     })
 
-    droid = R.Field(R.Droid, args={
-        'id': GraphQLArgument(R.String())
+    droid = R.Droid(args={
+        'id': R.String
     })
 
     def resolve_hero(self, obj, args, info):