Pagination Optimised for faster execution

Pagination support added for custom connection resolvers;
    eg:

    def resolve_author_query(self, info, **kwargs):
        return info.context.queryset.filter(is_verified=True)

Pagination Test Passed

Author: arunsureshkumar

graphene_mongo/fields.py

@@ -15,7 +15,8 @@
 from graphene.types.argument import to_arguments
 from graphene.types.dynamic import Dynamic
 from graphene.types.structures import Structure
-from graphql_relay.connection.arrayconnection import connection_from_list_slice
+from graphql_relay.connection.arrayconnection import cursor_to_offset
+from mongoengine import QuerySet
 
 from .advanced_types import (
     FileFieldType,
@@ -25,7 +26,8 @@
 )
 from .converter import convert_mongoengine_field, MongoEngineConversionError
 from .registry import get_global_registry
-from .utils import get_model_reference_fields, get_node_from_global_id, get_query_fields
+from .utils import get_model_reference_fields, get_node_from_global_id, get_query_fields, find_skip_and_limit, \
+    connection_from_iterables
 
 
 class MongoengineConnectionField(ConnectionField):
@@ -188,7 +190,7 @@ def get_reference_field(r, kv):
     def fields(self):
         return self._type._meta.fields
 
-    def get_queryset(self, model, info, required_fields=list(), **args):
+    def get_queryset(self, model, info, required_fields=list(), skip=None, limit=None, reversed=False, **args):
         if args:
             reference_fields = get_model_reference_fields(self.model)
             hydrated_references = {}
@@ -206,7 +208,30 @@ def get_queryset(self, model, info, required_fields=list(), **args):
                 return queryset_or_filters
             else:
                 args.update(queryset_or_filters)
-
+        if limit is not None:
+            if reversed:
+                order_by = ""
+                if self.order_by:
+                    order_by = self.order_by + ",-pk"
+                else:
+                    order_by = "-pk"
+                return model.objects(**args).no_dereference().only(*required_fields).order_by(order_by).skip(
+                    skip if skip else 0).limit(limit)
+            else:
+                return model.objects(**args).no_dereference().only(*required_fields).order_by(self.order_by).skip(
+                    skip if skip else 0).limit(limit)
+        elif skip is not None:
+            if reversed:
+                order_by = ""
+                if self.order_by:
+                    order_by = self.order_by + ",-pk"
+                else:
+                    order_by = "-pk"
+                return model.objects(**args).no_dereference().only(*required_fields).order_by(order_by).skip(
+                    skip)
+            else:
+                return model.objects(**args).no_dereference().only(*required_fields).order_by(self.order_by).skip(
+                    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):
@@ -217,38 +242,66 @@ def default_resolver(self, _root, info, required_fields=list(), **args):
             if getattr(_root, field_name, []) is not None:
                 args["pk__in"] = [r.id for r in getattr(_root, field_name, [])]
 
-        connection_args = {
-            "first": args.pop("first", None),
-            "last": args.pop("last", None),
-            "before": args.pop("before", None),
-            "after": args.pop("after", None),
-        }
-
         _id = args.pop('id', None)
 
         if _id is not None:
             args['pk'] = from_global_id(_id)[-1]
-
+        iterables = []
+        list_length = 0
+        skip = 0
+        count = 0
+        limit = None
+        reverse = False
         if callable(getattr(self.model, "objects", None)):
-            iterables = self.get_queryset(self.model, info, required_fields, **args)
-            if isinstance(info, ResolveInfo):
-                if not info.context:
-                    info.context = Context()
-                info.context.queryset = iterables
-            list_length = iterables.count()
-        else:
-            iterables = []
-            list_length = 0
-
-        connection = connection_from_list_slice(
-            list_slice=iterables,
-            args=connection_args,
-            list_length=list_length,
-            list_slice_length=list_length,
-            connection_type=self.type,
-            edge_type=self.type.Edge,
-            pageinfo_type=graphene.PageInfo,
-        )
+            first = args.pop("first", None)
+            after = cursor_to_offset(args.pop("after", None))
+            last = args.pop("last", None)
+            before = cursor_to_offset(args.pop("before", None))
+            if after is not None:
+                has_previous_page = after > 0
+            elif (before is not None and last is not None):
+                has_previous_page = before - last <= 0
+            if "pk__in" in args and args["pk__in"]:
+                count = len(args["pk__in"])
+                skip, limit, reverse = find_skip_and_limit(first=first, last=last, after=after, before=before,
+                                                           count=count)
+                if limit:
+                    if reverse:
+                        args["pk__in"] = args["pk__in"][::-1][skip:skip + limit]
+                    else:
+                        args["pk__in"] = args["pk__in"][skip:skip + limit]
+                elif skip:
+                    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 not info.context:
+                        info.context = Context()
+                    info.context.queryset = self.get_queryset(self.model, info, required_fields, **args)
+            elif _root is None:
+                count = self.get_queryset(self.model, info, required_fields, **args).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 not info.context:
+                            info.context = Context()
+                        info.context.queryset = self.get_queryset(self.model, info, required_fields, **args)
+        has_next_page = True if (0 if limit is None else limit) + (0 if skip is None else skip) < count else False
+        has_previous_page = True if skip else False
+        if reverse:
+            iterables = list(iterables)
+            iterables.reverse()
+            skip = limit
+        connection = connection_from_iterables(edges=iterables, start_offset=skip,
+                                               has_previous_page=has_previous_page,
+                                               has_next_page=has_next_page,
+                                               connection_type=self.type,
+                                               edge_type=self.type.Edge,
+                                               pageinfo_type=graphene.PageInfo)
+
         connection.iterable = iterables
         connection.list_length = list_length
         return connection
@@ -280,6 +333,9 @@ def chained_resolver(self, resolver, is_partial, root, info, **args):
                         return resolved
                     elif not isinstance(resolved[0], DBRef):
                         return resolved
+                elif isinstance(resolved, QuerySet):
+                    args.update(resolved._query)
+                    return self.default_resolver(root, info, required_fields, **args)
                 else:
                     return resolved
         return self.default_resolver(root, info, required_fields, **args)

graphene_mongo/tests/test_fields.py

@@ -56,4 +56,4 @@ def test_default_resolver_connection_list_length(fixtures):
 
     connection = field.default_resolver(None, {}, **{"first": 1})
     assert hasattr(connection, "list_length")
-    assert connection.list_length == 3
+    assert connection.list_length == 1

graphene_mongo/utils.py

@@ -7,6 +7,7 @@
 from graphene import Node
 from graphene.utils.trim_docstring import trim_docstring
 from graphql.utils.ast_to_dict import ast_to_dict
+from graphql_relay.connection.arrayconnection import offset_to_cursor
 
 
 def get_model_fields(model, excluding=None):
@@ -164,3 +165,67 @@ def get_query_fields(info):
     if "edges" in query:
         return query["edges"]["node"].keys()
     return query
+
+
+def find_skip_and_limit(first, last, after, before, count):
+    reverse = False
+    skip = 0
+    limit = None
+    if first is not None and after is not None:
+        skip = after + 1
+        limit = first
+    elif first is not None and before is not None:
+        if first >= before:
+            limit = before - 1
+        else:
+            limit = first
+    elif first is not None:
+        skip = 0
+        limit = first
+    elif last is not None and before is not None:
+        reverse = False
+        if last >= before:
+            limit = before
+        else:
+            limit = last
+            skip = before - last
+    elif last is not None and after is not None:
+        reverse = True
+        if last + after < count:
+            limit = last
+        else:
+            limit = count - after - 1
+    elif last is not None:
+        skip = 0
+        limit = last
+        reverse = True
+    elif after is not None:
+        skip = after + 1
+    elif before is not None:
+        limit = before
+    return skip, limit, reverse
+
+
+def connection_from_iterables(edges, start_offset, has_previous_page, has_next_page, connection_type,
+                              edge_type,
+                              pageinfo_type):
+    edges_items = [
+        edge_type(
+            node=node,
+            cursor=offset_to_cursor((0 if start_offset is None else start_offset) + i)
+        )
+        for i, node in enumerate(edges)
+    ]
+
+    first_edge_cursor = edges_items[0].cursor if edges_items else None
+    last_edge_cursor = edges_items[-1].cursor if edges_items else None
+
+    return connection_type(
+        edges=edges_items,
+        page_info=pageinfo_type(
+            start_cursor=first_edge_cursor,
+            end_cursor=last_edge_cursor,
+            has_previous_page=has_previous_page,
+            has_next_page=has_next_page
+        )
+    )