Merge pull request #172 from arunsureshkumar/support-graphene-v3

Support graphene v3

Author: abawchen

graphene_mongo/advanced_types.py

@@ -30,7 +30,7 @@ def resolve_data(self, info):
         v = getattr(self.instance, self.key)
         data = v.read()
         if data is not None:
-            return base64.b64encode(data)
+            return base64.b64encode(data).decode("utf-8")
         return None
 
 

graphene_mongo/fields.py

@@ -5,11 +5,11 @@
 
 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
-from graphql import ResolveInfo
+from graphql import GraphQLResolveInfo
 from mongoengine.base import get_document
 from promise import Promise
 from graphql_relay import from_global_id
@@ -168,7 +168,7 @@ def filter_args(self):
                     }
                     filter_type = advanced_filter_types.get(each, filter_type)
                     filter_args[field + "__" + each] = graphene.Argument(
-                        type=filter_type
+                        type_=filter_type
                     )
         return filter_args
 
@@ -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,8 +279,13 @@ 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:
+                del args[key]
         if _root is not None:
             field_name = to_snake_case(info.field_name)
             if not hasattr(_root, "_fields_ordered"):
@@ -301,9 +309,13 @@ def default_resolver(self, _root, info, required_fields=list(), **args):
         limit = None
         reverse = False
         first = args.pop("first", None)
-        after = cursor_to_offset(args.pop("after", None))
+        after = args.pop("after", None)
+        if after:
+            after = cursor_to_offset(after)
         last = args.pop("last", None)
-        before = cursor_to_offset(args.pop("before", None))
+        before = args.pop("before", None)
+        if before:
+            before = cursor_to_offset(before)
         if callable(getattr(self.model, "objects", None)):
             if "pk__in" in args and args["pk__in"]:
                 count = len(args["pk__in"])
@@ -318,20 +330,32 @@ def default_resolver(self, _root, info, required_fields=list(), **args):
                     args["pk__in"] = args["pk__in"][skip:]
                 iterables = self.get_queryset(self.model, info, required_fields, **args)
                 list_length = len(iterables)
-                if isinstance(info, ResolveInfo):
+                if isinstance(info, GraphQLResolveInfo):
                     if not info.context:
-                        info.context = Context()
+                        info = info._replace(context=Context())
                     info.context.queryset = self.get_queryset(self.model, info, required_fields, **args)
             elif _root is None or args:
-                count = self.get_queryset(self.model, info, required_fields, **args).count()
+                args_copy = args.copy()
+                for key in args.copy():
+                    if key not in self.model._fields_ordered:
+                        args_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):
+                        if not isinstance(args_copy[key], ObjectId):
+                            args_copy[key] = from_global_id(args_copy[key])[1]
+                count = mongoengine.get_db()[self.model._get_collection_name()].find(args_copy).count()
                 if count != 0:
                     skip, limit, reverse = find_skip_and_limit(first=first, after=after, last=last, before=before,
                                                                count=count)
                     iterables = self.get_queryset(self.model, info, required_fields, skip, limit, reverse, **args)
                     list_length = len(iterables)
-                    if isinstance(info, ResolveInfo):
+                    if isinstance(info, GraphQLResolveInfo):
                         if not info.context:
-                            info.context = Context()
+                            info = info._replace(context=Context())
                         info.context.queryset = self.get_queryset(self.model, info, required_fields, **args)
 
         elif _root is not None:
@@ -367,6 +391,9 @@ def default_resolver(self, _root, info, required_fields=list(), **args):
         return connection
 
     def chained_resolver(self, resolver, is_partial, root, info, **args):
+        for key, value in dict(args).items():
+            if value is None:
+                del args[key]
         required_fields = list()
         for field in self.required_fields:
             if field in self.model._fields_ordered:
@@ -378,13 +405,15 @@ def chained_resolver(self, resolver, is_partial, root, info, **args):
         if not bool(args) or not is_partial:
             if isinstance(self.model, mongoengine.Document) or isinstance(self.model,
                                                                           mongoengine.base.metaclasses.TopLevelDocumentMetaclass):
+
                 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, ResolveInfo):
+                if isinstance(info, GraphQLResolveInfo):
                     if not info.context:
-                        info.context = Context()
-                    info.context.queryset = self.get_queryset(self.model, info, required_fields, **args_copy)
+                        info = info._replace(context=Context())
+                    info.context.queryset = self.get_queryset(self.model, info, required_fields, **args)
+
             # XXX: Filter nested args
             resolved = resolver(root, info, **args)
             if resolved is not None:
@@ -405,7 +434,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 not isinstance(arg, ObjectId) and '.' in arg_name:
                                 operation = list(arg.keys())[0]
                                 args_copy[arg_name.replace('.', '__') + operation.replace('$', '__')] = arg[operation]
                         else:
@@ -415,6 +444,8 @@ def chained_resolver(self, resolver, is_partial, root, info, **args):
                                 args_copy[arg_name + operation.replace('$', '__')] = arg[operation]
                                 del args_copy[arg_name]
                     return self.default_resolver(root, info, required_fields, **args_copy)
+                elif isinstance(resolved, Promise):
+                    return resolved.value
                 else:
                     return resolved
         return self.default_resolver(root, info, required_fields, **args)

graphene_mongo/tests/test_inputs.py

@@ -21,11 +21,9 @@ def mutate(self, info, article):
             return CreateArticle(article=article)
 
     class Query(graphene.ObjectType):
-
         node = Node.Field()
 
     class Mutation(graphene.ObjectType):
-
         create_article = CreateArticle.Field()
 
     query = """
@@ -57,7 +55,8 @@ class Arguments:
         def mutate(self, info, id, editor):
             editor_to_update = Editor.objects.get(id=id)
             for key, value in editor.items():
-                setattr(editor_to_update, key, value)
+                if value:
+                    setattr(editor_to_update, key, value)
             editor_to_update.save()
             return UpdateEditor(editor=editor_to_update)
 

graphene_mongo/tests/test_query.py

@@ -55,7 +55,7 @@ def resolve_editors(self, *args, **kwargs):
                 "chunkSize": 261120,
                 "length": 46928,
                 "md5": "f3c657fd472fdc4bc2ca9056a1ae6106",
-                "data": str(data),
+                "data": data.decode("utf-8"),
             },
         },
         "editors": [

graphene_mongo/tests/test_relay_query.py

@@ -173,7 +173,7 @@ class Query(graphene.ObjectType):
                         "avatar": {
                             "contentType": "image/jpeg",
                             "length": 46928,
-                            "data": str(data),
+                            "data": data.decode("utf-8"),
                         },
                     }
                 },
@@ -489,7 +489,6 @@ class Query(graphene.ObjectType):
 
 def test_should_first_n(fixtures):
     class Query(graphene.ObjectType):
-
         editors = MongoengineConnectionField(nodes.EditorNode)
 
     query = """
@@ -533,7 +532,6 @@ class Query(graphene.ObjectType):
 
 def test_should_after(fixtures):
     class Query(graphene.ObjectType):
-
         players = MongoengineConnectionField(nodes.PlayerNode)
 
     query = """
@@ -566,7 +564,6 @@ class Query(graphene.ObjectType):
 
 def test_should_before(fixtures):
     class Query(graphene.ObjectType):
-
         players = MongoengineConnectionField(nodes.PlayerNode)
 
     query = """
@@ -632,7 +629,6 @@ class Query(graphene.ObjectType):
 
 def test_should_self_reference(fixtures):
     class Query(graphene.ObjectType):
-
         players = MongoengineConnectionField(nodes.PlayerNode)
 
     query = """
@@ -767,7 +763,6 @@ class Query(graphene.ObjectType):
 
 def test_should_query_with_embedded_document(fixtures):
     class Query(graphene.ObjectType):
-
         professors = MongoengineConnectionField(nodes.ProfessorVectorNode)
 
     query = """
@@ -1026,7 +1021,6 @@ class Query(graphene.ObjectType):
 
 
 def test_should_filter_mongoengine_queryset_by_id_and_other_fields(fixtures):
-
     class Query(graphene.ObjectType):
         players = MongoengineConnectionField(nodes.PlayerNode)
 

graphene_mongo/utils.py

@@ -6,7 +6,8 @@
 import mongoengine
 from graphene import Node
 from graphene.utils.trim_docstring import trim_docstring
-from graphql.utils.ast_to_dict import ast_to_dict
+# from graphql.utils.ast_to_dict import ast_to_dict
+from graphql import FieldNode
 from graphql_relay.connection.arrayconnection import offset_to_cursor
 
 
@@ -126,21 +127,24 @@ def collect_query_fields(node, fragments):
     """
 
     field = {}
-
-    if node.get('selection_set'):
-        for leaf in node['selection_set']['selections']:
-            if leaf['kind'] == 'Field':
+    selection_set = None
+    if type(node) == dict:
+        selection_set = node.get('selection_set')
+    else:
+        selection_set = node.selection_set
+    if selection_set:
+        for leaf in selection_set.selections:
+            if leaf.kind == 'field':
                 field.update({
-                    leaf['name']['value']: collect_query_fields(leaf, fragments)
+                    leaf.name.value: collect_query_fields(leaf, fragments)
                 })
-            elif leaf['kind'] == 'FragmentSpread':
+            elif leaf.kind == 'fragment_spread':
                 field.update(collect_query_fields(fragments[leaf['name']['value']],
                                                   fragments))
-            elif leaf['kind'] == 'InlineFragment':
+            elif leaf.kind == 'inline_fragment':
                 field.update({
-                    leaf["type_condition"]["name"]['value']: collect_query_fields(leaf, fragments)
+                    leaf.type_condition.name.value: collect_query_fields(leaf, fragments)
                 })
-                pass
 
     return field
 
@@ -156,7 +160,7 @@ def get_query_fields(info):
     """
 
     fragments = {}
-    node = ast_to_dict(info.field_asts[0])
+    node = ast_to_dict(info.field_nodes[0])
 
     for name, value in info.fragments.items():
         fragments[name] = ast_to_dict(value)
@@ -167,6 +171,24 @@ def get_query_fields(info):
     return query
 
 
+def ast_to_dict(node, include_loc=False):
+    if isinstance(node, FieldNode):
+        d = {"kind": node.__class__.__name__}
+        if hasattr(node, "keys"):
+            for field in node.keys:
+                d[field] = ast_to_dict(getattr(node, field), include_loc)
+
+        if include_loc and hasattr(node, "loc") and node.loc:
+            d["loc"] = {"start": node.loc.start, "end": node.loc.end}
+
+        return d
+
+    elif isinstance(node, list):
+        return [ast_to_dict(item, include_loc) for item in node]
+
+    return node
+
+
 def find_skip_and_limit(first, last, after, before, count):
     reverse = False
     skip = 0

requirements.txt

@@ -1,19 +1,18 @@
 coveralls==1.11.1; python_version <= '3.5'
-coveralls==2.1.2; python_version > '3.5'
+coveralls==3.0.1; python_version > '3.5'
 flake8==3.7.9
 flake8-per-file-ignores==0.6
 future==0.18.2
-graphene>=2.1.8,<3
-iso8601==0.1.13
+graphene==3.0b7
+promise==2.3
 mongoengine==0.19.1; python_version <= '3.5'
-mongoengine==0.22.1; python_version > '3.5'
-mongomock==3.22.0
-pymongo==3.11.2
+mongoengine==0.23.0; python_version > '3.5'
+mongomock==3.22.1
 pytest==4.6.11; python_version <= '3.5'
-pytest==6.2.1; python_version > '3.5'
+pytest==6.2.2; python_version > '3.5'
 pytest-cov==2.8.1; python_version == '3.5' or python_version == '3.4'
-pytest-cov==2.10.1; python_version < '3.4' or python_version > '3.5'
-singledispatch==3.4.0.3
+pytest-cov==2.11.1; python_version < '3.4' or python_version > '3.5'
+singledispatch==3.6.1
 # https://stackoverflow.com/a/58189684/9041712
 attrs==20.2.0
 futures; python_version < '3.0'

setup.cfg

@@ -1,5 +1,5 @@
 [metadata]
-description-file = README.md
+description_file = README.md
 
 [flake8]
 exclude = setup.py,docs/*,examples/*

setup.py

@@ -2,7 +2,7 @@
 
 setup(
     name="graphene-mongo",
-    version="0.2.13",
+    version="0.3.1",
     description="Graphene Mongoengine integration",
     long_description=open("README.rst").read(),
     url="https://github.com/graphql-python/graphene-mongo",
@@ -13,24 +13,23 @@
         "Development Status :: 4 - Beta",
         "Intended Audience :: Developers",
         "Topic :: Software Development :: Libraries",
-        "Programming Language :: Python :: 2.7",
-        "Programming Language :: Python :: 3.4",
-        "Programming Language :: Python :: 3.5",
         "Programming Language :: Python :: 3.6",
         "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: Implementation :: PyPy",
         "License :: OSI Approved :: MIT License",
     ],
     keywords="api graphql protocol rest relay graphene mongo mongoengine",
     packages=find_packages(exclude=["tests"]),
     install_requires=[
-        "graphene>=2.1.3,<3",
-        "mongoengine>=0.15.0",
+        "graphene==3.0b7",
+        "promise==2.3",
+        "mongoengine>=0.23.0",
         "singledispatch>=3.4.0.3",
         "iso8601>=0.1.12",
         'futures; python_version < "3.0"'
     ],
-    python_requires=">=2.7",
+    python_requires=">=3.6",
     zip_safe=True,
     tests_require=["pytest>=3.3.2", "mongomock", "mock"],
 )