Merge remote-tracking branch 'upstream/master' into graphene-3

Author: ktosiek

docs/filtering.rst

@@ -126,7 +126,7 @@ create your own ``FilterSet``. You can pass it directly as follows:
         all_animals = DjangoFilterConnectionField(AnimalNode,
                                                   filterset_class=AnimalFilter)
 
-You can also specify the ``FilterSet`` class using the ``filerset_class``
+You can also specify the ``FilterSet`` class using the ``filterset_class``
 parameter when defining your ``DjangoObjectType``, however, this can't be used
 in unison  with the ``filter_fields`` parameter:
 
@@ -217,4 +217,4 @@ with this set up, you can now order the users under group:
           xxx
         }
       }
-    }
+    }

graphene_django/__init__.py

@@ -1,6 +1,6 @@
 from .types import DjangoObjectType
 from .fields import DjangoConnectionField
 
-__version__ = "2.5.0"
+__version__ = "2.6.0"
 
 __all__ = ["__version__", "DjangoObjectType", "DjangoConnectionField"]

graphene_django/converter.py

@@ -1,3 +1,4 @@
+from collections import OrderedDict
 from django.db import models
 from django.utils.encoding import force_text
 from django.utils.functional import Promise
@@ -39,6 +40,8 @@ def convert_choice_name(name):
 
 def get_choices(choices):
     converted_names = []
+    if isinstance(choices, OrderedDict):
+        choices = choices.items()
     for value, help_text in choices:
         if isinstance(help_text, (tuple, list)):
             for choice in get_choices(help_text):
@@ -52,6 +55,19 @@ def get_choices(choices):
             yield name, value, description
 
 
+def convert_choices_to_named_enum_with_descriptions(name, choices):
+    choices = list(get_choices(choices))
+    named_choices = [(c[0], c[1]) for c in choices]
+    named_choices_descriptions = {c[0]: c[2] for c in choices}
+
+    class EnumWithDescriptionsType(object):
+        @property
+        def description(self):
+            return named_choices_descriptions[self.name]
+
+    return Enum(name, list(named_choices), type=EnumWithDescriptionsType)
+
+
 def convert_django_field_with_choices(
     field, registry=None, convert_choices_to_enum=True
 ):
@@ -63,16 +79,7 @@ def convert_django_field_with_choices(
     if choices and convert_choices_to_enum:
         meta = field.model._meta
         name = to_camel_case("{}_{}".format(meta.object_name, field.name))
-        choices = list(get_choices(choices))
-        named_choices = [(c[0], c[1]) for c in choices]
-        named_choices_descriptions = {c[0]: c[2] for c in choices}
-
-        class EnumWithDescriptionsType(object):
-            @property
-            def description(self):
-                return named_choices_descriptions[self.name]
-
-        enum = Enum(name, list(named_choices), type=EnumWithDescriptionsType)
+        enum = convert_choices_to_named_enum_with_descriptions(name, choices)
         required = not (field.blank or field.null)
         converted = enum(description=field.help_text, required=required)
     else:
@@ -235,12 +242,12 @@ def convert_postgres_array_to_list(field, registry=None):
 
 @convert_django_field.register(HStoreField)
 @convert_django_field.register(JSONField)
-def convert_posgres_field_to_string(field, registry=None):
+def convert_postgres_field_to_string(field, registry=None):
     return JSONString(description=field.help_text, required=not field.null)
 
 
 @convert_django_field.register(RangeField)
-def convert_posgres_range_to_string(field, registry=None):
+def convert_postgres_range_to_string(field, registry=None):
     inner_type = convert_django_field(field.base_field)
     if not isinstance(inner_type, (List, NonNull)):
         inner_type = type(inner_type)

graphene_django/fields.py

@@ -1,34 +1,58 @@
 from functools import partial
 
 from django.db.models.query import QuerySet
-from graphene import NonNull
 from graphene.relay.connection import page_info_adapter, connection_adapter
 
+from graphql_relay.connection.arrayconnection import connection_from_list_slice
 from promise import Promise
 
-from graphene.types import Field, List
+from graphene import NonNull
 from graphene.relay import ConnectionField
-from graphql_relay.connection.arrayconnection import connection_from_list_slice
+from graphene.types import Field, List
 
 from .settings import graphene_settings
 from .utils import maybe_queryset
 
 
 class DjangoListField(Field):
     def __init__(self, _type, *args, **kwargs):
+        from .types import DjangoObjectType
+
+        if isinstance(_type, NonNull):
+            _type = _type.of_type
+
+        assert issubclass(
+            _type, DjangoObjectType
+        ), "DjangoListField only accepts DjangoObjectType types"
+
         # Django would never return a Set of None  vvvvvvv
         super(DjangoListField, self).__init__(List(NonNull(_type)), *args, **kwargs)
 
     @property
     def model(self):
-        return self.type.of_type._meta.node._meta.model
+        _type = self.type.of_type
+        if isinstance(_type, NonNull):
+            _type = _type.of_type
+        return _type._meta.model
 
     @staticmethod
-    def list_resolver(resolver, root, info, **args):
-        return maybe_queryset(resolver(root, info, **args))
+    def list_resolver(django_object_type, resolver, root, info, **args):
+        queryset = maybe_queryset(resolver(root, info, **args))
+        if queryset is None:
+            # Default to Django Model queryset
+            # N.B. This happens if DjangoListField is used in the top level Query object
+            model = django_object_type._meta.model
+            queryset = maybe_queryset(
+                django_object_type.get_queryset(model.objects, info)
+            )
+        return queryset
 
     def get_resolver(self, parent_resolver):
-        return partial(self.list_resolver, parent_resolver)
+        _type = self.type
+        if isinstance(_type, NonNull):
+            _type = _type.of_type
+        django_object_type = _type.of_type.of_type
+        return partial(self.list_resolver, django_object_type, parent_resolver)
 
 
 class DjangoConnectionField(ConnectionField):

graphene_django/filter/tests/test_fields.py

@@ -56,8 +56,6 @@ class Meta:
             model = Pet
             interfaces = (Node,)
 
-    # schema = Schema()
-
 
 def get_args(field):
     return field.args
@@ -837,6 +835,75 @@ class Query(ObjectType):
     )
 
 
+def test_other_filter_types():
+    class PetType(DjangoObjectType):
+        class Meta:
+            model = Pet
+            interfaces = (Node,)
+            filter_fields = {"age": ["exact", "isnull", "lt"]}
+            fields = ("age",)
+
+    class Query(ObjectType):
+        pets = DjangoFilterConnectionField(PetType)
+
+    schema = Schema(query=Query)
+
+    assert str(schema) == dedent(
+        """\
+        \"""An object with an ID\"""
+        interface Node {
+          \"""The ID of the object\"""
+          id: ID!
+        }
+
+        \"""
+        The Relay compliant `PageInfo` type, containing data necessary to paginate this connection.
+        \"""
+        type PageInfo {
+          \"""When paginating forwards, are there more items?\"""
+          hasNextPage: Boolean!
+        
+          \"""When paginating backwards, are there more items?\"""
+          hasPreviousPage: Boolean!
+
+          \"""When paginating backwards, the cursor to continue.\"""
+          startCursor: String
+
+          \"""When paginating forwards, the cursor to continue.\"""
+          endCursor: String
+        }
+
+        type PetType implements Node {
+          age: Int!
+
+          \"""The ID of the object\"""
+          id: ID!
+        }
+
+        type PetTypeConnection {
+          \"""Pagination data for this connection.\"""
+          pageInfo: PageInfo!
+
+          \"""Contains the nodes in this connection.\"""
+          edges: [PetTypeEdge]!
+        }
+
+        \"""A Relay edge containing a `PetType` and its cursor.\"""
+        type PetTypeEdge {
+          \"""The item at the end of the edge\"""
+          node: PetType
+
+          \"""A cursor for use in pagination\"""
+          cursor: String!
+        }
+
+        type Query {
+          pets(before: String = null, after: String = null, first: Int = null, last: Int = null, age: Int = null, age_Isnull: Boolean = null, age_Lt: Int = null): PetTypeConnection
+        }
+    """
+    )
+
+
 def test_filter_filterset_based_on_mixin():
     class ArticleFilterMixin(FilterSet):
         @classmethod

graphene_django/filter/utils.py

@@ -18,9 +18,16 @@ def get_filtering_args_from_filterset(filterset_class, type):
         if name in filterset_class.declared_filters:
             form_field = filter_field.field
         else:
-            field_name = name.split("__", 1)[0]
-
-            if hasattr(model, field_name):
+            try:
+                field_name, filter_type = name.rsplit("__", 1)
+            except ValueError:
+                field_name = name
+                filter_type = None
+
+            # If the filter type is `isnull` then use the filter provided by
+            # DjangoFilter (a BooleanFilter).
+            # Otherwise try and get a filter based on the actual model field
+            if filter_type != "isnull" and hasattr(model, field_name):
                 model_field = model._meta.get_field(field_name)
 
                 if hasattr(model_field, "formfield"):

graphene_django/rest_framework/serializer_converter.py

@@ -5,6 +5,7 @@
 import graphene
 
 from ..registry import get_global_registry
+from ..converter import convert_choices_to_named_enum_with_descriptions
 from .types import DictType
 
 
@@ -128,7 +129,6 @@ def convert_serializer_field_to_time(field):
 @get_graphene_type_from_serializer_field.register(serializers.ListField)
 def convert_serializer_field_to_list(field, is_input=True):
     child_type = get_graphene_type_from_serializer_field(field.child)
-
     return (graphene.List, child_type)
 
 
@@ -143,5 +143,13 @@ def convert_serializer_field_to_jsonstring(field):
 
 
 @get_graphene_type_from_serializer_field.register(serializers.MultipleChoiceField)
-def convert_serializer_field_to_list_of_string(field):
-    return (graphene.List, graphene.String)
+def convert_serializer_field_to_list_of_enum(field):
+    child_type = convert_serializer_field_to_enum(field)
+    return (graphene.List, child_type)
+
+
+@get_graphene_type_from_serializer_field.register(serializers.ChoiceField)
+def convert_serializer_field_to_enum(field):
+    # enums require a name
+    name = field.field_name or field.source or "Choices"
+    return convert_choices_to_named_enum_with_descriptions(name, field.choices)

graphene_django/rest_framework/tests/test_field_converter.py

@@ -60,8 +60,17 @@ def test_should_url_convert_string():
     assert_conversion(serializers.URLField, graphene.String)
 
 
-def test_should_choice_convert_string():
-    assert_conversion(serializers.ChoiceField, graphene.String, choices=[])
+def test_should_choice_convert_enum():
+    field = assert_conversion(
+        serializers.ChoiceField,
+        graphene.Enum,
+        choices=[("h", "Hello"), ("w", "World")],
+        source="word",
+    )
+    assert field._meta.enum.__members__["H"].value == "h"
+    assert field._meta.enum.__members__["H"].description == "Hello"
+    assert field._meta.enum.__members__["W"].value == "w"
+    assert field._meta.enum.__members__["W"].description == "World"
 
 
 def test_should_base_field_convert_string():
@@ -174,7 +183,7 @@ def test_should_file_convert_string():
 
 
 def test_should_filepath_convert_string():
-    assert_conversion(serializers.FilePathField, graphene.String, path="/")
+    assert_conversion(serializers.FilePathField, graphene.Enum, path="/")
 
 
 def test_should_ip_convert_string():
@@ -189,9 +198,9 @@ def test_should_json_convert_jsonstring():
     assert_conversion(serializers.JSONField, graphene.types.json.JSONString)
 
 
-def test_should_multiplechoicefield_convert_to_list_of_string():
+def test_should_multiplechoicefield_convert_to_list_of_enum():
     field = assert_conversion(
         serializers.MultipleChoiceField, graphene.List, choices=[1, 2, 3]
     )
 
-    assert field.of_type == graphene.String
+    assert issubclass(field.of_type, graphene.Enum)