Removed conflict of only_fields by introducing required_fields

Author: arunsureshkumar

graphene_mongo/converter.py

@@ -112,9 +112,9 @@ def get_reference_objects(*args, **kwargs):
                     document_field = mongoengine.ReferenceField(document)
                     document_field = convert_mongoengine_field(document_field, registry)
                     document_field_type = document_field.get_type().type._meta.name
-                    only_fields = [to_snake_case(i) for i in
+                    required_fields = [to_snake_case(i) for i in
                                    get_query_fields(args[0][3][0])[document_field_type].keys()]
-                    return document.objects().no_dereference().only(*only_fields).filter(pk__in=args[0][1])
+                    return document.objects().no_dereference().only(*required_fields).filter(pk__in=args[0][1])
                 else:
                     return []
 
@@ -237,20 +237,20 @@ def reference_resolver(root, *args, **kwargs):
         document = getattr(root, field.name or field.db_name)
         if document:
             _type = registry.get_type_for_model(field.document_type)
-            only_fields = _type._meta.only_fields.split(",") if isinstance(_type._meta.only_fields,
+            required_fields = _type._meta.required_fields.split(",") if isinstance(_type._meta.required_fields,
                                                                            str) else list()
             return field.document_type.objects().no_dereference().only(
-                *((list(set(only_fields + [to_snake_case(i) for i in get_query_fields(args[0]).keys()]))))).get(
+                *((list(set(required_fields + [to_snake_case(i) for i in get_query_fields(args[0]).keys()]))))).get(
                 pk=document.id)
         return None
 
     def cached_reference_resolver(root, *args, **kwargs):
         if field:
             _type = registry.get_type_for_model(field.document_type)
-            only_fields = _type._meta.only_fields.split(",") if isinstance(_type._meta.only_fields,
+            required_fields = _type._meta.required_fields.split(",") if isinstance(_type._meta.required_fields,
                                                                            str) else list()
             return field.document_type.objects().no_dereference().only(
-                *(list(set(only_fields + [to_snake_case(i) for i in get_query_fields(args[0]).keys()]))
+                *(list(set(required_fields + [to_snake_case(i) for i in get_query_fields(args[0]).keys()]))
                   )).get(
                 pk=getattr(root, field.name or field.db_name))
         return None
@@ -279,10 +279,10 @@ def lazy_resolver(root, *args, **kwargs):
         document = getattr(root, field.name or field.db_name)
         if document:
             _type = registry.get_type_for_model(document.document_type)
-            only_fields = _type._meta.only_fields.split(",") if isinstance(_type._meta.only_fields,
+            required_fields = _type._meta.required_fields.split(",") if isinstance(_type._meta.required_fields,
                                                                            str) else list()
             return document.document_type.objects().no_dereference().only(
-                *(list(set((only_fields + [to_snake_case(i) for i in get_query_fields(args[0]).keys()]))))).get(
+                *(list(set((required_fields + [to_snake_case(i) for i in get_query_fields(args[0]).keys()]))))).get(
                 pk=document.pk)
         return None
 

graphene_mongo/fields.py

@@ -64,10 +64,8 @@ def order_by(self):
         return self.node_type._meta.order_by
 
     @property
-    def only_fields(self):
-        if isinstance(self.node_type._meta.only_fields, str):
-            return self.node_type._meta.only_fields.split(",")
-        return list()
+    def required_fields(self):
+        return tuple(set(self.node_type._meta.required_fields + self.node_type._meta.only_fields))
 
     @property
     def registry(self):
@@ -190,7 +188,7 @@ def get_reference_field(r, kv):
     def fields(self):
         return self._type._meta.fields
 
-    def get_queryset(self, model, info, only_fields=list(), **args):
+    def get_queryset(self, model, info, required_fields=list(), **args):
         if args:
             reference_fields = get_model_reference_fields(self.model)
             hydrated_references = {}
@@ -209,9 +207,9 @@ def get_queryset(self, model, info, only_fields=list(), **args):
             else:
                 args.update(queryset_or_filters)
 
-        return model.objects(**args).no_dereference().only(*only_fields).order_by(self.order_by)
+        return model.objects(**args).no_dereference().only(*required_fields).order_by(self.order_by)
 
-    def default_resolver(self, _root, info, only_fields=list(), **args):
+    def default_resolver(self, _root, info, required_fields=list(), **args):
         args = args or {}
 
         if _root is not None:
@@ -232,7 +230,7 @@ def default_resolver(self, _root, info, only_fields=list(), **args):
             args['pk'] = from_global_id(_id)[-1]
 
         if callable(getattr(self.model, "objects", None)):
-            iterables = self.get_queryset(self.model, info, only_fields, **args)
+            iterables = self.get_queryset(self.model, info, required_fields, **args)
             if isinstance(info, ResolveInfo):
                 if not info.context:
                     info.context = Context()
@@ -256,13 +254,13 @@ def default_resolver(self, _root, info, only_fields=list(), **args):
         return connection
 
     def chained_resolver(self, resolver, is_partial, root, info, **args):
-        only_fields = list()
-        for field in self.only_fields:
+        required_fields = list()
+        for field in self.required_fields:
             if field in self.model._fields_ordered:
-                only_fields.append(field)
+                required_fields.append(field)
         for field in get_query_fields(info):
             if to_snake_case(field) in self.model._fields_ordered:
-                only_fields.append(to_snake_case(field))
+                required_fields.append(to_snake_case(field))
         if not bool(args) or not is_partial:
             if isinstance(self.model, mongoengine.Document) or isinstance(self.model,
                                                                           mongoengine.base.metaclasses.TopLevelDocumentMetaclass):
@@ -273,7 +271,7 @@ def chained_resolver(self, resolver, is_partial, root, info, **args):
                 if isinstance(info, ResolveInfo):
                     if not info.context:
                         info.context = Context()
-                    info.context.queryset = self.get_queryset(self.model, info, only_fields, **args_copy)
+                    info.context.queryset = self.get_queryset(self.model, info, required_fields, **args_copy)
             # XXX: Filter nested args
             resolved = resolver(root, info, **args)
             if resolved is not None:
@@ -284,7 +282,7 @@ def chained_resolver(self, resolver, is_partial, root, info, **args):
                         return resolved
                 else:
                     return resolved
-        return self.default_resolver(root, info, only_fields, **args)
+        return self.default_resolver(root, info, required_fields, **args)
 
     @classmethod
     def connection_resolver(cls, resolver, connection_type, root, info, **args):

graphene_mongo/types.py

@@ -13,7 +13,7 @@
 from .utils import get_model_fields, is_valid_mongoengine_model, get_query_fields
 
 
-def construct_fields(model, registry, only_fields, exclude_fields):
+def construct_fields(model, registry, required_fields, exclude_fields):
     """
     Args:
         model (mongoengine.Document):
@@ -29,10 +29,10 @@ def construct_fields(model, registry, only_fields, exclude_fields):
     fields = OrderedDict()
     self_referenced = OrderedDict()
     for name, field in _model_fields.items():
-        is_not_in_only = only_fields and name not in only_fields
+        is_not_in_only = required_fields and name not in required_fields
         is_excluded = name in exclude_fields
         if is_not_in_only or is_excluded:
-            # We skip this field if we specify only_fields and is not
+            # We skip this field if we specify required_fields and is not
             # in there. Or when we exclude this field in exclude_fields
             continue
         if isinstance(field, mongoengine.ListField):
@@ -83,6 +83,7 @@ def __init_subclass_with_meta__(
         registry=None,
         skip_registry=False,
         only_fields=(),
+        required_fields=(),
         exclude_fields=(),
         filter_fields=None,
         connection=None,
@@ -157,6 +158,7 @@ def __init_subclass_with_meta__(
         _meta.connection_field_class = connection_field_class
         # Save them for later
         _meta.only_fields = only_fields
+        _meta.required_fields = required_fields
         _meta.exclude_fields = exclude_fields
         _meta.order_by = order_by
 
@@ -211,15 +213,15 @@ def is_type_of(cls, root, info):
 
     @classmethod
     def get_node(cls, info, id):
-        only_fields = list()
-        for field in cls._meta.only_fields:
+        required_fields = list()
+        for field in cls._meta.required_fields:
             if field in cls._meta.model._fields_ordered:
-                only_fields.append(field)
+                required_fields.append(field)
         for field in get_query_fields(info):
             if to_snake_case(field) in cls._meta.model._fields_ordered:
-                only_fields.append(to_snake_case(field))
-        only_fields = list(set(only_fields))
-        return cls._meta.model.objects.no_dereference().only(*only_fields).get(pk=id)
+                required_fields.append(to_snake_case(field))
+        required_fields = list(set(required_fields))
+        return cls._meta.model.objects.no_dereference().only(*required_fields).get(pk=id)
 
     def resolve_id(self, info):
         return str(self.id)