Feat nested relay query

graphene_mongo/fields.py

@@ -135,6 +135,7 @@ def get_queryset(self, model, info, **args):
                     reference_obj = get_node_from_global_id(reference_fields[arg_name], info, args.pop(arg_name))
                     hydrated_references[arg_name] = reference_obj
             args.update(hydrated_references)
+
         if self._get_queryset:
             queryset_or_filters = self._get_queryset(model, info, **args)
             if isinstance(queryset_or_filters, mongoengine.QuerySet):
@@ -178,12 +179,15 @@ def default_resolver(self, _root, info, **args):
         return connection
 
     def chained_resolver(self, resolver, root, info, **args):
-        resolved = resolver(root, info, **args)
-        if resolved is not None:
-            return resolved
+        if not bool(args):
+            # XXX: Filter nested args
+            resolved = resolver(root, info, **args)
+            if resolved is not None:
+                return resolved
         return self.default_resolver(root, info, **args)
 
     def get_resolver(self, parent_resolver):
         super_resolver = self.resolver or parent_resolver
+        # print('super_resolver', super_resolver)
         resolver = partial(self.chained_resolver, super_resolver)
         return partial(self.connection_resolver, resolver, self.type)

graphene_mongo/tests/setup.py

@@ -57,6 +57,9 @@ def fixtures():
     article2 = Article(headline='World', editor=editor2, pub_date=pub_date)
     article2.save()
 
+    article3 = Article(headline='Bye', editor=editor2, pub_date=pub_date)
+    article3.save()
+
     Reporter.drop_collection()
     reporter1 = Reporter(
         id='1',

graphene_mongo/tests/test_fields.py

@@ -57,4 +57,4 @@ def test_default_resolver_connection_list_length(fixtures):
 
     connection = field.default_resolver(None, {}, **{'first': 1})
     assert hasattr(connection, 'list_length')
-    assert connection.list_length == 2
+    assert connection.list_length == 3

graphene_mongo/tests/test_relay_query.py

@@ -25,7 +25,6 @@ def get_nodes(data, key):
 def test_should_query_reporter(fixtures):
 
     class Query(graphene.ObjectType):
-        node = Node.Field()
         reporter = graphene.Field(ReporterNode)
 
         def resolve_reporter(self, *args, **kwargs):
@@ -126,18 +125,74 @@ def resolve_reporter(self, *args, **kwargs):
     schema = graphene.Schema(query=Query)
     result = schema.execute(query)
     assert not result.errors
-    assert dict(result.data['reporter']) == expected['reporter']
+    assert result.data['reporter'] == expected['reporter']
+
+
+def test_should_query_reporters_with_nested_document(fixtures):
+
+    class Query(graphene.ObjectType):
+        reporters = MongoengineConnectionField(ReporterNode)
+
+    query = '''
+        query ReporterQuery {
+            reporters(firstName: "Allen") {
+                edges {
+                    node {
+                        firstName,
+                        lastName,
+                        email,
+                        articles(headline: "Hello") {
+                             edges {
+                                  node {
+                                       headline
+                                  }
+                             }
+                        }
+                    }
+                }
+            }
+        }
+    '''
+    expected = {
+        'reporters': {
+            'edges': [
+                {
+                    'node': {
+                        'firstName': 'Allen',
+                        'lastName': 'Iverson',
+                        'email': '[email protected]',
+                        'articles': {
+                            'edges': [
+                                {
+                                    'node': {
+                                        'headline': 'Hello'
+                                    }
+                                }
+                            ]
+                        }
+                    }
+                }
+            ]
+        }
+    }
+
+    # print(query, expected)
+    schema = graphene.Schema(query=Query)
+    result = schema.execute(query)
+    assert not result.errors
+    # import json
+    # print(json.dumps(result.data['reporters']))
+    assert result.data['reporters'] == expected['reporters']
 
 
 def test_should_query_all_editors(fixtures, fixtures_dirname):
 
     class Query(graphene.ObjectType):
-        node = Node.Field()
-        all_editors = MongoengineConnectionField(EditorNode)
+        editors = MongoengineConnectionField(EditorNode)
 
     query = '''
         query EditorQuery {
-          allEditors {
+          editors {
             edges {
                 node {
                     id,
@@ -159,7 +214,7 @@ class Query(graphene.ObjectType):
         data = base64.b64encode(f.read())
 
     expected = {
-        'allEditors': {
+        'editors': {
             'edges': [
                 {
                     'node': {
@@ -204,7 +259,7 @@ class Query(graphene.ObjectType):
     schema = graphene.Schema(query=Query)
     result = schema.execute(query)
     assert not result.errors
-    assert result.data['allEditors'] == expected['allEditors']
+    assert result.data['editors'] == expected['editors']
 
 
 def test_should_filter_editors_by_id(fixtures):