strawberry-graphql 0.233.3__tar.gz → 0.234.1__tar.gz

{strawberry_graphql-0.233.3 → strawberry_graphql-0.234.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strawberry-graphql
-Version: 0.233.3
+Version: 0.234.1
 Summary: A library for creating GraphQL APIs
 Home-page: https://strawberry.rocks/
 License: MIT

{strawberry_graphql-0.233.3 → strawberry_graphql-0.234.1}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "strawberry-graphql"
 packages = [ { include = "strawberry" } ]
-version = "0.233.3"
+version = "0.234.1"
 description = "A library for creating GraphQL APIs"
 authors = ["Patrick Arminio <patrick.arminio@gmail.com>"]
 license = "MIT"

{strawberry_graphql-0.233.3 → strawberry_graphql-0.234.1}/strawberry/relay/types.py

@@ -38,7 +38,12 @@ from strawberry.utils.aio import aenumerate, aislice, resolve_awaitable
 from strawberry.utils.inspect import in_async_context
 from strawberry.utils.typing import eval_type, is_classvar
 
-from .utils import from_base64, should_resolve_list_connection_edges, to_base64
+from .utils import (
+    SliceMetadata,
+    from_base64,
+    should_resolve_list_connection_edges,
+    to_base64,
+)
 
 if TYPE_CHECKING:
     from strawberry.scalars import ID
@@ -215,14 +220,22 @@ class GlobalID:
 
         """
         type_def = info.schema.get_type_by_name(self.type_name)
-        assert isinstance(type_def, StrawberryObjectDefinition)
+        if not isinstance(type_def, StrawberryObjectDefinition):
+            raise GlobalIDValueError(
+                f"Cannot resolve. GlobalID requires a GraphQL type, "
+                f"received `{self.type_name}`."
+            )
 
         origin = (
             type_def.origin.resolve_type
             if isinstance(type_def.origin, LazyType)
             else type_def.origin
         )
-        assert issubclass(origin, Node)
+        if not issubclass(origin, Node):
+            raise GlobalIDValueError(
+                f"Cannot resolve. GlobalID requires a GraphQL Node type, "
+                f"received `{self.type_name}`."
+            )
         return origin
 
     @overload
@@ -790,61 +803,13 @@ class ListConnection(Connection[NodeType]):
             https://relay.dev/graphql/connections.htm#sec-Pagination-algorithm
 
         """
-        max_results = info.schema.config.relay_max_results
-        start = 0
-        end: Optional[int] = None
-
-        if after:
-            after_type, after_parsed = from_base64(after)
-            if after_type != PREFIX:
-                # When the base64 hash doesnt exist, the after_type seems to return
-                # arrayconnEction instead of PREFIX. Let's raise a predictable
-                # instead of "An unknown error occurred."
-                raise TypeError("Argument 'after' contains a non-existing value.")
-
-            start = int(after_parsed) + 1
-        if before:
-            before_type, before_parsed = from_base64(before)
-            if before_type != PREFIX:
-                # When the base64 hash doesnt exist, the after_type seems to return
-                # arrayconnEction instead of PREFIX. Let's raise a predictable
-                # instead of "An unknown error occurred.
-                raise TypeError("Argument 'before' contains a non-existing value.")
-            end = int(before_parsed)
-
-        if isinstance(first, int):
-            if first < 0:
-                raise ValueError("Argument 'first' must be a non-negative integer.")
-
-            if first > max_results:
-                raise ValueError(
-                    f"Argument 'first' cannot be higher than {max_results}."
-                )
-
-            if end is not None:
-                start = max(0, end - 1)
-
-            end = start + first
-        if isinstance(last, int):
-            if last < 0:
-                raise ValueError("Argument 'last' must be a non-negative integer.")
-
-            if last > max_results:
-                raise ValueError(
-                    f"Argument 'last' cannot be higher than {max_results}."
-                )
-
-            if end is not None:
-                start = max(start, end - last)
-            else:
-                end = sys.maxsize
-
-        if end is None:
-            end = start + max_results
-
-        expected = end - start if end != sys.maxsize else None
-        # Overfetch by 1 to check if we have a next result
-        overfetch = end + 1 if end != sys.maxsize else end
+        slice_metadata = SliceMetadata.from_arguments(
+            info,
+            before=before,
+            after=after,
+            first=first,
+            last=last,
+        )
 
         type_def = get_object_definition(cls)
         assert type_def
@@ -863,15 +828,17 @@ class ListConnection(Connection[NodeType]):
                 try:
                     iterator = cast(
                         Union[AsyncIterator[NodeType], AsyncIterable[NodeType]],
-                        cast(Sequence, nodes)[start:overfetch],
+                        cast(Sequence, nodes)[
+                            slice_metadata.start : slice_metadata.overfetch
+                        ],
                     )
                 except TypeError:
                     # TODO: Why mypy isn't narrowing this based on the if above?
                     assert isinstance(nodes, (AsyncIterator, AsyncIterable))
                     iterator = aislice(
                         nodes,
-                        start,
-                        overfetch,
+                        slice_metadata.start,
+                        slice_metadata.overfetch,
                     )
 
                 # The slice above might return an object that now is not async
@@ -880,7 +847,7 @@ class ListConnection(Connection[NodeType]):
                     edges: List[Edge] = [
                         edge_class.resolve_edge(
                             cls.resolve_node(v, info=info, **kwargs),
-                            cursor=start + i,
+                            cursor=slice_metadata.start + i,
                         )
                         async for i, v in aenumerate(iterator)
                     ]
@@ -888,17 +855,20 @@ class ListConnection(Connection[NodeType]):
                     edges: List[Edge] = [  # type: ignore[no-redef]
                         edge_class.resolve_edge(
                             cls.resolve_node(v, info=info, **kwargs),
-                            cursor=start + i,
+                            cursor=slice_metadata.start + i,
                         )
                         for i, v in enumerate(iterator)
                     ]
 
-                has_previous_page = start > 0
-                if expected is not None and len(edges) == expected + 1:
+                has_previous_page = slice_metadata.start > 0
+                if (
+                    slice_metadata.expected is not None
+                    and len(edges) == slice_metadata.expected + 1
+                ):
                     # Remove the overfetched result
                     edges = edges[:-1]
                     has_next_page = True
-                elif end == sys.maxsize:
+                elif slice_metadata.end == sys.maxsize:
                     # Last was asked without any after/before
                     assert last is not None
                     original_len = len(edges)
@@ -923,14 +893,14 @@ class ListConnection(Connection[NodeType]):
         try:
             iterator = cast(
                 Union[Iterator[NodeType], Iterable[NodeType]],
-                cast(Sequence, nodes)[start:overfetch],
+                cast(Sequence, nodes)[slice_metadata.start : slice_metadata.overfetch],
             )
         except TypeError:
             assert isinstance(nodes, (Iterable, Iterator))
             iterator = itertools.islice(
                 nodes,
-                start,
-                overfetch,
+                slice_metadata.start,
+                slice_metadata.overfetch,
             )
 
         if not should_resolve_list_connection_edges(info):
@@ -947,17 +917,20 @@ class ListConnection(Connection[NodeType]):
         edges = [
             edge_class.resolve_edge(
                 cls.resolve_node(v, info=info, **kwargs),
-                cursor=start + i,
+                cursor=slice_metadata.start + i,
             )
             for i, v in enumerate(iterator)
         ]
 
-        has_previous_page = start > 0
-        if expected is not None and len(edges) == expected + 1:
+        has_previous_page = slice_metadata.start > 0
+        if (
+            slice_metadata.expected is not None
+            and len(edges) == slice_metadata.expected + 1
+        ):
             # Remove the overfetched result
             edges = edges[:-1]
             has_next_page = True
-        elif end == sys.maxsize:
+        elif slice_metadata.end == sys.maxsize:
             # Last was asked without any after/before
             assert last is not None
             original_len = len(edges)

{strawberry_graphql-0.233.3 → strawberry_graphql-0.234.1}/strawberry/relay/utils.py

@@ -1,11 +1,17 @@
+from __future__ import annotations
+
 import base64
-from typing import Any, Tuple, Union
-from typing_extensions import assert_never
+import dataclasses
+import sys
+from typing import TYPE_CHECKING, Any, Tuple, Union
+from typing_extensions import Self, assert_never
 
-from strawberry.types.info import Info
 from strawberry.types.nodes import InlineFragment, Selection
 from strawberry.types.types import StrawberryObjectDefinition
 
+if TYPE_CHECKING:
+    from strawberry.types.info import Info
+
 
 def from_base64(value: str) -> Tuple[str, str]:
     """Parse the base64 encoded relay value.
@@ -102,3 +108,82 @@ def should_resolve_list_connection_edges(info: Info) -> bool:
             if _check_selection(selection):
                 return True
     return False
+
+
+@dataclasses.dataclass
+class SliceMetadata:
+    start: int
+    end: int
+    expected: int | None
+
+    @property
+    def overfetch(self) -> int:
+        # Overfetch by 1 to check if we have a next result
+        return self.end + 1 if self.end != sys.maxsize else self.end
+
+    @classmethod
+    def from_arguments(
+        cls,
+        info: Info,
+        *,
+        before: str | None = None,
+        after: str | None = None,
+        first: int | None = None,
+        last: int | None = None,
+    ) -> Self:
+        """Get the slice metadata to use on ListConnection."""
+        from strawberry.relay.types import PREFIX
+
+        max_results = info.schema.config.relay_max_results
+        start = 0
+        end: int | None = None
+
+        if after:
+            after_type, after_parsed = from_base64(after)
+            if after_type != PREFIX:
+                raise TypeError("Argument 'after' contains a non-existing value.")
+
+            start = int(after_parsed) + 1
+        if before:
+            before_type, before_parsed = from_base64(before)
+            if before_type != PREFIX:
+                raise TypeError("Argument 'before' contains a non-existing value.")
+            end = int(before_parsed)
+
+        if isinstance(first, int):
+            if first < 0:
+                raise ValueError("Argument 'first' must be a non-negative integer.")
+
+            if first > max_results:
+                raise ValueError(
+                    f"Argument 'first' cannot be higher than {max_results}."
+                )
+
+            if end is not None:
+                start = max(0, end - 1)
+
+            end = start + first
+        if isinstance(last, int):
+            if last < 0:
+                raise ValueError("Argument 'last' must be a non-negative integer.")
+
+            if last > max_results:
+                raise ValueError(
+                    f"Argument 'last' cannot be higher than {max_results}."
+                )
+
+            if end is not None:
+                start = max(start, end - last)
+            else:
+                end = sys.maxsize
+
+        if end is None:
+            end = start + max_results
+
+        expected = end - start if end != sys.maxsize else None
+
+        return cls(
+            start=start,
+            end=end,
+            expected=expected,
+        )