Implemented cross checking for defined resolver before assigning default resolver for Reference, Generic Reference & Lazy Reference fields

Author: arunsureshkumar

graphene_mongo/converter.py

@@ -113,7 +113,7 @@ def get_reference_objects(*args, **kwargs):
                     document_field = convert_mongoengine_field(document_field, registry)
                     document_field_type = document_field.get_type().type._meta.name
                     required_fields = [to_snake_case(i) for i in
-                                   get_query_fields(args[0][3][0])[document_field_type].keys()]
+                                       get_query_fields(args[0][3][0])[document_field_type].keys()]
                     return document.objects().no_dereference().only(*required_fields).filter(pk__in=args[0][1])
                 else:
                     return []
@@ -221,7 +221,12 @@ def reference_resolver(root, *args, **kwargs):
         return None
 
     if isinstance(field, mongoengine.GenericReferenceField):
-        return graphene.Field(_union, resolver=reference_resolver,
+        field_resolver = None
+        if field.db_field is not None:
+            resolver_function = getattr(_union, "resolve_" + field.db_field, None)
+            if resolver_function and callable(resolver_function):
+                field_resolver = resolver_function
+        return graphene.Field(_union, resolver=field_resolver if field_resolver else reference_resolver,
                               description=get_field_description(field, registry))
 
     return graphene.Field(_union)
@@ -238,7 +243,7 @@ def reference_resolver(root, *args, **kwargs):
         if document:
             _type = registry.get_type_for_model(field.document_type)
             required_fields = _type._meta.required_fields.split(",") if isinstance(_type._meta.required_fields,
-                                                                           str) else list()
+                                                                                   str) else list()
             return field.document_type.objects().no_dereference().only(
                 *((list(set(required_fields + [to_snake_case(i) for i in get_query_fields(args[0]).keys()]))))).get(
                 pk=document.id)
@@ -248,7 +253,7 @@ def cached_reference_resolver(root, *args, **kwargs):
         if field:
             _type = registry.get_type_for_model(field.document_type)
             required_fields = _type._meta.required_fields.split(",") if isinstance(_type._meta.required_fields,
-                                                                           str) else list()
+                                                                                   str) else list()
             return field.document_type.objects().no_dereference().only(
                 *(list(set(required_fields + [to_snake_case(i) for i in get_query_fields(args[0]).keys()]))
                   )).get(
@@ -259,14 +264,20 @@ def dynamic_type():
         _type = registry.get_type_for_model(model)
         if not _type:
             return None
-        elif isinstance(field, mongoengine.ReferenceField):
-            return graphene.Field(_type, resolver=reference_resolver,
+        if isinstance(field, mongoengine.EmbeddedDocumentField):
+            return graphene.Field(_type,
                                   description=get_field_description(field, registry))
-        elif isinstance(field, mongoengine.CachedReferenceField):
-            return graphene.Field(_type, resolver=cached_reference_resolver,
+        field_resolver = None
+        if field.db_field is not None:
+            resolver_function = getattr(_type, "resolve_" + field.db_field, None)
+            if resolver_function and callable(resolver_function):
+                field_resolver = resolver_function
+        if isinstance(field, mongoengine.ReferenceField):
+            return graphene.Field(_type, resolver=field_resolver if field_resolver else reference_resolver,
+                                  description=get_field_description(field, registry))
+        else:
+            return graphene.Field(_type, resolver=field_resolver if field_resolver else cached_reference_resolver(),
                                   description=get_field_description(field, registry))
-        return graphene.Field(_type,
-                              description=get_field_description(field, registry))
 
     return graphene.Dynamic(dynamic_type)
 
@@ -280,20 +291,24 @@ def lazy_resolver(root, *args, **kwargs):
         if document:
             _type = registry.get_type_for_model(document.document_type)
             required_fields = _type._meta.required_fields.split(",") if isinstance(_type._meta.required_fields,
-                                                                           str) else list()
+                                                                                   str) else list()
             return document.document_type.objects().no_dereference().only(
                 *(list(set((required_fields + [to_snake_case(i) for i in get_query_fields(args[0]).keys()]))))).get(
                 pk=document.pk)
         return None
 
     def dynamic_type():
         _type = registry.get_type_for_model(model)
-
         if not _type:
             return None
+        field_resolver = None
+        if field.db_field is not None:
+            resolver_function = getattr(_type, "resolve_" + field.db_field, None)
+            if resolver_function and callable(resolver_function):
+                field_resolver = resolver_function
         return graphene.Field(
             _type,
-            resolver=lazy_resolver,
+            resolver=field_resolver if field_resolver else lazy_resolver,
             description=get_field_description(field, registry),
         )