Improved resolvers in Django

Author: syrusakbary

graphene/contrib/django/fields.py

@@ -1,28 +1,44 @@
-import warnings
-
 from ...core.exceptions import SkipField
 from ...core.fields import Field
 from ...core.types.base import FieldType
 from ...core.types.definitions import List
 from ...relay import ConnectionField
 from ...relay.utils import is_node
-from .filter.fields import DjangoFilterConnectionField
-from .utils import get_type_for_model
+from .utils import get_type_for_model, maybe_queryset
 
 
 class DjangoConnectionField(ConnectionField):
 
     def __init__(self, *args, **kwargs):
-        cls = self.__class__
-        warnings.warn("Using {} will be not longer supported."
-                      " Use relay.ConnectionField instead".format(cls.__name__),
-                      FutureWarning)
+        self.on = kwargs.pop('on', False)
         return super(DjangoConnectionField, self).__init__(*args, **kwargs)
 
+    @property
+    def model(self):
+        return self.type._meta.model
+
+    def get_manager(self):
+        if self.on:
+            return getattr(self.model, self.on)
+        else:
+            return self.model._default_manager
+
+    def get_queryset(self, resolved_qs, args, info):
+        return resolved_qs
+
+    def from_list(self, connection_type, resolved, args, info):
+        if not resolved:
+            resolved = self.get_manager()
+        resolved_qs = maybe_queryset(resolved)
+        qs = self.get_queryset(resolved_qs, args, info)
+        return super(DjangoConnectionField, self).from_list(connection_type, qs, args, info)
+
 
 class ConnectionOrListField(Field):
 
     def internal_type(self, schema):
+        from .filter.fields import DjangoFilterConnectionField
+
         model_field = self.type
         field_object_type = model_field.get_object_type(schema)
         if not field_object_type:
@@ -31,7 +47,7 @@ def internal_type(self, schema):
             if field_object_type._meta.filter_fields:
                 field = DjangoFilterConnectionField(field_object_type)
             else:
-                field = ConnectionField(field_object_type)
+                field = DjangoConnectionField(field_object_type)
         else:
             field = Field(List(field_object_type))
         field.contribute_to_class(self.object_type, self.attname)

graphene/contrib/django/filter/fields.py

@@ -1,25 +1,36 @@
-from graphene.contrib.django.filter.resolvers import FilterConnectionResolver
-from graphene.contrib.django.utils import get_filtering_args_from_filterset
-from graphene.relay import ConnectionField
+from .utils import get_filterset_class, get_filtering_args_from_filterset
+from ..fields import DjangoConnectionField
 
 
-class DjangoFilterConnectionField(ConnectionField):
+class DjangoFilterConnectionField(DjangoConnectionField):
 
-    def __init__(self, type, on=None, fields=None, order_by=None,
-                 extra_filter_meta=None, filterset_class=None, resolver=None,
+    def __init__(self, type, fields=None, order_by=None,
+                 extra_filter_meta=None, filterset_class=None,
                  *args, **kwargs):
 
-        if not resolver:
-            resolver = FilterConnectionResolver(
-                node=type,
-                on=on,
-                filterset_class=filterset_class,
-                fields=fields,
-                order_by=order_by,
-                extra_filter_meta=extra_filter_meta,
-            )
-
-        filtering_args = get_filtering_args_from_filterset(resolver.get_filterset_class(), type)
+        self.order_by = order_by or type._meta.filter_order_by
+        self.fields = fields or type._meta.filter_fields
+        meta = dict(model=type._meta.model,
+                    fields=self.fields,
+                    order_by=self.order_by)
+        if extra_filter_meta:
+            meta.update(extra_filter_meta)
+        self.filterset_class = get_filterset_class(filterset_class, **meta)
+        self.filtering_args = get_filtering_args_from_filterset(self.filterset_class, type)
         kwargs.setdefault('args', {})
-        kwargs['args'].update(**filtering_args)
-        super(DjangoFilterConnectionField, self).__init__(type, resolver, *args, **kwargs)
+        kwargs['args'].update(**self.filtering_args)
+        super(DjangoFilterConnectionField, self).__init__(type, *args, **kwargs)
+
+    def get_queryset(self, qs, args, info):
+        filterset_class = self.filterset_class
+        filter_kwargs = self.get_filter_kwargs(args)
+        order = self.get_order(args)
+        if order:
+            qs = qs.order_by(order)
+        return filterset_class(data=filter_kwargs, queryset=qs)
+
+    def get_filter_kwargs(self, args):
+        return {k: v for k, v in args.items() if k in self.filtering_args}
+
+    def get_order(self, args):
+        return args.get('order_by', None)

graphene/contrib/django/filter/resolvers.py

@@ -9,7 +9,7 @@
                                            GlobalIDMultipleChoiceField)
 from graphene.contrib.django.tests.models import Article, Pet, Reporter
 from graphene.contrib.django.utils import DJANGO_FILTER_INSTALLED
-from graphene.relay import NodeField
+from graphene.relay import NodeField, ConnectionField
 from graphene.utils import ProxySnakeDict
 
 pytestmark = []
@@ -217,7 +217,7 @@ class Query(ObjectType):
 
 def test_global_id_field_implicit():
     field = DjangoFilterConnectionField(ArticleNode, fields=['id'])
-    filterset_class = field.resolver_fn.get_filterset_class()
+    filterset_class = field.filterset_class
     id_filter = filterset_class.base_filters['id']
     assert isinstance(id_filter, GlobalIDFilter)
     assert id_filter.field_class == GlobalIDFormField
@@ -231,23 +231,23 @@ class Meta:
             fields = ['id']
 
     field = DjangoFilterConnectionField(ArticleNode, filterset_class=ArticleIdFilter)
-    filterset_class = field.resolver_fn.get_filterset_class()
+    filterset_class = field.filterset_class
     id_filter = filterset_class.base_filters['id']
     assert isinstance(id_filter, GlobalIDFilter)
     assert id_filter.field_class == GlobalIDFormField
 
 
 def test_global_id_field_relation():
     field = DjangoFilterConnectionField(ArticleNode, fields=['reporter'])
-    filterset_class = field.resolver_fn.get_filterset_class()
+    filterset_class = field.filterset_class
     id_filter = filterset_class.base_filters['reporter']
     assert isinstance(id_filter, GlobalIDFilter)
     assert id_filter.field_class == GlobalIDFormField
 
 
 def test_global_id_multiple_field_implicit():
     field = DjangoFilterConnectionField(ReporterNode, fields=['pets'])
-    filterset_class = field.resolver_fn.get_filterset_class()
+    filterset_class = field.filterset_class
     multiple_filter = filterset_class.base_filters['pets']
     assert isinstance(multiple_filter, GlobalIDMultipleChoiceFilter)
     assert multiple_filter.field_class == GlobalIDMultipleChoiceField
@@ -261,15 +261,15 @@ class Meta:
             fields = ['pets']
 
     field = DjangoFilterConnectionField(ReporterNode, filterset_class=ReporterPetsFilter)
-    filterset_class = field.resolver_fn.get_filterset_class()
+    filterset_class = field.filterset_class
     multiple_filter = filterset_class.base_filters['pets']
     assert isinstance(multiple_filter, GlobalIDMultipleChoiceFilter)
     assert multiple_filter.field_class == GlobalIDMultipleChoiceField
 
 
 def test_global_id_multiple_field_implicit_reverse():
     field = DjangoFilterConnectionField(ReporterNode, fields=['articles'])
-    filterset_class = field.resolver_fn.get_filterset_class()
+    filterset_class = field.filterset_class
     multiple_filter = filterset_class.base_filters['articles']
     assert isinstance(multiple_filter, GlobalIDMultipleChoiceFilter)
     assert multiple_filter.field_class == GlobalIDMultipleChoiceField
@@ -283,7 +283,7 @@ class Meta:
             fields = ['articles']
 
     field = DjangoFilterConnectionField(ReporterNode, filterset_class=ReporterPetsFilter)
-    filterset_class = field.resolver_fn.get_filterset_class()
+    filterset_class = field.filterset_class
     multiple_filter = filterset_class.base_filters['articles']
     assert isinstance(multiple_filter, GlobalIDMultipleChoiceFilter)
     assert multiple_filter.field_class == GlobalIDMultipleChoiceField

graphene/contrib/django/filter/tests/test_fields.py

@@ -0,0 +1,31 @@
+import six
+
+from .filterset import custom_filterset_factory, setup_filterset
+from ....core.types import Argument, String
+
+
+def get_filtering_args_from_filterset(filterset_class, type):
+    """ Inspect a FilterSet and produce the arguments to pass to
+        a Graphene Field. These arguments will be available to
+        filter against in the GraphQL
+    """
+    from graphene.contrib.django.form_converter import convert_form_field
+
+    args = {}
+    for name, filter_field in six.iteritems(filterset_class.base_filters):
+        field_type = Argument(convert_form_field(filter_field.field))
+        args[name] = field_type
+
+    # Also add the 'order_by' field
+    if filterset_class._meta.order_by:
+        args[filterset_class.order_by_field] = Argument(String())
+    return args
+
+
+def get_filterset_class(filterset_class, **meta):
+    """Get the class to be used as the FilterSet"""
+    if filterset_class:
+        # If were given a FilterSet class, then set it up and
+        # return it
+        return setup_filterset(filterset_class)
+    return custom_filterset_factory(**meta)