Fix: While querying embedded document with key value as ObjectID

Author: arunsureshkumar

graphene_mongo/fields.py

@@ -5,7 +5,7 @@
 
 import graphene
 import mongoengine
-from bson import DBRef
+from bson import DBRef, ObjectId
 from graphene import Context
 from graphene.types.utils import get_type
 from graphene.utils.str_converters import to_snake_case
@@ -215,7 +215,10 @@ def fields(self):
         self._type = get_type(self._type)
         return self._type._meta.fields
 
-    def get_queryset(self, model, info, required_fields=list(), skip=None, limit=None, reversed=False, **args):
+    def get_queryset(self, model, info, required_fields=None, skip=None, limit=None, reversed=False, **args):
+        if required_fields is None:
+            required_fields = list()
+
         if args:
             reference_fields = get_model_reference_fields(self.model)
             hydrated_references = {}
@@ -276,7 +279,9 @@ def get_queryset(self, model, info, required_fields=list(), skip=None, limit=Non
                     skip)
         return model.objects(**args).no_dereference().only(*required_fields).order_by(self.order_by)
 
-    def default_resolver(self, _root, info, required_fields=list(), **args):
+    def default_resolver(self, _root, info, required_fields=None, **args):
+        if required_fields is None:
+            required_fields = list()
         args = args or {}
         for key, value in dict(args).items():
             if value is None:
@@ -400,39 +405,13 @@ def chained_resolver(self, resolver, is_partial, root, info, **args):
             if isinstance(self.model, mongoengine.Document) or isinstance(self.model,
                                                                           mongoengine.base.metaclasses.TopLevelDocumentMetaclass):
 
-                skip = 0
-                count = 0
-                limit = None
-                reverse = False
-                first = args_copy.get("first")
-                after = args_copy.get("after")
-                if after:
-                    after = cursor_to_offset(after)
-                last = args_copy.get("last")
-                before = args_copy.get("before")
                 for arg_name, arg in args.copy().items():
                     if arg_name not in self.model._fields_ordered + tuple(self.filter_args.keys()):
                         args_copy.pop(arg_name)
                 if isinstance(info, GraphQLResolveInfo):
                     if not info.context:
                         info = info._replace(context=Context())
-                    args_count_copy = args.copy()
-                    for key in args.copy():
-                        if key not in self.model._fields_ordered:
-                            args_count_copy.pop(key)
-                        elif isinstance(getattr(self.model, key),
-                                        mongoengine.fields.ReferenceField) or isinstance(getattr(self.model, key),
-                                                                                         mongoengine.fields.GenericReferenceField) or isinstance(
-                            getattr(self.model, key),
-                            mongoengine.fields.LazyReferenceField) or isinstance(getattr(self.model, key),
-                                                                                 mongoengine.fields.CachedReferenceField):
-                            args_count_copy[key] = from_global_id(args_count_copy[key])[1]
-                    count = mongoengine.get_db()[self.model._get_collection_name()].find(args_count_copy).count()
-                    if count != 0:
-                        skip, limit, reverse = find_skip_and_limit(first=first, after=after, last=last,
-                                                                   before=before,
-                                                                   count=count)
-                    info.context.queryset = self.get_queryset(self.model, info, required_fields, skip, limit, reverse)
+                    info.context.queryset = self.get_queryset(self.model, info, required_fields, **args)
 
             # XXX: Filter nested args
             resolved = resolver(root, info, **args)
@@ -454,7 +433,7 @@ def chained_resolver(self, resolver, is_partial, root, info, **args):
                             if arg_name == '_id' and isinstance(arg, dict):
                                 operation = list(arg.keys())[0]
                                 args_copy['pk' + operation.replace('$', '__')] = arg[operation]
-                            if '.' in arg_name:
+                            if '.' in arg_name and not isinstance(arg, ObjectId):
                                 operation = list(arg.keys())[0]
                                 args_copy[arg_name.replace('.', '__') + operation.replace('$', '__')] = arg[operation]
                         else: