fix(converter.py): performance fix in convert_field_to_djangomodel.dynamic_type.CustomField. Get instance from the database only one time.

Author: mahdyhamad

graphene_django/converter.py

@@ -1,3 +1,4 @@
+import inspect
 from collections import OrderedDict
 from functools import singledispatch, wraps
 
@@ -25,6 +26,7 @@
 )
 from graphene.types.json import JSONString
 from graphene.types.scalars import BigInt
+from graphene.types.resolver import get_default_resolver
 from graphene.utils.str_converters import to_camel_case
 from graphql import GraphQLError
 
@@ -324,13 +326,49 @@ def wrap_resolve(self, parent_resolver):
                 resolver = super().wrap_resolve(parent_resolver)
 
                 def custom_resolver(root, info, **args):
-                    fk_obj = resolver(root, info, **args)
-                    if not isinstance(fk_obj, model):
+                    # Note: this function is used to resolve FK or 1:1 fields
+                    #   it does not differentiate between custom-resolved fields
+                    #   and default resolved fields.
+
+                    # because this is a django foreign key or one-to-one field, the pk for
+                    # this node can be accessed from the root node.
+                    # ex: article.reporter_id
+
+                    # or get the field name from the model itself to be more precise
+                    fk_object_key = info.field_name + "_id"
+                    if hasattr(root, fk_object_key):
+                        fk_object_id = getattr(root, fk_object_key)
+                    else:
+                        return None
+
+                    is_resolver_awaitable = inspect.iscoroutinefunction(resolver)
+
+                    if is_resolver_awaitable:
+                        fk_obj = resolver(root, info, **args)
                         # In case the resolver is a custom one that overwrites
                         # the default Django resolver
-                        # This happens, for example, when using custom awaitable resolvers.
+                        # In this case, it is a custom awaitable resolver.
+                        return fk_obj
+
+                    instance_from_get_node = _type.get_node(info, fk_object_id)
+
+                    if not instance_from_get_node:
+                        # no instance to return
+                        return
+                    elif resolver is not get_default_resolver():
+                        # Default resolver is overriden
+                        # For optimization, add the instance to the resolver
+                        setattr(root, info.field_name, instance_from_get_node)
+                        # Explanation: previously, `_type.get_node` is called which results in
+                        #   -at least- one hit to the database.
+                        #   But, if we did not pass the instance to the root, calling the resolver will result in
+                        #   another call to get the instance which results in at least two database queries to resolve
+                        #   this node only.
+
+                        fk_obj = resolver(root, info, **args)
                         return fk_obj
-                    return _type.get_node(info, fk_obj.pk)
+                    else:
+                        return instance_from_get_node
 
                 return custom_resolver