feat: Enables user customization by allowing subclassing and runtime filters on Connection fields.

• Subclassing or replacing automatically attached/converted MongoengineConnectionField is possible by specifying `connection_field_class` in the ObjectType meta.
• A new API for specifying a callable that can return custom filters or a queryset when generating a connection iterable: `get_queryset`.
• Refactors MongoengineConnectionField to use existing graphene connection functions instead of reinventing list slicing.
• Refactors MongoengineConnectionField to do object lookup as an instance method instead of doing wacky things with the connection class methods. Should make subclassing get_queryset and default_resolver much more useful and intuitive.

Author: zrlay

graphene_mongo/converter.py

@@ -86,8 +86,6 @@ 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()
@@ -96,7 +94,7 @@ def convert_field_to_list(field, registry=None):
         base_type = base_type._type
 
     if is_node(base_type):
-        return MongoengineConnectionField(base_type)
+        return base_type._meta.connection_field_class(base_type)
 
     # Non-relationship field
     relations = (mongoengine.ReferenceField, mongoengine.EmbeddedDocumentField)

graphene_mongo/fields.py

@@ -4,23 +4,26 @@
 from functools import partial, reduce
 
 import mongoengine
+from graphene import PageInfo
 from graphene.relay import ConnectionField
-from graphene.relay.connection import PageInfo
 from graphene.types.argument import to_arguments
 from graphene.types.dynamic import Dynamic
 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 .converter import convert_mongoengine_field, MongoEngineConversionError
 from .registry import get_global_registry
-from .utils import get_model_reference_fields, node_from_global_id
+from .utils import get_model_reference_fields, global_id_via_node
 
 
 class MongoengineConnectionField(ConnectionField):
 
     def __init__(self, type, *args, **kwargs):
+        get_queryset = kwargs.pop('get_queryset', None)
+        if get_queryset:
+            assert callable(get_queryset), "Attribute `get_queryset` on {} must be callable.".format(self)
+        self._get_queryset = get_queryset
         super(MongoengineConnectionField, self).__init__(
             type,
             *args,
@@ -109,91 +112,65 @@ def get_reference_field(r, kv):
     def fields(self):
         return self._type._meta.fields
 
-    @classmethod
-    def get_query(cls, model, connection, info, **args):
-
-        if not callable(getattr(model, 'objects', None)):
+    def get_queryset(self, model, info, **args):
+        if self._get_queryset:
+            queryset_or_filters = self._get_queryset(model, info, **args)
+            if isinstance(queryset_or_filters, mongoengine.QuerySet):
+                return queryset_or_filters
+            else:
+                return model.objects(**queryset_or_filters)
+        return model.objects()
+
+    def default_resolver(self, _root, info, **args):
+        if not callable(getattr(self.model, 'objects', None)):
             return [], 0
 
-        objs = model.objects()
+        args = args or {}
+
+        connection_args = {
+            'first': args.pop('first', None),
+            'last': args.pop('last', None),
+            'before': args.pop('before', None),
+            'after': args.pop('after', None)
+        }
+
+        objs = self.get_queryset(self.model, info, **args)
+
         if args:
-            reference_fields = get_model_reference_fields(model)
+            reference_fields = get_model_reference_fields(self.model)
             reference_args = {}
             for arg_name, arg in args.copy().items():
                 if arg_name in reference_fields:
-                    reference_model = model._fields[arg_name]
-                    pk = node_from_global_id(connection, args.pop(arg_name))[-1]
+                    reference_model = self.model._fields[arg_name]
+                    pk = global_id_via_node(self.node_type, 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)
-            before = args.pop('before', None)
-            after = args.pop('after', None)
-
             if _id is not None:
-                # https://github.com/graphql-python/graphene/issues/124
-                args['pk'] = node_from_global_id(connection, _id)[-1]
+                args['pk'] = global_id_via_node(self.node_type, _id)[-1]
 
             objs = objs.filter(**args)
 
-            # https://github.com/graphql-python/graphene-mongo/issues/21
-            if after is not None:
-                _after = int(from_global_id(after)[-1])
-                objs = objs[_after:]
-
-            if before is not None:
-                _before = int(from_global_id(before)[-1])
-                objs = objs[:_before]
-
-            list_length = objs.count()
-
-            if first is not None:
-                objs = objs[:first]
-            if last is not None:
-                # https://github.com/graphql-python/graphene-mongo/issues/20
-                objs = objs[max(0, list_length - last):]
-        else:
-            list_length = objs.count()
-
-        return objs, list_length
-
-    # noqa
-    @classmethod
-    def merge_querysets(cls, default_queryset, queryset):
-        return queryset & default_queryset
-
-    """
-    Notes: Not sure how does this work :(
-    """
-    @classmethod
-    def connection_resolver(cls, resolver, connection, model, root, info, **args):
-        iterable = resolver(root, 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
-
         connection = connection_from_list_slice(
-            iterable,
-            args,
-            slice_start=0,
-            list_length=_len,
-            list_slice_length=_len,
-            connection_type=connection,
+            list_slice=objs,
+            args=connection_args,
+            list_length=objs.count(),
+            connection_type=self.type,
+            edge_type=self.type.Edge,
             pageinfo_type=PageInfo,
-            edge_type=connection.Edge,
         )
-        connection.iterable = iterable
-        connection.length = _len
+        connection.iterable = objs
         return connection
 
+    def chained_resolver(self, resolver, root, info, **args):
+        resolved = resolver(root, info, **args)
+        if resolved is not None:
+            return resolved
+        return self.default_resolver(root, info, **args)
+
     def get_resolver(self, parent_resolver):
-        return partial(self.connection_resolver, parent_resolver, self.type, self.model)
+        super_resolver = self.resolver or parent_resolver
+        resolver = partial(self.chained_resolver, super_resolver)
+        return partial(self.connection_resolver, resolver, self.type)

graphene_mongo/tests/setup.py

@@ -143,3 +143,4 @@ def fixtures():
     child3.parent = child4.parent = parent
     child3.save()
     child4.save()
+    return True

graphene_mongo/tests/test_relay_query.py

@@ -514,7 +514,7 @@ class Query(graphene.ObjectType):
         players = MongoengineConnectionField(PlayerNode)
 
     query = '''
-        query EditorQuery {
+        query PlayerQuery {
             players(last: 2) {
                 edges {
                     cursor,

graphene_mongo/types.py

@@ -1,11 +1,12 @@
 from collections import OrderedDict
 
-from graphene import Field
+from graphene import Field, ConnectionField
 from graphene.relay import Connection, Node
 from graphene.types.objecttype import ObjectType, ObjectTypeOptions
 from graphene.types.utils import yank_fields_from_attrs
 from mongoengine import ListField
 
+from graphene_mongo import MongoengineConnectionField
 from .converter import convert_mongoengine_field
 from .registry import Registry, get_global_registry
 from .utils import (get_model_fields, is_valid_mongoengine_model)
@@ -61,18 +62,20 @@ class MongoengineObjectType(ObjectType):
 
     @classmethod
     def __init_subclass_with_meta__(cls, model=None, registry=None, skip_registry=False,
-                                    only_fields=(), exclude_fields=(), filter_fields=None, connection=None,
-                                    connection_class=None, use_connection=None, interfaces=(), **options):
+                                    only_fields=(), exclude_fields=(), filter_fields=None,
+                                    connection=None, connection_class=None, use_connection=None,
+                                    connection_field_class=None, interfaces=(), **options):
 
         assert is_valid_mongoengine_model(model), (
-            'You need to pass a valid Mongoengine Model in {}.Meta, received "{}".'
-        ).format(cls.__name__, model)
+            'The attribute model in {}.Meta must be a valid Mongoengine Model. '
+            'Received "{}" instead.'
+        ).format(cls.__name__, type(model))
 
         if not registry:
             registry = get_global_registry()
 
         assert isinstance(registry, Registry), (
-            'The attribute registry in {} needs to be an instance of '
+            'The attribute registry in {}.Meta needs to be an instance of '
             'Registry, received "{}".'
         ).format(cls.__name__, registry)
 
@@ -93,15 +96,25 @@ def __init_subclass_with_meta__(cls, model=None, registry=None, skip_registry=Fa
 
         if connection is not None:
             assert issubclass(connection, Connection), (
-                'The connection must be a Connection. Received {}'
-            ).format(connection.__name__)
+                'The attribute connection in {}.Meta must be of type Connection. '
+                'Received "{}" instead.'
+            ).format(cls.__name__, type(connection))
+
+        if connection_field_class is not None:
+            assert issubclass(connection_field_class, ConnectionField), (
+                'The attribute connection_field_class in {}.Meta must be of type ConnectionField. '
+                'Received "{}" instead.'
+            ).format(cls.__name__, type(connection_field_class))
+        else:
+            connection_field_class = MongoengineConnectionField
 
         _meta = MongoengineObjectTypeOptions(cls)
         _meta.model = model
         _meta.registry = registry
         _meta.fields = mongoengine_fields
         _meta.filter_fields = filter_fields
         _meta.connection = connection
+        _meta.connection_field_class = connection_field_class
         # Save them for later
         _meta.only_fields = only_fields
         _meta.exclude_fields = exclude_fields

graphene_mongo/utils.py

@@ -91,9 +91,9 @@ def get_field_description(field, registry=None):
     return "\n".join(parts)
 
 
-def node_from_global_id(connection, _id):
+def global_id_via_node(node, _id):
     try:
-        for interface in connection._meta.node._meta.interfaces:
+        for interface in node._meta.interfaces:
             if issubclass(interface, Node):
                 return interface.from_global_id(_id)
     except AttributeError:

setup.py

@@ -2,7 +2,7 @@
 
 setup(
     name='graphene-mongo',
-    version='0.1.19',
+    version='0.2.0',
 
     description='Graphene Mongoengine integration',
     long_description=open('README.rst').read(),