strawberry-graphql 0.233.2__tar.gz → 0.234.0__tar.gz

{strawberry_graphql-0.233.2 → strawberry_graphql-0.234.0}/PKG-INFO

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

{strawberry_graphql-0.233.2 → strawberry_graphql-0.234.0}/pyproject.toml

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

{strawberry_graphql-0.233.2 → strawberry_graphql-0.234.0}/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
@@ -790,61 +795,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 +820,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 +839,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 +847,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 +885,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 +909,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.2 → strawberry_graphql-0.234.0}/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,
+        )

{strawberry_graphql-0.233.2 → strawberry_graphql-0.234.0}/strawberry/types/fields/resolver.py

@@ -231,30 +231,25 @@ class StrawberryResolver(Generic[T]):
     @cached_property
     def arguments(self) -> List[StrawberryArgument]:
         """Resolver arguments exposed in the GraphQL Schema."""
-        parameters = self.signature.parameters.values()
-        reserved_parameters = set(self.reserved_parameters.values())
-        populated_reserved_parameters = set(
-            key for key, value in self.reserved_parameters.items() if value is not None
-        )
+        root_parameter = self.reserved_parameters.get(ROOT_PARAMSPEC)
+        parent_parameter = self.reserved_parameters.get(PARENT_PARAMSPEC)
 
+        # TODO: Maybe use SELF_PARAMSPEC in the future? Right now
+        # it would prevent some common pattern for integrations
+        # (e.g. django) of typing the `root` parameters as the
+        # type of the real object being used
         if (
-            conflicting_arguments := (
-                populated_reserved_parameters
-                # TODO: Maybe use SELF_PARAMSPEC in the future? Right now
-                # it would prevent some common pattern for integrations
-                # (e.g. django) of typing the `root` parameters as the
-                # type of the real object being used
-                & {ROOT_PARAMSPEC, PARENT_PARAMSPEC}
-            )
-        ) and len(conflicting_arguments) > 1:
+            root_parameter is not None
+            and parent_parameter is not None
+            and root_parameter.name != parent_parameter.name
+        ):
             raise ConflictingArgumentsError(
                 self,
-                [
-                    cast(Parameter, self.reserved_parameters[key]).name
-                    for key in conflicting_arguments
-                ],
+                [root_parameter.name, parent_parameter.name],
             )
 
+        parameters = self.signature.parameters.values()
+        reserved_parameters = set(self.reserved_parameters.values())
         missing_annotations: List[str] = []
         arguments: List[StrawberryArgument] = []
         user_parameters = (p for p in parameters if p not in reserved_parameters)