Feature: Add DjangoInstanceField to allow reuse queryset on DjangoObjectType

graphene_django/converter.py

@@ -30,7 +30,7 @@
 from graphql.pyutils import register_description
 
 from .compat import ArrayField, HStoreField, JSONField, PGJSONField, RangeField
-from .fields import DjangoListField, DjangoConnectionField
+from .fields import DjangoListField, DjangoConnectionField, DjangoInstanceField
 from .settings import graphene_settings
 from .utils.str_converters import to_const
 
@@ -230,23 +230,6 @@ def convert_time_to_string(field, registry=None):
     )
 
 
-@convert_django_field.register(models.OneToOneRel)
-def convert_onetoone_field_to_djangomodel(field, registry=None):
-    model = field.related_model
-
-    def dynamic_type():
-        _type = registry.get_type_for_model(model)
-        if not _type:
-            return
-
-        # We do this for a bug in Django 1.8, where null attr
-        # is not available in the OneToOneRel instance
-        null = getattr(field, "null", True)
-        return Field(_type, required=not null)
-
-    return Dynamic(dynamic_type)
-
-
 @convert_django_field.register(models.ManyToManyField)
 @convert_django_field.register(models.ManyToManyRel)
 @convert_django_field.register(models.ManyToOneRel)
@@ -289,6 +272,7 @@ def dynamic_type():
 
 @convert_django_field.register(models.OneToOneField)
 @convert_django_field.register(models.ForeignKey)
+@convert_django_field.register(models.OneToOneRel)
 def convert_field_to_djangomodel(field, registry=None):
     model = field.related_model
 
@@ -297,10 +281,16 @@ def dynamic_type():
         if not _type:
             return
 
-        return Field(
+        if isinstance(field, models.OneToOneRel):
+            description = get_django_field_description(field.field)
+        else:
+            description = get_django_field_description(field)
+
+        return DjangoInstanceField(
             _type,
-            description=get_django_field_description(field),
+            description=description,
             required=not field.null,
+            is_foreign_key=True,
         )
 
     return Dynamic(dynamic_type)

graphene_django/fields.py

@@ -246,3 +246,105 @@ def wrap_resolve(self, parent_resolver):
 
     def get_queryset_resolver(self):
         return self.resolve_queryset
+
+
+class DjangoInstanceField(Field):
+    def __init__(self, _type, *args, **kwargs):
+        from .types import DjangoObjectType
+
+        self.unique_fields = kwargs.pop("unique_fields", ("id",))
+        self.is_foreign_key = kwargs.pop("is_foreign_key", False)
+
+        assert not isinstance(
+            self.unique_fields, list
+        ), "unique_fields argument needs to be a list"
+
+        if isinstance(_type, NonNull):
+            _type = _type.of_type
+
+        super(DjangoInstanceField, self).__init__(_type, *args, **kwargs)
+
+        assert issubclass(
+            self._underlying_type, DjangoObjectType
+        ), "DjangoInstanceField only accepts DjangoObjectType types"
+
+    @property
+    def _underlying_type(self):
+        _type = self._type
+        while hasattr(_type, "of_type"):
+            _type = _type.of_type
+        return _type
+
+    @property
+    def model(self):
+        return self._underlying_type._meta.model
+
+    def get_manager(self):
+        return self.model._default_manager
+
+    @staticmethod
+    def instance_resolver(
+        django_object_type,
+        unique_fields,
+        resolver,
+        default_manager,
+        is_foreign_key,
+        root,
+        info,
+        **args
+    ):
+
+        queryset = None
+        unique_filter = {}
+        if is_foreign_key:
+            pk_name = "{}_id".format(info.field_name)
+            pk = None
+            if hasattr(root, pk_name):
+                pk = getattr(root, pk_name)
+            else:
+                fk_obj = getattr(root, info.field_name)
+                if fk_obj:
+                    pk = fk_obj.pk
+
+            if pk is not None:
+                unique_filter["pk"] = pk
+                unique_fields = ()
+            else:
+                return None
+        else:
+            queryset = maybe_queryset(resolver(root, info, **args))
+
+        if queryset is None:
+            queryset = maybe_queryset(default_manager)
+
+        if isinstance(queryset, QuerySet):
+            # Pass queryset to the DjangoObjectType get_queryset method
+            queryset = maybe_queryset(django_object_type.get_queryset(queryset, info))
+            for field in unique_fields:
+                key = field if field != "id" else "pk"
+                value = args.get(field)
+
+                if value is not None:
+                    unique_filter[key] = value
+
+            assert len(unique_filter.keys()) > 0, (
+                "You need to model unique arguments. The declared unique fields are: {}."
+            ).format(", ".join(unique_fields))
+
+            try:
+                return queryset.get(**unique_filter)
+            except django_object_type._meta.model.DoesNotExist:
+                return None
+
+        return queryset
+
+    def wrap_resolve(self, parent_resolver):
+        resolver = super(DjangoInstanceField, self).wrap_resolve(parent_resolver)
+        return partial(
+            self.instance_resolver,
+            self._underlying_type,
+            self.unique_fields,
+            resolver,
+            self.get_manager(),
+            self.is_foreign_key,
+        )

graphene_django/tests/models.py

@@ -13,6 +13,9 @@ class Person(models.Model):
 class Pet(models.Model):
     name = models.CharField(max_length=30)
     age = models.PositiveIntegerField()
+    owner = models.ForeignKey(
+        "Person", on_delete=models.CASCADE, null=True, blank=True, related_name="pets"
+    )
 
 
 class FilmDetails(models.Model):
@@ -91,8 +94,8 @@ class Meta:
 
 class Article(models.Model):
     headline = models.CharField(max_length=100)
-    pub_date = models.DateField()
-    pub_date_time = models.DateTimeField()
+    pub_date = models.DateField(auto_now_add=True)
+    pub_date_time = models.DateTimeField(auto_now_add=True)
     reporter = models.ForeignKey(
         Reporter, on_delete=models.CASCADE, related_name="articles"
     )

graphene_django/tests/test_fields.py

@@ -5,7 +5,7 @@
 
 from graphene import List, NonNull, ObjectType, Schema, String
 
-from ..fields import DjangoListField
+from ..fields import DjangoListField, DjangoInstanceField
 from ..types import DjangoObjectType
 from .models import Article as ArticleModel
 from .models import Reporter as ReporterModel
@@ -302,6 +302,149 @@ def resolve_reporters(_, info):
         assert not result.errors
         assert result.data == {"reporters": [{"firstName": "Tara"}]}
 
+    def test_get_queryset_filter_instance(self):
+        """Resolving prefilter list to get instance"""
+
+        class Reporter(DjangoObjectType):
+            class Meta:
+                model = ReporterModel
+                fields = ("first_name", "articles")
+
+            @classmethod
+            def get_queryset(cls, queryset, info):
+                # Only get reporters with at least 1 article
+                return queryset.annotate(article_count=Count("articles")).filter(
+                    article_count__gt=0
+                )
+
+        class Query(ObjectType):
+            reporter = DjangoInstanceField(
+                Reporter,
+                unique_fields=("first_name",),
+                first_name=String(required=True),
+            )
+
+        schema = Schema(query=Query)
+
+        query = """
+            query {
+                reporter(firstName: "Tara") {
+                    firstName
+                }
+            }
+        """
+
+        r1 = ReporterModel.objects.create(first_name="Tara", last_name="West")
+        ReporterModel.objects.create(first_name="Debra", last_name="Payne")
+
+        ArticleModel.objects.create(
+            headline="Amazing news",
+            reporter=r1,
+            pub_date=datetime.date.today(),
+            pub_date_time=datetime.datetime.now(),
+            editor=r1,
+        )
+
+        result = schema.execute(query)
+
+        assert not result.errors
+        assert result.data == {"reporter": {"firstName": "Tara"}}
+
+    def test_get_queryset_filter_instance_null(self):
+        """Resolving prefilter list with no results"""
+
+        class Reporter(DjangoObjectType):
+            class Meta:
+                model = ReporterModel
+                fields = ("first_name", "articles")
+
+            @classmethod
+            def get_queryset(cls, queryset, info):
+                # Only get reporters with at least 1 article
+                return queryset.annotate(article_count=Count("articles")).filter(
+                    article_count__gt=0
+                )
+
+        class Query(ObjectType):
+            reporter = DjangoInstanceField(
+                Reporter,
+                unique_fields=("first_name",),
+                first_name=String(required=True),
+            )
+
+        schema = Schema(query=Query)
+
+        query = """
+            query {
+                reporter(firstName: "Debra") {
+                    firstName
+                }
+            }
+        """
+
+        r1 = ReporterModel.objects.create(first_name="Tara", last_name="West")
+        ReporterModel.objects.create(first_name="Debra", last_name="Payne")
+
+        ArticleModel.objects.create(
+            headline="Amazing news",
+            reporter=r1,
+            pub_date=datetime.date.today(),
+            pub_date_time=datetime.datetime.now(),
+            editor=r1,
+        )
+
+        result = schema.execute(query)
+
+        assert not result.errors
+        assert result.data == {"reporter": None}
+
+    def test_get_queryset_filter_instance_plain(self):
+        """Resolving a plain object should work (and not call get_queryset)"""
+
+        class Reporter(DjangoObjectType):
+            class Meta:
+                model = ReporterModel
+                fields = ("first_name", "articles")
+
+            @classmethod
+            def get_queryset(cls, queryset, info):
+                # Only get reporters with at least 1 article
+                return queryset.annotate(article_count=Count("articles")).filter(
+                    article_count__gt=0
+                )
+
+        class Query(ObjectType):
+            reporter = DjangoInstanceField(Reporter, first_name=String(required=True))
+
+            def resolve_reporter(_, info, first_name):
+                return ReporterModel.objects.get(first_name=first_name)
+
+        schema = Schema(query=Query)
+
+        query = """
+            query {
+                reporter(firstName: "Debra") {
+                    firstName
+                }
+            }
+        """
+
+        r1 = ReporterModel.objects.create(first_name="Tara", last_name="West")
+        ReporterModel.objects.create(first_name="Debra", last_name="Payne")
+
+        ArticleModel.objects.create(
+            headline="Amazing news",
+            reporter=r1,
+            pub_date=datetime.date.today(),
+            pub_date_time=datetime.datetime.now(),
+            editor=r1,
+        )
+
+        result = schema.execute(query)
+
+        assert not result.errors
+        assert result.data == {"reporter": {"firstName": "Debra"}}
+
     def test_resolve_list(self):
         """Resolving a plain list should work (and not call get_queryset)"""