strawberry-graphql 0.190.0.dev1687447182__py3-none-any.whl → 0.192.1__py3-none-any.whl

strawberry/permission.py

@@ -1,184 +1,21 @@
 from __future__ import annotations
 
-import abc
-from inspect import iscoroutinefunction
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Awaitable,
-    Dict,
-    List,
-    Optional,
-    Type,
-    Union,
-)
-
-from strawberry.exceptions import StrawberryGraphQLError
-from strawberry.exceptions.permission_fail_silently_requires_optional import (
-    PermissionFailSilentlyRequiresOptionalError,
-)
-from strawberry.extensions import FieldExtension
-from strawberry.schema_directive import Location, StrawberrySchemaDirective
-from strawberry.type import StrawberryList, StrawberryOptional
-from strawberry.utils.await_maybe import await_maybe
-from strawberry.utils.cached_property import cached_property
+from typing import TYPE_CHECKING, Any, Awaitable, Optional, Union
 
 if TYPE_CHECKING:
-    from graphql import GraphQLError, GraphQLErrorExtensions
-
-    from strawberry.extensions.field_extension import (
-        AsyncExtensionResolver,
-        SyncExtensionResolver,
-    )
-    from strawberry.field import StrawberryField
-    from strawberry.types import Info
+    from strawberry.types.info import Info
 
 
-class BasePermission(abc.ABC):
+class BasePermission:
     """
     Base class for creating permissions
     """
 
     message: Optional[str] = None
 
-    error_extensions: Optional[GraphQLErrorExtensions] = None
-
-    error_class: Type[GraphQLError] = StrawberryGraphQLError
-
-    _schema_directive: Optional[object] = None
-
-    @abc.abstractmethod
     def has_permission(
         self, source: Any, info: Info, **kwargs: Any
     ) -> Union[bool, Awaitable[bool]]:
         raise NotImplementedError(
             "Permission classes should override has_permission method"
         )
-
-    def handle_no_permission(self) -> None:
-        """
-        Default error raising for permissions.
-        This can be overridden to customize the behavior.
-        """
-
-        # Instantiate error class
-        error = self.error_class(self.message or "")
-
-        if self.error_extensions:
-            # Add our extensions to the error
-            if not error.extensions:
-                error.extensions = dict()
-            error.extensions.update(self.error_extensions)
-
-        raise error
-
-    @property
-    def schema_directive(self) -> object:
-        if not self._schema_directive:
-
-            class AutoDirective:
-                __strawberry_directive__ = StrawberrySchemaDirective(
-                    self.__class__.__name__,
-                    self.__class__.__name__,
-                    [Location.FIELD_DEFINITION],
-                    [],
-                )
-
-            self._schema_directive = AutoDirective()
-
-        return self._schema_directive
-
-
-class PermissionExtension(FieldExtension):
-    """
-    Handles permissions for a field
-    Instantiate this as a field extension with all of the permissions you want to apply
-
-    fail_silently: bool = False will return None or [] if the permission fails
-    instead of raising an exception. This is only valid for optional or list fields.
-
-    NOTE:
-    Currently, this is automatically added to the field, when using
-    field.permission_classes
-    This is deprecated behavior, please manually add the extension to field.extensions
-    """
-
-    def __init__(
-        self,
-        permissions: List[BasePermission],
-        use_directives: bool = True,
-        fail_silently: bool = False,
-    ):
-        self.permissions = permissions
-        self.fail_silently = fail_silently
-        self.return_empty_list = False
-        self.use_directives = use_directives
-
-    def apply(self, field: StrawberryField) -> None:
-        """
-        Applies all of the permission directives to the schema
-        and sets up silent permissions
-        """
-        if self.use_directives:
-            field.directives.extend(
-                p.schema_directive for p in self.permissions if p.schema_directive
-            )
-        # We can only fail silently if the field is optional or a list
-        if self.fail_silently:
-            if isinstance(field.type, StrawberryOptional):
-                if isinstance(field.type.of_type, StrawberryList):
-                    self.return_empty_list = True
-            elif isinstance(field.type, StrawberryList):
-                self.return_empty_list = True
-            else:
-                errror = PermissionFailSilentlyRequiresOptionalError(field)
-                a = errror.exception_source
-                raise errror
-
-    def _handle_no_permission(self, permission: BasePermission) -> Any:
-        if self.fail_silently:
-            return [] if self.return_empty_list else None
-        return permission.handle_no_permission()
-
-    def resolve(
-        self,
-        next_: SyncExtensionResolver,
-        source: Any,
-        info: Info,
-        **kwargs: Dict[str, Any],
-    ) -> Any:
-        """
-        Checks if the permission should be accepted and
-        raises an exception if not
-        """
-        for permission in self.permissions:
-            if not permission.has_permission(source, info, **kwargs):
-                return self._handle_no_permission(permission)
-        return next_(source, info, **kwargs)
-
-    async def resolve_async(
-        self,
-        next_: AsyncExtensionResolver,
-        source: Any,
-        info: Info,
-        **kwargs: Dict[str, Any],
-    ) -> Any:
-        for permission in self.permissions:
-            has_permission = await await_maybe(
-                permission.has_permission(source, info, **kwargs)
-            )
-
-            if not has_permission:
-                return self._handle_no_permission(permission)
-        return await next_(source, info, **kwargs)
-
-    @cached_property
-    def supports_sync(self) -> bool:
-        """The Permission extension always supports async checking using await_maybe,
-        but only supports sync checking if there are no async permissions"""
-        async_permissions = [
-            True
-            for permission in self.permissions
-            if iscoroutinefunction(permission.has_permission)
-        ]
-        return len(async_permissions) == 0

strawberry/relay/fields.py

@@ -235,6 +235,8 @@ class ConnectionExtension(FieldExtension):
         # for subscription support, but we can't use it here. Maybe we can refactor
         # this in the future.
         resolver_type = field.base_resolver.signature.return_annotation
+        if isinstance(resolver_type, str):
+            resolver_type = ForwardRef(resolver_type)
         if isinstance(resolver_type, ForwardRef):
             resolver_type = eval_type(
                 resolver_type,

strawberry/relay/types.py

@@ -11,6 +11,7 @@ from typing import (
     AsyncIterator,
     Awaitable,
     ClassVar,
+    ForwardRef,
     Generic,
     Iterable,
     Iterator,
@@ -38,16 +39,16 @@ from strawberry.object_type import interface, type
 from strawberry.private import StrawberryPrivate
 from strawberry.relay.exceptions import NodeIDAnnotationError
 from strawberry.type import StrawberryContainer, get_object_definition
+from strawberry.types.info import Info  # noqa: TCH001
 from strawberry.types.types import StrawberryObjectDefinition
 from strawberry.utils.aio import aenumerate, aislice, resolve_awaitable
 from strawberry.utils.inspect import in_async_context
-from strawberry.utils.typing import eval_type
+from strawberry.utils.typing import eval_type, is_classvar
 
 from .utils import from_base64, to_base64
 
 if TYPE_CHECKING:
     from strawberry.scalars import ID
-    from strawberry.types.info import Info
     from strawberry.utils.await_maybe import AwaitableOrValue
 
 _T = TypeVar("_T")
@@ -407,7 +408,16 @@ class Node:
             base_namespace = sys.modules[base.__module__].__dict__
 
             for attr_name, attr in getattr(base, "__annotations__", {}).items():
-                evaled = eval_type(attr, globalns=base_namespace)
+                # Some ClassVar might raise TypeError when being resolved
+                # on some python versions. This is fine to skip since
+                # we are not interested in ClassVars here
+                if is_classvar(base, attr):
+                    continue
+
+                evaled = eval_type(
+                    ForwardRef(attr) if isinstance(attr, str) else attr,
+                    globalns=base_namespace,
+                )
 
                 if get_origin(evaled) is Annotated and any(
                     isinstance(a, NodeIDPrivate) for a in get_args(evaled)
@@ -845,7 +855,7 @@ class ListConnection(Connection[NodeType]):
         field_def = type_def.get_field("edges")
         assert field_def
 
-        field = field_def.type
+        field = field_def.resolve_type(type_definition=type_def)
         while isinstance(field, StrawberryContainer):
             field = field.of_type
 

strawberry/schema/schema.py

@@ -23,7 +23,7 @@ from graphql import (
     parse,
     validate_schema,
 )
-from graphql.subscription import subscribe
+from graphql.execution import subscribe
 from graphql.type.directives import specified_directives
 
 from strawberry import relay

strawberry/schema/schema_converter.py

@@ -8,6 +8,7 @@ from typing import (
     Any,
     Callable,
     Dict,
+    Generic,
     List,
     Optional,
     Tuple,
@@ -16,6 +17,7 @@ from typing import (
     Union,
     cast,
 )
+from typing_extensions import Protocol
 
 from graphql import (
     GraphQLArgument,
@@ -53,6 +55,8 @@ from strawberry.schema.types.scalar import _make_scalar_type
 from strawberry.type import (
     StrawberryList,
     StrawberryOptional,
+    StrawberryType,
+    WithStrawberryObjectDefinition,
     has_object_definition,
 )
 from strawberry.types.info import Info
@@ -83,7 +87,56 @@ if TYPE_CHECKING:
     from strawberry.field import StrawberryField
     from strawberry.schema.config import StrawberryConfig
     from strawberry.schema_directive import StrawberrySchemaDirective
-    from strawberry.type import StrawberryType
+
+
+FieldType = TypeVar(
+    "FieldType", bound=Union[GraphQLField, GraphQLInputField], covariant=True
+)
+
+
+class FieldConverterProtocol(Generic[FieldType], Protocol):
+    def __call__(  # pragma: no cover
+        self,
+        field: StrawberryField,
+        *,
+        override_type: Optional[
+            Union[StrawberryType, Type[WithStrawberryObjectDefinition]]
+        ] = None,
+    ) -> FieldType:
+        ...
+
+
+def _get_thunk_mapping(
+    type_definition: StrawberryObjectDefinition,
+    name_converter: Callable[[StrawberryField], str],
+    field_converter: FieldConverterProtocol[FieldType],
+) -> Dict[str, FieldType]:
+    """Create a GraphQL core `ThunkMapping` mapping of field names to field types.
+
+    This method filters out remaining `strawberry.Private` annotated fields that
+    could not be filtered during the initialization of a `TypeDefinition` due to
+    postponed type-hint evaluation (PEP-563). Performing this filtering now (at
+    schema conversion time) ensures that all types to be included in the schema
+    should have already been resolved.
+
+    Raises:
+        TypeError: If the type of a field in ``fields`` is `UNRESOLVED`
+    """
+    thunk_mapping: Dict[str, FieldType] = {}
+
+    for field in type_definition.fields:
+        field_type = field.resolve_type(type_definition=type_definition)
+
+        if field_type is UNRESOLVED:
+            raise UnresolvedFieldTypeError(type_definition, field)
+
+        if not is_private(field_type):
+            thunk_mapping[name_converter(field)] = field_converter(
+                field,
+                override_type=field_type,
+            )
+
+    return thunk_mapping
 
 
 # graphql-core expects a resolver for an Enum type to return
@@ -248,11 +301,20 @@ class GraphQLCoreConverter:
             },
         )
 
-    def from_field(self, field: StrawberryField) -> GraphQLField:
+    def from_field(
+        self,
+        field: StrawberryField,
+        *,
+        override_type: Optional[
+            Union[StrawberryType, Type[WithStrawberryObjectDefinition]]
+        ] = None,
+    ) -> GraphQLField:
         # self.from_resolver needs to be called before accessing field.type because
         # in there a field extension might want to change the type during its apply
         resolver = self.from_resolver(field)
-        field_type = cast("GraphQLOutputType", self.from_maybe_optional(field.type))
+        field_type = cast(
+            "GraphQLOutputType", self.from_maybe_optional(override_type or field.type)
+        )
         subscribe = None
 
         if field.is_subscription:
@@ -276,8 +338,17 @@ class GraphQLCoreConverter:
             },
         )
 
-    def from_input_field(self, field: StrawberryField) -> GraphQLInputField:
-        field_type = cast("GraphQLInputType", self.from_maybe_optional(field.type))
+    def from_input_field(
+        self,
+        field: StrawberryField,
+        *,
+        override_type: Optional[
+            Union[StrawberryType, Type[WithStrawberryObjectDefinition]]
+        ] = None,
+    ) -> GraphQLInputField:
+        field_type = cast(
+            "GraphQLInputType", self.from_maybe_optional(override_type or field.type)
+        )
         default_value: object
 
         if field.default_value is UNSET or field.default_value is dataclasses.MISSING:
@@ -295,40 +366,10 @@ class GraphQLCoreConverter:
             },
         )
 
-    FieldType = TypeVar("FieldType", GraphQLField, GraphQLInputField)
-
-    @staticmethod
-    def _get_thunk_mapping(
-        type_definition: StrawberryObjectDefinition,
-        name_converter: Callable[[StrawberryField], str],
-        field_converter: Callable[[StrawberryField], FieldType],
-    ) -> Dict[str, FieldType]:
-        """Create a GraphQL core `ThunkMapping` mapping of field names to field types.
-
-        This method filters out remaining `strawberry.Private` annotated fields that
-        could not be filtered during the initialization of a `TypeDefinition` due to
-        postponed type-hint evaluation (PEP-563). Performing this filtering now (at
-        schema conversion time) ensures that all types to be included in the schema
-        should have already been resolved.
-
-        Raises:
-            TypeError: If the type of a field in ``fields`` is `UNRESOLVED`
-        """
-        thunk_mapping = {}
-
-        for field in type_definition.fields:
-            if field.type is UNRESOLVED:
-                raise UnresolvedFieldTypeError(type_definition, field)
-
-            if not is_private(field.type):
-                thunk_mapping[name_converter(field)] = field_converter(field)
-
-        return thunk_mapping
-
     def get_graphql_fields(
         self, type_definition: StrawberryObjectDefinition
     ) -> Dict[str, GraphQLField]:
-        return self._get_thunk_mapping(
+        return _get_thunk_mapping(
             type_definition=type_definition,
             name_converter=self.config.name_converter.from_field,
             field_converter=self.from_field,
@@ -337,7 +378,7 @@ class GraphQLCoreConverter:
     def get_graphql_input_fields(
         self, type_definition: StrawberryObjectDefinition
     ) -> Dict[str, GraphQLInputField]:
-        return self._get_thunk_mapping(
+        return _get_thunk_mapping(
             type_definition=type_definition,
             name_converter=self.config.name_converter.from_field,
             field_converter=self.from_input_field,
@@ -522,6 +563,31 @@ class GraphQLCoreConverter:
 
             return args, kwargs
 
+        def _check_permissions(source: Any, info: Info, kwargs: Any):
+            """
+            Checks if the permission should be accepted and
+            raises an exception if not
+            """
+            for permission_class in field.permission_classes:
+                permission = permission_class()
+
+                if not permission.has_permission(source, info, **kwargs):
+                    message = getattr(permission, "message", None)
+                    raise PermissionError(message)
+
+        async def _check_permissions_async(source: Any, info: Info, kwargs: Any):
+            for permission_class in field.permission_classes:
+                permission = permission_class()
+                has_permission: bool
+
+                has_permission = await await_maybe(
+                    permission.has_permission(source, info, **kwargs)
+                )
+
+                if not has_permission:
+                    message = getattr(permission, "message", None)
+                    raise PermissionError(message)
+
         def _strawberry_info_from_graphql(info: GraphQLResolveInfo) -> Info:
             return Info(
                 _raw_info=info,
@@ -590,6 +656,7 @@ class GraphQLCoreConverter:
 
         def _resolver(_source: Any, info: GraphQLResolveInfo, **kwargs: Any):
             strawberry_info = _strawberry_info_from_graphql(info)
+            _check_permissions(_source, strawberry_info, kwargs)
 
             return _get_result_with_extensions(
                 _source,
@@ -601,6 +668,7 @@ class GraphQLCoreConverter:
             _source: Any, info: GraphQLResolveInfo, **kwargs: Any
         ):
             strawberry_info = _strawberry_info_from_graphql(info)
+            await _check_permissions_async(_source, strawberry_info, kwargs)
 
             return await await_maybe(
                 _get_result_with_extensions(
@@ -711,7 +779,7 @@ class GraphQLCoreConverter:
             # TypeVars, Annotations, LazyTypes, etc it can't perfectly detect issues at
             # that stage
             if not StrawberryUnion.is_valid_union_type(type_):
-                raise InvalidUnionTypeError(union_name, type_)
+                raise InvalidUnionTypeError(union_name, type_, union_definition=union)
 
         # Don't reevaluate known types
         if union_name in self.type_map:

strawberry/subscriptions/protocols/graphql_transport_ws/handlers.py

@@ -8,7 +8,6 @@ from typing import TYPE_CHECKING, Any, AsyncGenerator, Callable, Dict, List, Opt
 
 from graphql import ExecutionResult as GraphQLExecutionResult
 from graphql import GraphQLError, GraphQLSyntaxError, parse
-from graphql.error.graphql_error import format_error as format_graphql_error
 
 from strawberry.subscriptions.protocols.graphql_transport_ws.types import (
     CompleteMessage,
@@ -245,12 +244,12 @@ class BaseGraphQLTransportWSHandler(ABC):
 
             result_source = get_result_source()
 
-        operation = Operation(self, message.id)
+        operation = Operation(self, message.id, operation_type)
 
         # Handle initial validation errors
         if isinstance(result_source, GraphQLExecutionResult):
             assert result_source.errors
-            payload = [format_graphql_error(result_source.errors[0])]
+            payload = [err.formatted for err in result_source.errors]
             await self.send_message(ErrorMessage(id=message.id, payload=payload))
             self.schema.process_errors(result_source.errors)
             return
@@ -295,14 +294,21 @@ class BaseGraphQLTransportWSHandler(ABC):
     ) -> None:
         try:
             async for result in result_source:
-                if result.errors:
-                    error_payload = [format_graphql_error(err) for err in result.errors]
+                if (
+                    result.errors
+                    and operation.operation_type != OperationType.SUBSCRIPTION
+                ):
+                    error_payload = [err.formatted for err in result.errors]
                     error_message = ErrorMessage(id=operation.id, payload=error_payload)
                     await operation.send_message(error_message)
                     self.schema.process_errors(result.errors)
                     return
                 else:
                     next_payload = {"data": result.data}
+                    if result.errors:
+                        next_payload["errors"] = [
+                            err.formatted for err in result.errors
+                        ]
                     next_message = NextMessage(id=operation.id, payload=next_payload)
                     await operation.send_message(next_message)
         except asyncio.CancelledError:
@@ -312,7 +318,7 @@ class BaseGraphQLTransportWSHandler(ABC):
             # GraphQLErrors are handled by graphql-core and included in the
             # ExecutionResult
             error = GraphQLError(str(error), original_error=error)
-            error_payload = [format_graphql_error(error)]
+            error_payload = [error.formatted]
             error_message = ErrorMessage(id=operation.id, payload=error_payload)
             await operation.send_message(error_message)
             self.schema.process_errors([error])
@@ -358,11 +364,17 @@ class Operation:
     Helps enforce protocol state transition.
     """
 
-    __slots__ = ["handler", "id", "completed", "task"]
+    __slots__ = ["handler", "id", "operation_type", "completed", "task"]
 
-    def __init__(self, handler: BaseGraphQLTransportWSHandler, id: str):
+    def __init__(
+        self,
+        handler: BaseGraphQLTransportWSHandler,
+        id: str,
+        operation_type: OperationType,
+    ):
         self.handler = handler
         self.id = id
+        self.operation_type = operation_type
         self.completed = False
         self.task: Optional[asyncio.Task] = None
 

strawberry/subscriptions/protocols/graphql_transport_ws/types.py

@@ -85,7 +85,7 @@ class NextMessage(GraphQLTransportMessage):
     """
 
     id: str
-    payload: Dict[str, Any]  # TODO: shape like ExecutionResult
+    payload: Dict[str, Any]  # TODO: shape like FormattedExecutionResult
     type: str = "next"
 
     def as_dict(self) -> dict:

strawberry/subscriptions/protocols/graphql_ws/handlers.py

@@ -7,7 +7,6 @@ from typing import TYPE_CHECKING, Any, AsyncGenerator, Dict, Optional, cast
 
 from graphql import ExecutionResult as GraphQLExecutionResult
 from graphql import GraphQLError
-from graphql.error.graphql_error import format_error as format_graphql_error
 
 from strawberry.subscriptions.protocols.graphql_ws import (
     GQL_COMPLETE,
@@ -133,14 +132,14 @@ class BaseGraphQLWSHandler(ABC):
                 root_value=root_value,
             )
         except GraphQLError as error:
-            error_payload = format_graphql_error(error)
+            error_payload = error.formatted
             await self.send_message(GQL_ERROR, operation_id, error_payload)
             self.schema.process_errors([error])
             return
 
         if isinstance(result_source, GraphQLExecutionResult):
             assert result_source.errors
-            error_payload = format_graphql_error(result_source.errors[0])
+            error_payload = result_source.errors[0].formatted
             await self.send_message(GQL_ERROR, operation_id, error_payload)
             self.schema.process_errors(result_source.errors)
             return
@@ -168,9 +167,7 @@ class BaseGraphQLWSHandler(ABC):
             async for result in result_source:
                 payload = {"data": result.data}
                 if result.errors:
-                    payload["errors"] = [
-                        format_graphql_error(err) for err in result.errors
-                    ]
+                    payload["errors"] = [err.formatted for err in result.errors]
                 await self.send_message(GQL_DATA, operation_id, payload)
                 # log errors after send_message to prevent potential
                 # slowdown of sending result
@@ -186,7 +183,7 @@ class BaseGraphQLWSHandler(ABC):
             await self.send_message(
                 GQL_DATA,
                 operation_id,
-                {"data": None, "errors": [format_graphql_error(error)]},
+                {"data": None, "errors": [error.formatted]},
             )
             self.schema.process_errors([error])
 

strawberry/type.py

@@ -13,7 +13,7 @@ from typing import (
     Union,
     overload,
 )
-from typing_extensions import Literal, Protocol
+from typing_extensions import Literal, Protocol, Self
 
 from strawberry.utils.typing import is_concrete_generic
 
@@ -113,7 +113,7 @@ class StrawberryContainer(StrawberryType):
         type_var_map: Mapping[
             TypeVar, Union[StrawberryType, Type[WithStrawberryObjectDefinition]]
         ],
-    ) -> StrawberryType:
+    ) -> Self:
         of_type_copy = self.of_type
 
         if has_object_definition(self.of_type):