Union, Field argument

Author: dittos

graphql/api.py

@@ -81,19 +81,38 @@ def __init__(self, typerefspec, args=None, resolver=None,
         self.description = description
 
     def resolve(self, schema):
+        args = {}
+        if self.args:
+            for arg_name, arg in self.args.items():
+                args[arg_name] = arg.resolve(schema)
         return graphql.type.GraphQLField(
             self.typeref.resolve(schema),
-            self.args, self.resolver, self.deprecation_reason, self.description
+            args, self.resolver, self.deprecation_reason, self.description
+        )
+
+
+class LazyArgument(object):
+    def __init__(self, typerefspec, default_value=None, description=None):
+        self.typeref = build_typeref(typerefspec)
+        self.default_value = default_value
+        self.description = description
+
+    def resolve(self, schema):
+        return graphql.type.GraphQLArgument(
+            self.typeref.resolve(schema),
+            self.default_value, self.description
         )
 
 
 class Schema(object):
     String = InternalTypeRef(graphql.type.GraphQLString)
     Int = InternalTypeRef(graphql.type.GraphQLInt)
     Float = InternalTypeRef(graphql.type.GraphQLFloat)
+    Boolean = InternalTypeRef(graphql.type.GraphQLBoolean)
     ID = InternalTypeRef(graphql.type.GraphQLID)
 
     Field = LazyField
+    Argument = LazyArgument
     EnumValue = graphql.type.GraphQLEnumValue
 
     def __init__(self):
@@ -108,6 +127,7 @@ def __init__(self):
 
         self.EnumType = self._build_type_definer(self._define_enum)
         self.InterfaceType = self._build_type_definer(self._define_interface)
+        self.UnionType = self._build_type_definer(self._define_union)
         self.ObjectType = self._build_type_definer(self._define_object)
         self.QueryRoot = self._build_type_definer(self._define_query_root)
         self.MutationRoot = self._build_type_definer(self._define_mutation_root)
@@ -134,6 +154,15 @@ def _define_interface(self, dct):
             description=dct.get('__doc__'),
         )
 
+    def _define_union(self, dct):
+        types = [self._public_types[public_type] for public_type in dct['types']]
+        return graphql.type.GraphQLUnionType(
+            name=dct['__typename__'],
+            types=types,
+            resolve_type=dct.get('resolve_type'),
+            description=dct.get('__doc__'),
+        )
+
     def _define_object(self, dct):
         fields = {}
         for k, v in dct.items():

tests/test_api.py

@@ -146,6 +146,56 @@ class QueryRoot(gql.QueryRoot):
     })
 
 
+def test_field_arguments():
+    gql = Schema()
+
+    class A(gql.ObjectType):
+        pass
+
+    class QueryRoot(gql.QueryRoot):
+        field = gql.Field(gql.String, {
+            'byPublicType': gql.Argument(A),
+            'byName': gql.Argument('A'),
+            'byInternalType': gql.Argument(gql.String),
+            'byPublicTypeWrapped': gql.Argument(gql.List(A)),
+            'byNameWrapped': gql.Argument(gql.List('A')),
+            'byInternalTypeWrapped': gql.Argument(gql.List(gql.String)),
+        })
+
+    result = graphql(gql.to_internal(), '''{
+        type: __type(name: "QueryRoot") {
+            fields {
+                args {
+                    name
+                    type { ...TypeRef }
+                }
+            }
+        }
+    }
+    fragment TypeRef on __Type {
+        kind, name
+        ofType {
+            kind, name
+            ofType { kind, name, ofType }
+        }
+    }''')
+    assert not result.errors
+    a_type = {"kind": "OBJECT", "name": "A", "ofType": None}
+    string_type = {"kind": "SCALAR", "name": "String", "ofType": None}
+    assert sort_lists(result.data) == sort_lists({
+        "type": {
+            "fields": [{"args": [
+                {"name": "byPublicType", "type": a_type},
+                {"name": "byName", "type": a_type},
+                {"name": "byInternalType", "type": string_type},
+                {"name": "byPublicTypeWrapped", "type": {"kind": "LIST", "name": None, "ofType": a_type}},
+                {"name": "byNameWrapped", "type": {"kind": "LIST", "name": None, "ofType": a_type}},
+                {"name": "byInternalTypeWrapped", "type": {"kind": "LIST", "name": None, "ofType": string_type}},
+            ]}]
+        }
+    })
+
+
 def test_prevent_defining_many_query_roots():
     gql = Schema()
 
@@ -155,3 +205,42 @@ class QueryRoot(gql.QueryRoot):
     with raises(Exception):
         class SecondQueryRoot(gql.QueryRoot):
             pass
+
+
+def test_define_union_type():
+    gql = Schema()
+
+    class A(gql.ObjectType):
+        pass
+
+    class B(gql.ObjectType):
+        pass
+
+    class UnionType(gql.UnionType):
+        """description"""
+        __typename__ = 'Union'
+        types = [A, B]
+
+    class QueryRoot(gql.QueryRoot):
+        union = gql.Field(UnionType)
+
+    result = graphql(gql.to_internal(), '''{
+        type: __type(name: "Union") {
+            kind
+            name
+            description
+            possibleTypes { name }
+        }
+    }''')
+    assert not result.errors
+    assert sort_lists(result.data) == sort_lists({
+        "type": {
+            "name": "Union",
+            "description": "description",
+            "kind": "UNION",
+            "possibleTypes": [
+                {"name": "A"},
+                {"name": "B"},
+                ]
+        }
+    })