Add support for "true" cursor based pagination in connections

docs/guide/relay.md

@@ -69,3 +69,36 @@ For more customization options, like changing the pagination algorithm, adding e
 to the `Connection`/`Edge` type, take a look at the
 [official strawberry relay integration](https://strawberry.rocks/docs/guides/relay)
 as those are properly explained there.
+
+## Cursor based connections
+
+As an alternative to the default `ListConnection`, `DjangoCursorConnection` is also available.
+It supports pagination through a Django `QuerySet` via "true" cursors.
+`ListConnection` uses slicing to achieve pagination, which can negatively affect performance for huge datasets,
+because large page numbers require a large `OFFSET` in SQL.
+Instead, `DjangoCursorConnection` uses range queries such as `Q(due_date__gte=...)` for pagination. In combination
+with an Index, this makes for more efficient queries.
+
+`DjangoCursorConnection` requires a _strictly_ ordered `QuerySet`, that is, no two entries in the `QuerySet`
+must be considered equal by its ordering. `order_by('due_date')` for example is not strictly ordered, because two
+items could have the same due date. `DjangoCursorConnection` will automatically resolve such situations by
+also ordering by the primary key.
+
+When the order for the connection is configurable by the user (for example via
+[`@strawberry_django.order`](./ordering.md)) then cursors created by `DjangoCursorConnection` will not be compatible
+between different orders.
+
+The drawback of cursor based pagination is that users cannot jump to a particular page immediately. Therefor
+cursor based pagination is better suited for special use-cases like an infinitely scrollable list.
+
+Otherwise `DjangoCursorConnection` behaves like other connection classes:
+
+```python
+@strawberry.type
+class Query:
+    fruit: DjangoCursorConnection[FruitType] = strawberry_django.connection()
+
+    @strawberry_django.connection(DjangoCursorConnection[FruitType])
+    def fruit_with_custom_resolver(self) -> list[Fruit]:
+      return Fruit.objects.all()
+```

strawberry_django/fields/field.py

@@ -323,8 +323,10 @@ def get_queryset(self, queryset, info, **kwargs):
         )
 
         # If optimizer extension is enabled, optimize this queryset
-        ext = optimizer.optimizer.get()
-        if ext is not None:
+        if (
+            not self.disable_optimization
+            and (ext := optimizer.optimizer.get()) is not None
+        ):
             queryset = ext.optimize(queryset, info=info)
 
         return queryset

strawberry_django/optimizer.py

@@ -41,7 +41,7 @@
 from strawberry.relay.utils import SliceMetadata
 from strawberry.schema.schema import Schema
 from strawberry.schema.schema_converter import get_arguments
-from strawberry.types import get_object_definition
+from strawberry.types import get_object_definition, has_object_definition
 from strawberry.types.base import StrawberryContainer
 from strawberry.types.info import Info
 from strawberry.types.lazy_type import LazyType
@@ -94,7 +94,6 @@
     "optimize",
 ]
 
-NESTED_PREFETCH_MARK = "_strawberry_nested_prefetch_optimized"
 _M = TypeVar("_M", bound=models.Model)
 
 _sentinel = object()
@@ -496,6 +495,8 @@ def _optimize_prefetch_queryset(
         StrawberryDjangoField,
     )
 
+    from .relay_cursor import DjangoCursorConnection, apply_cursor_pagination
+
     if (
         not config
         or not config.enable_nested_relations_prefetch
@@ -571,6 +572,17 @@ def _optimize_prefetch_queryset(
                     limit=slice_metadata.end - slice_metadata.start,
                     max_results=connection_extension.max_results,
                 )
+            elif connection_type is DjangoCursorConnection:
+                qs, _ = apply_cursor_pagination(
+                    qs,
+                    related_field_id=related_field_id,
+                    info=Info(_raw_info=info, _field=field),
+                    first=field_kwargs.get("first"),
+                    last=field_kwargs.get("last"),
+                    before=field_kwargs.get("before"),
+                    after=field_kwargs.get("after"),
+                    max_results=connection_extension.max_results,
+                )
             else:
                 mark_optimized = False
 
@@ -1246,13 +1258,20 @@ def _get_model_hints_from_connection(
         if edge.name.value != "edges":
             continue
 
-        e_definition = get_object_definition(relay.Edge, strict=True)
-        e_type = e_definition.resolve_generic(
-            relay.Edge[cast("type[relay.Node]", n_type)],
-        )
+        e_field = object_definition.get_field("edges")
+        if e_field is None:
+            break
+
+        e_definition = e_field.type
+        while isinstance(e_definition, StrawberryContainer):
+            e_definition = e_definition.of_type
+        if has_object_definition(e_definition):
+            e_definition = get_object_definition(e_definition, strict=True)
+        assert isinstance(e_definition, StrawberryObjectDefinition)
+
         e_gql_definition = _get_gql_definition(
             schema,
-            get_object_definition(e_type, strict=True),
+            e_definition,
         )
         assert isinstance(e_gql_definition, (GraphQLObjectType, GraphQLInterfaceType))
         e_info = _generate_selection_resolve_info(
@@ -1451,20 +1470,17 @@ def optimize(
 
 
 def is_optimized(qs: QuerySet) -> bool:
-    return get_queryset_config(qs).optimized or is_optimized_by_prefetching(qs)
+    config = get_queryset_config(qs)
+    return config.optimized or config.optimized_by_prefetching
 
 
 def mark_optimized_by_prefetching(qs: QuerySet[_M]) -> QuerySet[_M]:
-    # This is a bit of a hack, but there is no easy way to mark a related manager
-    # as optimized at this phase, so we just add a mark to the queryset that
-    # we can check leater on using is_optimized_by_prefetching
-    return qs.annotate(**{
-        NESTED_PREFETCH_MARK: models.Value(True),
-    })
+    get_queryset_config(qs).optimized_by_prefetching = True
+    return qs
 
 
 def is_optimized_by_prefetching(qs: QuerySet) -> bool:
-    return NESTED_PREFETCH_MARK in qs.query.annotations
+    return get_queryset_config(qs).optimized_by_prefetching
 
 
 optimizer: contextvars.ContextVar[DjangoOptimizerExtension | None] = (

strawberry_django/queryset.py

@@ -9,6 +9,8 @@
 if TYPE_CHECKING:
     from strawberry import Info
 
+    from strawberry_django.relay_cursor import OrderingDescriptor
+
 _M = TypeVar("_M", bound=Model)
 
 CONFIG_KEY = "_strawberry_django_config"
@@ -17,11 +19,16 @@
 @dataclasses.dataclass
 class StrawberryDjangoQuerySetConfig:
     optimized: bool = False
+    optimized_by_prefetching: bool = False
     type_get_queryset_did_run: bool = False
+    ordering_descriptors: list[OrderingDescriptor] | None = None
 
 
 def get_queryset_config(queryset: QuerySet) -> StrawberryDjangoQuerySetConfig:
-    return getattr(queryset, CONFIG_KEY, None) or StrawberryDjangoQuerySetConfig()
+    config = getattr(queryset, CONFIG_KEY, None)
+    if config is None:
+        setattr(queryset, CONFIG_KEY, (config := StrawberryDjangoQuerySetConfig()))
+    return config
 
 
 def run_type_get_queryset(