feat: Add support for Node interface subclasses that override global_id functions.

Author: zrlay

graphene_mongo/converter.py

@@ -16,15 +16,18 @@
 import mongoengine
 
 from .advanced_types import PointFieldType, MultiPolygonFieldType
-from .fields import MongoengineConnectionField
 from .utils import import_single_dispatch, get_field_description
 
 singledispatch = import_single_dispatch()
 
 
+class MongoEngineConversionError(Exception):
+    pass
+
+
 @singledispatch
 def convert_mongoengine_field(field, registry=None):
-    raise Exception(
+    raise MongoEngineConversionError(
         "Don't know how to convert the MongoEngine field %s (%s)" %
         (field, field.__class__))
 
@@ -83,6 +86,8 @@ def convert_field_to_datetime(field, registry=None):
 @convert_mongoengine_field.register(mongoengine.ListField)
 @convert_mongoengine_field.register(mongoengine.EmbeddedDocumentListField)
 def convert_field_to_list(field, registry=None):
+    from .fields import MongoengineConnectionField
+
     base_type = convert_mongoengine_field(field.field, registry=registry)
     if isinstance(base_type, (Dynamic)):
         base_type = base_type.get_type()

graphene_mongo/fields.py

@@ -1,19 +1,21 @@
 from __future__ import absolute_import
 
-import mongoengine
 from collections import OrderedDict
 from functools import partial, reduce
 
+import mongoengine
 from graphene.relay import ConnectionField
 from graphene.relay.connection import PageInfo
-from graphql_relay.connection.arrayconnection import connection_from_list_slice
-from graphql_relay.node.node import from_global_id
 from graphene.types.argument import to_arguments
 from graphene.types.dynamic import Dynamic
-from graphene.types.structures import Structure
+from graphene.types.structures import Structure, List
+from graphql_relay import from_global_id
+from graphql_relay.connection.arrayconnection import connection_from_list_slice
 
 from .advanced_types import PointFieldType, MultiPolygonFieldType
-from .utils import get_model_reference_fields
+from .converter import convert_mongoengine_field, MongoEngineConversionError
+from .registry import get_global_registry
+from .utils import get_model_reference_fields, node_from_global_id
 
 
 class MongoengineConnectionField(ConnectionField):
@@ -43,6 +45,10 @@ def node_type(self):
     def model(self):
         return self.node_type._meta.model
 
+    @property
+    def registry(self):
+        return getattr(self.node_type._meta, 'registry', get_global_registry())
+
     @property
     def args(self):
         return to_arguments(
@@ -55,12 +61,19 @@ def args(self, args):
         self._base_args = args
 
     def _field_args(self, items):
-        def is_filterable(v):
-            if isinstance(v, (ConnectionField, Dynamic)):
+        def is_filterable(k):
+            if not hasattr(self.model, k):
+                return False
+            if isinstance(getattr(self.model, k), property):
                 return False
-            # FIXME: Skip PointTypeField at this moment.
-            if not isinstance(v.type, Structure) \
-                    and isinstance(v.type(), (PointFieldType, MultiPolygonFieldType)):
+            try:
+                converted = convert_mongoengine_field(getattr(self.model, k), self.registry)
+            except MongoEngineConversionError:
+                return False
+            if isinstance(converted, (ConnectionField, Dynamic, List)):
+                return False
+            if callable(getattr(converted, 'type', None)) and isinstance(converted.type(),
+                                                                         (PointFieldType, MultiPolygonFieldType)):
                 return False
             return True
 
@@ -69,7 +82,7 @@ def get_type(v):
                 return v.type.of_type()
             return v.type()
 
-        return {k: get_type(v) for k, v in items if is_filterable(v)}
+        return {k: get_type(v) for k, v in items if is_filterable(k)}
 
     @property
     def field_args(self):
@@ -78,19 +91,26 @@ def field_args(self):
     @property
     def reference_args(self):
         def get_reference_field(r, kv):
-            if callable(getattr(kv[1], 'get_type', None)):
-                node = kv[1].get_type()._type._meta
-                if not issubclass(node.model, mongoengine.EmbeddedDocument):
-                    r.update({kv[0]: node.fields['id']._type.of_type()})
+            field = kv[1]
+            mongo_field = getattr(self.model, kv[0], None)
+            if isinstance(mongo_field, (mongoengine.LazyReferenceField, mongoengine.ReferenceField)):
+                field = convert_mongoengine_field(mongo_field, self.registry)
+            if callable(getattr(field, 'get_type', None)):
+                _type = field.get_type()
+                if _type:
+                    node = _type._type._meta
+                    if 'id' in node.fields and not issubclass(node.model, mongoengine.EmbeddedDocument):
+                        r.update({kv[0]: node.fields['id']._type.of_type()})
             return r
+
         return reduce(get_reference_field, self.fields.items(), {})
 
     @property
     def fields(self):
         return self._type._meta.fields
 
     @classmethod
-    def get_query(cls, model, info, **args):
+    def get_query(cls, model, connection, info, **args):
 
         if not callable(getattr(model, 'objects', None)):
             return [], 0
@@ -102,20 +122,20 @@ def get_query(cls, model, info, **args):
             for arg_name, arg in args.copy().items():
                 if arg_name in reference_fields:
                     reference_model = model._fields[arg_name]
-                    pk = from_global_id(args.pop(arg_name))[-1]
+                    pk = node_from_global_id(connection, args.pop(arg_name))[-1]
                     reference_obj = reference_model.document_type_obj.objects(pk=pk).get()
                     reference_args[arg_name] = reference_obj
 
             args.update(reference_args)
             first = args.pop('first', None)
             last = args.pop('last', None)
-            id = args.pop('id', None)
+            _id = args.pop('id', None)
             before = args.pop('before', None)
             after = args.pop('after', None)
 
-            if id is not None:
+            if _id is not None:
                 # https://github.com/graphql-python/graphene/issues/124
-                args['pk'] = from_global_id(id)[-1]
+                args['pk'] = node_from_global_id(connection, _id)[-1]
 
             objs = objs.filter(**args)
 
@@ -152,14 +172,14 @@ def merge_querysets(cls, default_queryset, queryset):
     def connection_resolver(cls, resolver, connection, model, root, info, **args):
         iterable = resolver(root, info, **args)
 
-        if not iterable:
-            iterable, _len = cls.get_query(model, info, **args)
+        if iterable or iterable == []:
+            _len = len(iterable)
+        else:
+            iterable, _len = cls.get_query(model, connection, info, **args)
 
             if root:
                 # If we have a root, we must be at least 1 layer in, right?
                 _len = 0
-        else:
-            _len = len(iterable)
 
         connection = connection_from_list_slice(
             iterable,

graphene_mongo/utils.py

@@ -4,7 +4,9 @@
 from collections import OrderedDict
 
 import mongoengine
+from graphene import Node
 from graphene.utils.trim_docstring import trim_docstring
+from graphql_relay import from_global_id
 
 
 def get_model_fields(model, excluding=None):
@@ -87,3 +89,12 @@ def get_field_description(field, registry=None):
         parts.append(name_format % field.db_field)
 
     return "\n".join(parts)
+
+
+def node_from_global_id(connection, _id):
+    try:
+        for interface in connection._meta.node._meta.interfaces:
+            if issubclass(interface, Node):
+                return interface.from_global_id(_id)
+    except AttributeError:
+        return from_global_id(_id)