Merge pull request #28 from graphql-python/feat-filter-by-reference

Feat filter by reference, fixed #25

Author: abawchen

graphene_mongo/fields.py

@@ -11,6 +11,9 @@
 from graphene.types.argument import to_arguments
 
 
+from .utils import get_model_reference_fields
+
+
 # noqa
 class MongoengineListField(Field):
 
@@ -60,26 +63,35 @@ def model(self):
     @property
     def args(self):
         return to_arguments(
-            self._base_args or OrderedDict(), self.default_filter_args
+            self._base_args or OrderedDict(),
+            dict(self.field_args, **self.reference_args)
         )
 
     @args.setter
     def args(self, args):
         self._base_args = args
 
     @property
-    def default_filter_args(self):
+    def field_args(self):
         def is_filterable(kv):
             return hasattr(kv[1], '_type') \
                 and callable(getattr(kv[1]._type, '_of_type', None))
 
         return reduce(
             lambda r, kv: r.update(
                 {kv[0]: kv[1]._type._of_type()}) or r if is_filterable(kv) else r,
-            self.fields.items(),
-            {}
+            self.fields.items(), {}
         )
 
+    @property
+    def reference_args(self):
+        def get_reference_field(r, kv):
+            if callable(getattr(kv[1], 'get_type', None)):
+                node = kv[1].get_type()._type._meta
+                r.update({kv[0]: node.fields['id']._type.of_type()})
+            return r
+        return reduce(get_reference_field, self.fields.items(), {})
+
     @property
     def filter_fields(self):
         return self._type._meta.filter_fields
@@ -95,8 +107,17 @@ def get_query(cls, model, info, **args):
             return []
 
         objs = model.objects()
-
         if args:
+            reference_fields = get_model_reference_fields(model)
+            reference_args = {}
+            for arg_name, arg in args.copy().items():
+                if arg_name in reference_fields:
+                    reference_model = model._fields[arg_name]
+                    pk = from_global_id(args.pop(arg_name))[-1]
+                    reference_obj = reference_model.document_type_obj.objects(pk=pk).get()
+                    reference_args[arg_name] = reference_obj
+
+            args.update(reference_args)
             first = args.pop('first', None)
             last = args.pop('last', None)
             id = args.pop('id', None)
@@ -121,7 +142,7 @@ def get_query(cls, model, info, **args):
             if first is not None:
                 objs = objs[:first]
             if last is not None:
-                # fix for https://github.com/graphql-python/graphene-mongo/issues/20
+                # https://github.com/graphql-python/graphene-mongo/issues/20
                 objs = objs[-(last+1):]
 
         return objs

graphene_mongo/tests/test_fields.py

@@ -0,0 +1,18 @@
+import pytest
+
+from ..fields import MongoengineConnectionField
+from .types import ArticleNode
+
+
+def test_field_args():
+    field = MongoengineConnectionField(ArticleNode)
+
+    field_args = ['id', 'headline', 'pub_date']
+    assert set(field.field_args.keys()) == set(field_args)
+
+    reference_args = ['editor', 'reporter']
+    assert set(field.reference_args.keys()) == set(reference_args)
+
+    default_args = ['after', 'last', 'first', 'before']
+    args = field_args + reference_args + default_args
+    assert set(field.args) == set(args)

graphene_mongo/tests/test_relay_query.py

@@ -295,6 +295,46 @@ class Query(graphene.ObjectType):
     assert result.data == expected
 
 
+def test_should_filter_by_reference_field():
+
+    class Query(graphene.ObjectType):
+        node = Node.Field()
+        articles = MongoengineConnectionField(ArticleNode)
+
+    query = '''
+        query ArticlesQuery {
+            articles(editor: "RWRpdG9yTm9kZTox") {
+                edges {
+                    node {
+                        headline,
+                        editor {
+                            firstName
+                        }
+                    }
+                }
+            }
+        }
+    '''
+    expected = {
+        'articles': {
+            'edges': [
+                {
+                    'node': {
+                        'headline': 'Hello',
+                        'editor': {
+                            'firstName': 'Penny'
+                        }
+                    }
+                }
+            ]
+        }
+    }
+    schema = graphene.Schema(query=Query)
+    result = schema.execute(query)
+    assert not result.errors
+    assert result.data == expected
+
+
 def test_should_filter_through_inheritance():
 
     class Query(graphene.ObjectType):

graphene_mongo/tests/test_utils.py

@@ -5,14 +5,20 @@
 from ..utils import (
     get_model_fields, is_valid_mongoengine_model
 )
-from .models import Reporter, Child
+from .models import Article, Reporter, Child
+
 
 def test_get_model_fields_no_duplication():
     reporter_fields = get_model_fields(Reporter)
     reporter_name_set = set(reporter_fields)
     assert len(reporter_fields) == len(reporter_name_set)
 
 
+def test_get_model_relation_fields():
+    article_fields = get_model_fields(Article)
+    assert all(field in set(article_fields) for field in ['editor', 'reporter'])
+
+
 def test_get_base_model_fields():
     child_fields = get_model_fields(Child)
     assert all(field in set(child_fields) for field in ['bar', 'baz'])

graphene_mongo/utils.py

@@ -5,8 +5,7 @@
 
 
 def get_model_fields(model, excluding=None):
-    if excluding is None:
-        excluding = []
+    excluding = excluding or []
     attributes = dict()
     for attr_name, attr in model._fields.items():
         if attr_name in excluding:
@@ -15,6 +14,17 @@ def get_model_fields(model, excluding=None):
     return OrderedDict(sorted(attributes.items()))
 
 
+def get_model_reference_fields(model, excluding=None):
+    excluding = excluding or []
+    attributes = dict()
+    for attr_name, attr in model._fields.items():
+        if attr_name in excluding \
+                or not isinstance(attr, mongoengine.fields.ReferenceField):
+            continue
+        attributes[attr_name] = attr
+    return attributes
+
+
 def is_valid_mongoengine_model(model):
     return inspect.isclass(model) and (
         issubclass(model, mongoengine.Document) or issubclass(model, mongoengine.EmbeddedDocument)