Add new strawberry.Parent annotation to support static resolvers with non-self types.

RELEASE.md

@@ -0,0 +1,22 @@
+Release type: minor
+
+Adds new strawberry.Parent type annotation to support resolvers without use of self.
+
+E.g.
+
+@dataclass
+class UserRow:
+    id_: str
+
+@strawberry.type
+class User:
+    @strawberry.field
+    @staticmethod
+    async def name(parent: strawberry.Parent[UserRow]) -> str:
+        return f"User Number {parent.id}"
+
+@strawberry.type
+class Query:
+    @strawberry.field
+    def user(self) -> User:
+        return UserRow(id_="1234")

docs/errors/conflicting-arguments.md

@@ -0,0 +1,26 @@
+---
+title: Conflicting Arguments Error
+---
+
+# Conflicting Arguments Error
+
+## Description
+
+This error is thrown when you define a resolver with multiple arguments that
+conflict with each other, like "self", "root", or any arguments annotated with
+strawberry.Parent.
+
+For example the following code will throw this error:
+
+```python
+import strawberry
+
+
+@strawberry.type
+class Query:
+    @strawberry.field
+    def hello(
+        self, root, parent: strawberry.Parent[str]
+    ) -> str:  #  <-- self, root, and parent all identify the same input
+        return f"hello world"
+```

strawberry/__init__.py

@@ -8,6 +8,7 @@
 from .lazy_type import LazyType, lazy
 from .mutation import mutation, subscription
 from .object_type import asdict, input, interface, type
+from .parent import Parent
 from .permission import BasePermission
 from .private import Private
 from .scalars import ID
@@ -23,6 +24,7 @@
     "UNSET",
     "lazy",
     "LazyType",
+    "Parent",
     "Private",
     "Schema",
     "argument",

strawberry/exceptions/__init__.py

@@ -5,6 +5,7 @@
 
 from graphql import GraphQLError
 
+from .conflicting_arguments import ConflictingArgumentsError
 from .duplicated_type_name import DuplicatedTypeName
 from .exception import StrawberryException, UnableToFindExceptionSource
 from .handler import setup_exception_handler
@@ -178,6 +179,7 @@ class StrawberryGraphQLError(GraphQLError):
     "WrongNumberOfResultsReturned",
     "FieldWithResolverAndDefaultValueError",
     "FieldWithResolverAndDefaultFactoryError",
+    "ConflictingArgumentsError",
     "MissingQueryError",
     "InvalidArgumentTypeError",
     "InvalidDefaultFactoryError",

strawberry/exceptions/conflicting_arguments.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from functools import cached_property
+from typing import TYPE_CHECKING, List, Optional
+
+from .exception import StrawberryException
+from .utils.source_finder import SourceFinder
+
+if TYPE_CHECKING:
+    from strawberry.types.fields.resolver import StrawberryResolver
+
+    from .exception_source import ExceptionSource
+
+
+class ConflictingArgumentsError(StrawberryException):
+    def __init__(
+        self,
+        resolver: StrawberryResolver,
+        arguments: List[str],
+    ):
+        self.function = resolver.wrapped_func
+        self.argument_names = arguments
+
+        self.message = (
+            f"Arguments {self.argument_names_str} define conflicting resources. "
+            "Only one of these arguments may be defined per resolver."
+        )
+
+        self.rich_message = self.message
+
+        self.suggestion = (
+            f"Only one of {self.argument_names_str} may be defined per resolver."
+        )
+
+        self.annotation_message = self.suggestion
+
+    @cached_property
+    def argument_names_str(self) -> str:
+        return (
+            ", ".join(f'"{name}"' for name in self.argument_names[:-1])
+            + " and "
+            + f'"{self.argument_names[-1]}"'
+        )
+
+    @cached_property
+    def exception_source(self) -> Optional[ExceptionSource]:
+        if self.function is None:
+            return None  # pragma: no cover
+
+        source_finder = SourceFinder()
+
+        return source_finder.find_argument_from_object(
+            self.function, self.argument_names[1]  # type: ignore
+        )

strawberry/parent.py

@@ -0,0 +1,39 @@
+from typing import TypeVar
+from typing_extensions import Annotated
+
+
+class StrawberryParent:
+    ...
+
+
+T = TypeVar("T")
+
+Parent = Annotated[T, StrawberryParent()]
+Parent.__doc__ = """Represents a parameter holding the parent resolver's value.
+
+This can be used when defining a resolver on a type when the parent isn't expected
+to return the type itself.
+
+Example:
+
+>>> import strawberry
+>>> from dataclasses import dataclass
+>>>
+>>> @dataclass
+>>> class UserRow:
+...     id_: str
+...
+>>> @strawberry.type
+... class User:
+...     @strawberry.field
+...     @staticmethod
+...     async def name(parent: strawberry.Parent[UserRow]) -> str:
+...         return f"User Number {parent.id}"
+...
+>>> @strawberry.type
+>>> class Query:
+...     @strawberry.field
+...     def user(self) -> User:
+...         return UserRow(id_="1234")
+...
+"""

strawberry/private.py

@@ -1,5 +1,7 @@
 from typing import TypeVar
-from typing_extensions import Annotated, get_args, get_origin
+from typing_extensions import Annotated
+
+from strawberry.utils.typing import type_has_annotation
 
 
 class StrawberryPrivate:
@@ -22,9 +24,4 @@ class StrawberryPrivate:
 
 
 def is_private(type_: object) -> bool:
-    if get_origin(type_) is Annotated:
-        return any(
-            isinstance(argument, StrawberryPrivate) for argument in get_args(type_)
-        )
-
-    return False
+    return type_has_annotation(type_, StrawberryPrivate)

strawberry/schema/schema_converter.py

@@ -574,7 +574,7 @@ def _get_arguments(
             # the following code allows to omit info and root arguments
             # by inspecting the original resolver arguments,
             # if it asks for self, the source will be passed as first argument
-            # if it asks for root, the source it will be passed as kwarg
+            # if it asks for root or parent, the source will be passed as kwarg
             # if it asks for info, the info will be passed as kwarg
 
             args = []
@@ -583,12 +583,13 @@ def _get_arguments(
                 if field.base_resolver.self_parameter:
                     args.append(source)
 
-                root_parameter = field.base_resolver.root_parameter
-                if root_parameter:
+                if parent_parameter := field.base_resolver.parent_parameter:
+                    kwargs[parent_parameter.name] = source
+
+                if root_parameter := field.base_resolver.root_parameter:
                     kwargs[root_parameter.name] = source
 
-                info_parameter = field.base_resolver.info_parameter
-                if info_parameter:
+                if info_parameter := field.base_resolver.info_parameter:
                     kwargs[info_parameter.name] = info
 
             return args, kwargs

strawberry/types/fields/resolver.py

@@ -20,13 +20,18 @@
     Union,
     cast,
 )
-from typing_extensions import Annotated, Protocol, get_args, get_origin
+from typing_extensions import Annotated, Protocol, get_origin
 
 from strawberry.annotation import StrawberryAnnotation
 from strawberry.arguments import StrawberryArgument
-from strawberry.exceptions import MissingArgumentsAnnotationsError
+from strawberry.exceptions import (
+    ConflictingArgumentsError,
+    MissingArgumentsAnnotationsError,
+)
+from strawberry.parent import StrawberryParent
 from strawberry.type import StrawberryType, has_object_definition
 from strawberry.types.info import Info
+from strawberry.utils.typing import type_has_annotation
 
 if TYPE_CHECKING:
     import builtins
@@ -95,17 +100,20 @@ class ReservedType(NamedTuple):
     """Define a reserved type by name or by type.
 
     To preserve backwards-comaptibility, if an annotation was defined but does not match
-    :attr:`type`, then the name is used as a fallback.
+    :attr:`type`, then the name is used as a fallback if available.
     """
 
-    name: str
+    name: str | None
     type: type
 
     def find(
         self,
         parameters: Tuple[inspect.Parameter, ...],
         resolver: StrawberryResolver[Any],
     ) -> Optional[inspect.Parameter]:
+        # Go through all the types even after we've found one so we can
+        # give a helpful error message if someone uses the type more than once.
+        type_parameters = []
         for parameter in parameters:
             annotation = resolver.strawberry_annotations[parameter]
             if isinstance(annotation, StrawberryAnnotation):
@@ -115,9 +123,19 @@ def find(
                     continue
                 else:
                     if self.is_reserved_type(evaled_annotation):
-                        return parameter
+                        type_parameters.append(parameter)
+
+        if len(type_parameters) > 1:
+            raise ConflictingArgumentsError(
+                resolver, [parameter.name for parameter in type_parameters]
+            )
+
+        if type_parameters:
+            return type_parameters[0]
 
         # Fallback to matching by name
+        if not self.name:
+            return None
         reserved_name = ReservedName(name=self.name).find(parameters, resolver)
         if reserved_name:
             warning = DeprecationWarning(
@@ -135,7 +153,7 @@ def is_reserved_type(self, other: builtins.type) -> bool:
         origin = cast(type, get_origin(other)) or other
         if origin is Annotated:
             # Handle annotated arguments such as Private[str] and DirectiveValue[str]
-            return any(isinstance(argument, self.type) for argument in get_args(other))
+            return type_has_annotation(other, self.type)
         else:
             # Handle both concrete and generic types (i.e Info, and Info[Any, Any])
             return (
@@ -149,6 +167,7 @@ def is_reserved_type(self, other: builtins.type) -> bool:
 CLS_PARAMSPEC = ReservedNameBoundParameter("cls")
 ROOT_PARAMSPEC = ReservedName("root")
 INFO_PARAMSPEC = ReservedType("info", Info)
+PARENT_PARAMSPEC = ReservedType(name=None, type=StrawberryParent)
 
 T = TypeVar("T")
 
@@ -159,6 +178,7 @@ class StrawberryResolver(Generic[T]):
         CLS_PARAMSPEC,
         ROOT_PARAMSPEC,
         INFO_PARAMSPEC,
+        PARENT_PARAMSPEC,
     )
 
     def __init__(
@@ -213,6 +233,23 @@ 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
+        )
+
+        if (
+            conflicting_arguments := (
+                populated_reserved_parameters
+                & {SELF_PARAMSPEC, ROOT_PARAMSPEC, PARENT_PARAMSPEC}
+            )
+        ) and len(conflicting_arguments) > 1:
+            raise ConflictingArgumentsError(
+                self,
+                [
+                    cast(Parameter, self.reserved_parameters[key]).name
+                    for key in conflicting_arguments
+                ],
+            )
 
         missing_annotations: List[str] = []
         arguments: List[StrawberryArgument] = []
@@ -246,6 +283,10 @@ def root_parameter(self) -> Optional[inspect.Parameter]:
     def self_parameter(self) -> Optional[inspect.Parameter]:
         return self.reserved_parameters.get(SELF_PARAMSPEC)
 
+    @cached_property
+    def parent_parameter(self) -> Optional[inspect.Parameter]:
+        return self.reserved_parameters.get(PARENT_PARAMSPEC)
+
     @cached_property
     def name(self) -> str:
         # TODO: What to do if resolver is a lambda?

strawberry/utils/typing.py

@@ -182,6 +182,14 @@ def is_classvar(cls: type, annotation: Union[ForwardRef, str]) -> bool:
     )
 
 
+def type_has_annotation(type_: object, annotation: Type) -> bool:
+    """Returns True if the type_ has been annotated with annotation."""
+    if get_origin(type_) is Annotated:
+        return any(isinstance(argument, annotation) for argument in get_args(type_))
+
+    return False
+
+
 def get_parameters(annotation: Type) -> Union[Tuple[object], Tuple[()]]:
     if (
         isinstance(annotation, _GenericAlias)