strawberry-graphql 0.239.1__py3-none-any.whl → 0.240.0__py3-none-any.whl

strawberry/channels/testing.py

@@ -144,9 +144,9 @@ class GraphQLWebsocketCommunicator(WebsocketCommunicator):
             message_type = response["type"]
             if message_type == NextMessage.type:
                 payload = NextMessage(**response).payload
-                ret = ExecutionResult(payload["data"], None)
+                ret = ExecutionResult(payload.get("data"), None)
                 if "errors" in payload:
-                    ret.errors = self.process_errors(payload["errors"])
+                    ret.errors = self.process_errors(payload.get("errors") or [])
                 ret.extensions = payload.get("extensions", None)
                 yield ret
             elif message_type == ErrorMessage.type:

strawberry/dataloader.py

@@ -208,14 +208,11 @@ class DataLoader(Generic[K, T]):
 
 
 def should_create_new_batch(loader: DataLoader, batch: Batch) -> bool:
-    if (
+    return bool(
         batch.dispatched
         or loader.max_batch_size
         and len(batch) >= loader.max_batch_size
-    ):
-        return True
-
-    return False
+    )
 
 
 def get_current_batch(loader: DataLoader) -> Batch:

strawberry/extensions/base_extension.py

@@ -21,9 +21,11 @@ class LifecycleStep(Enum):
 class SchemaExtension:
     execution_context: ExecutionContext
 
-    def __init__(self, *, execution_context: ExecutionContext) -> None:
-        self.execution_context = execution_context
-
+    # to support extensions that still use the old signature
+    # we have an optional argument here for ease of initialization.
+    def __init__(
+        self, *, execution_context: ExecutionContext | None = None
+    ) -> None: ...
     def on_operation(  # type: ignore
         self,
     ) -> AsyncIteratorOrIterator[None]:  # pragma: no cover
@@ -61,6 +63,11 @@ class SchemaExtension:
     def get_results(self) -> AwaitableOrValue[Dict[str, Any]]:
         return {}
 
+    @classmethod
+    def _implements_resolve(cls) -> bool:
+        """Whether the extension implements the resolve method."""
+        return cls.resolve is not SchemaExtension.resolve
+
 
 Hook = Callable[[SchemaExtension], AsyncIteratorOrIterator[None]]
 

strawberry/extensions/runner.py

@@ -1,9 +1,7 @@
 from __future__ import annotations
 
 import inspect
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type, Union
-
-from graphql import MiddlewareManager
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
 from strawberry.extensions.context import (
     ExecutingContextManager,
@@ -13,11 +11,11 @@ from strawberry.extensions.context import (
 )
 from strawberry.utils.await_maybe import await_maybe
 
-from . import SchemaExtension
-
 if TYPE_CHECKING:
     from strawberry.types import ExecutionContext
 
+    from . import SchemaExtension
+
 
 class SchemaExtensionsRunner:
     extensions: List[SchemaExtension]
@@ -25,27 +23,10 @@ class SchemaExtensionsRunner:
     def __init__(
         self,
         execution_context: ExecutionContext,
-        extensions: Optional[
-            List[Union[Type[SchemaExtension], SchemaExtension]]
-        ] = None,
+        extensions: Optional[List[SchemaExtension]] = None,
     ) -> None:
         self.execution_context = execution_context
-
-        if not extensions:
-            extensions = []
-
-        init_extensions: List[SchemaExtension] = []
-
-        for extension in extensions:
-            # If the extension has already been instantiated then set the
-            # `execution_context` attribute
-            if isinstance(extension, SchemaExtension):
-                extension.execution_context = execution_context
-                init_extensions.append(extension)
-            else:
-                init_extensions.append(extension(execution_context=execution_context))
-
-        self.extensions = init_extensions
+        self.extensions = extensions or []
 
     def operation(self) -> OperationContextManager:
         return OperationContextManager(self.extensions)
@@ -61,29 +42,19 @@ class SchemaExtensionsRunner:
 
     def get_extensions_results_sync(self) -> Dict[str, Any]:
         data: Dict[str, Any] = {}
-
         for extension in self.extensions:
             if inspect.iscoroutinefunction(extension.get_results):
                 msg = "Cannot use async extension hook during sync execution"
                 raise RuntimeError(msg)
-
             data.update(extension.get_results())  # type: ignore
 
         return data
 
-    async def get_extensions_results(self) -> Dict[str, Any]:
+    async def get_extensions_results(self, ctx: ExecutionContext) -> Dict[str, Any]:
         data: Dict[str, Any] = {}
 
         for extension in self.extensions:
-            results = await await_maybe(extension.get_results())
-            data.update(results)
+            data.update(await await_maybe(extension.get_results()))
 
+        data.update(ctx.extensions_results)
         return data
-
-    def as_middleware_manager(self, *additional_middlewares: Any) -> MiddlewareManager:
-        middlewares = tuple(self.extensions) + additional_middlewares
-
-        return MiddlewareManager(*middlewares)
-
-
-__all__ = ["SchemaExtensionsRunner"]

strawberry/http/__init__.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import json
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, Mapping, Optional
-from typing_extensions import TypedDict
+from typing_extensions import Literal, TypedDict
 
 if TYPE_CHECKING:
     from strawberry.types import ExecutionResult
@@ -33,6 +33,7 @@ class GraphQLRequestData:
     query: Optional[str]
     variables: Optional[Dict[str, Any]]
     operation_name: Optional[str]
+    protocol: Literal["http", "multipart-subscription"] = "http"
 
 
 def parse_query_params(params: Dict[str, str]) -> Dict[str, Any]:

strawberry/http/async_base_view.py

@@ -14,6 +14,7 @@ from typing import (
     Tuple,
     Union,
 )
+from typing_extensions import Literal
 
 from graphql import GraphQLError
 
@@ -121,6 +122,15 @@ class AsyncBaseHTTPView(
 
         assert self.schema
 
+        if request_data.protocol == "multipart-subscription":
+            return await self.schema.subscribe(
+                request_data.query,  # type: ignore
+                variable_values=request_data.variables,
+                context_value=context,
+                root_value=root_value,
+                operation_name=request_data.operation_name,
+            )
+
         return await self.schema.execute(
             request_data.query,
             root_value=root_value,
@@ -233,7 +243,7 @@ class AsyncBaseHTTPView(
         self, stream: Callable[[], AsyncGenerator[str, None]]
     ) -> Callable[[], AsyncGenerator[str, None]]:
         """Adds a heartbeat to the stream, to prevent the connection from closing when there are no messages being sent."""
-        queue = asyncio.Queue[Tuple[bool, Any]](1)
+        queue: asyncio.Queue[Tuple[bool, Any]] = asyncio.Queue(1)
 
         cancelling = False
 
@@ -312,14 +322,19 @@ class AsyncBaseHTTPView(
     ) -> GraphQLRequestData:
         content_type, params = parse_content_type(request.content_type or "")
 
+        protocol: Literal["http", "multipart-subscription"] = "http"
+
         if request.method == "GET":
             data = self.parse_query_params(request.query_params)
+            if self._is_multipart_subscriptions(content_type, params):
+                protocol = "multipart-subscription"
         elif "application/json" in content_type:
             data = self.parse_json(await request.get_body())
         elif content_type == "multipart/form-data":
             data = await self.parse_multipart(request)
         elif self._is_multipart_subscriptions(content_type, params):
             data = await self.parse_multipart_subscriptions(request)
+            protocol = "multipart-subscription"
         else:
             raise HTTPException(400, "Unsupported content type")
 
@@ -327,6 +342,7 @@ class AsyncBaseHTTPView(
             query=data.get("query"),
             variables=data.get("variables"),
             operation_name=data.get("operationName"),
+            protocol=protocol,
         )
 
     async def process_result(

strawberry/schema/base.py

@@ -15,7 +15,6 @@ if TYPE_CHECKING:
     from strawberry.types import (
         ExecutionContext,
         ExecutionResult,
-        SubscriptionExecutionResult,
     )
     from strawberry.types.base import StrawberryObjectDefinition
     from strawberry.types.enum import EnumDefinition
@@ -24,6 +23,7 @@ if TYPE_CHECKING:
     from strawberry.types.union import StrawberryUnion
 
     from .config import StrawberryConfig
+    from .subscribe import SubscriptionResult
 
 
 class BaseSchema(Protocol):
@@ -43,7 +43,7 @@ class BaseSchema(Protocol):
         root_value: Optional[Any] = None,
         operation_name: Optional[str] = None,
         allowed_operation_types: Optional[Iterable[OperationType]] = None,
-    ) -> Union[ExecutionResult, SubscriptionExecutionResult]:
+    ) -> ExecutionResult:
         raise NotImplementedError
 
     @abstractmethod
@@ -66,7 +66,7 @@ class BaseSchema(Protocol):
         context_value: Optional[Any] = None,
         root_value: Optional[Any] = None,
         operation_name: Optional[str] = None,
-    ) -> Any:
+    ) -> SubscriptionResult:
         raise NotImplementedError
 
     @abstractmethod

strawberry/schema/execute.py

@@ -4,40 +4,43 @@ from asyncio import ensure_future
 from inspect import isawaitable
 from typing import (
     TYPE_CHECKING,
+    Awaitable,
     Callable,
     Iterable,
     List,
     Optional,
-    Sequence,
     Tuple,
     Type,
     TypedDict,
     Union,
+    cast,
 )
 
-from graphql import GraphQLError, parse, subscribe
+from graphql import ExecutionResult as GraphQLExecutionResult
+from graphql import GraphQLError, parse
 from graphql import execute as original_execute
 from graphql.validation import validate
 
 from strawberry.exceptions import MissingQueryError
-from strawberry.extensions.runner import SchemaExtensionsRunner
 from strawberry.schema.validation_rules.one_of import OneOfInputValidationRule
 from strawberry.types import ExecutionResult
-from strawberry.types.graphql import OperationType
+from strawberry.types.execution import PreExecutionError
+from strawberry.utils.await_maybe import await_maybe
 
 from .exceptions import InvalidOperationTypeError
 
 if TYPE_CHECKING:
-    from typing_extensions import NotRequired, Unpack
+    from typing_extensions import NotRequired, TypeAlias, Unpack
 
     from graphql import ExecutionContext as GraphQLExecutionContext
     from graphql import GraphQLSchema
+    from graphql.execution.middleware import MiddlewareManager
     from graphql.language import DocumentNode
     from graphql.validation import ASTValidationRule
 
-    from strawberry.extensions import SchemaExtension
+    from strawberry.extensions.runner import SchemaExtensionsRunner
     from strawberry.types import ExecutionContext
-    from strawberry.types.execution import SubscriptionExecutionResult
+    from strawberry.types.graphql import OperationType
 
 
 # duplicated because of https://github.com/mkdocstrings/griffe-typingdoc/issues/7
@@ -45,6 +48,11 @@ class ParseOptions(TypedDict):
     max_tokens: NotRequired[int]
 
 
+ProcessErrors: TypeAlias = (
+    "Callable[[List[GraphQLError], Optional[ExecutionContext]], None]"
+)
+
+
 def parse_document(query: str, **kwargs: Unpack[ParseOptions]) -> DocumentNode:
     return parse(query, **kwargs)
 
@@ -77,112 +85,120 @@ def _run_validation(execution_context: ExecutionContext) -> None:
         )
 
 
+async def _parse_and_validate_async(
+    context: ExecutionContext, extensions_runner: SchemaExtensionsRunner
+) -> Optional[PreExecutionError]:
+    if not context.query:
+        raise MissingQueryError()
+
+    async with extensions_runner.parsing():
+        try:
+            if not context.graphql_document:
+                context.graphql_document = parse_document(context.query)
+
+        except GraphQLError as error:
+            context.errors = [error]
+            return PreExecutionError(data=None, errors=[error])
+
+        except Exception as error:
+            error = GraphQLError(str(error), original_error=error)
+            context.errors = [error]
+            return PreExecutionError(data=None, errors=[error])
+
+    if context.operation_type not in context.allowed_operations:
+        raise InvalidOperationTypeError(context.operation_type)
+
+    async with extensions_runner.validation():
+        _run_validation(context)
+        if context.errors:
+            return PreExecutionError(
+                data=None,
+                errors=context.errors,
+            )
+
+    return None
+
+
+async def _handle_execution_result(
+    context: ExecutionContext,
+    result: Union[GraphQLExecutionResult, ExecutionResult],
+    extensions_runner: SchemaExtensionsRunner,
+    process_errors: ProcessErrors,
+) -> ExecutionResult:
+    # Set errors on the context so that it's easier
+    # to access in extensions
+    if result.errors:
+        context.errors = result.errors
+
+        # Run the `Schema.process_errors` function here before
+        # extensions have a chance to modify them (see the MaskErrors
+        # extension). That way we can log the original errors but
+        # only return a sanitised version to the client.
+        process_errors(result.errors, context)
+    if isinstance(result, GraphQLExecutionResult):
+        result = ExecutionResult(data=result.data, errors=result.errors)
+    result.extensions = await extensions_runner.get_extensions_results(context)
+    context.result = result  # type: ignore  # mypy failed to deduce correct type.
+    return result
+
+
+def _coerce_error(error: Union[GraphQLError, Exception]) -> GraphQLError:
+    if isinstance(error, GraphQLError):
+        return error
+    return GraphQLError(str(error), original_error=error)
+
+
 async def execute(
     schema: GraphQLSchema,
-    *,
-    allowed_operation_types: Iterable[OperationType],
-    extensions: Sequence[Union[Type[SchemaExtension], SchemaExtension]],
     execution_context: ExecutionContext,
+    extensions_runner: SchemaExtensionsRunner,
+    process_errors: ProcessErrors,
+    middleware_manager: MiddlewareManager,
     execution_context_class: Optional[Type[GraphQLExecutionContext]] = None,
-    process_errors: Callable[[List[GraphQLError], Optional[ExecutionContext]], None],
-) -> Union[ExecutionResult, SubscriptionExecutionResult]:
-    extensions_runner = SchemaExtensionsRunner(
-        execution_context=execution_context,
-        extensions=list(extensions),
-    )
-
+) -> ExecutionResult | PreExecutionError:
     try:
         async with extensions_runner.operation():
             # Note: In graphql-core the schema would be validated here but in
             # Strawberry we are validating it at initialisation time instead
-            if not execution_context.query:
-                raise MissingQueryError()
 
-            async with extensions_runner.parsing():
-                try:
-                    if not execution_context.graphql_document:
-                        execution_context.graphql_document = parse_document(
-                            execution_context.query, **execution_context.parse_options
-                        )
-
-                except GraphQLError as exc:
-                    execution_context.errors = [exc]
-                    process_errors([exc], execution_context)
-                    return ExecutionResult(
-                        data=None,
-                        errors=[exc],
-                        extensions=await extensions_runner.get_extensions_results(),
-                    )
-
-            if execution_context.operation_type not in allowed_operation_types:
-                raise InvalidOperationTypeError(execution_context.operation_type)
-
-            async with extensions_runner.validation():
-                _run_validation(execution_context)
-                if execution_context.errors:
-                    process_errors(execution_context.errors, execution_context)
-                    return ExecutionResult(data=None, errors=execution_context.errors)
+            if errors := await _parse_and_validate_async(
+                execution_context, extensions_runner
+            ):
+                return await _handle_execution_result(
+                    execution_context, errors, extensions_runner, process_errors
+                )
 
+            assert execution_context.graphql_document
             async with extensions_runner.executing():
                 if not execution_context.result:
-                    if execution_context.operation_type == OperationType.SUBSCRIPTION:
-                        # TODO: should we process errors here?
-                        # TODO: make our own wrapper?
-                        return await subscribe(  # type: ignore
-                            schema,
-                            execution_context.graphql_document,
-                            root_value=execution_context.root_value,
-                            context_value=execution_context.context,
-                            variable_values=execution_context.variables,
-                            operation_name=execution_context.operation_name,
-                        )
-                    else:
-                        result = original_execute(
+                    res = await await_maybe(
+                        original_execute(
                             schema,
                             execution_context.graphql_document,
                             root_value=execution_context.root_value,
-                            middleware=extensions_runner.as_middleware_manager(),
+                            middleware=middleware_manager,
                             variable_values=execution_context.variables,
                             operation_name=execution_context.operation_name,
                             context_value=execution_context.context,
                             execution_context_class=execution_context_class,
                         )
+                    )
 
-                    if isawaitable(result):
-                        result = await result
-
-                    execution_context.result = result
-                    # Also set errors on the execution_context so that it's easier
-                    # to access in extensions
-                    if result.errors:
-                        execution_context.errors = result.errors
-
-                        # Run the `Schema.process_errors` function here before
-                        # extensions have a chance to modify them (see the MaskErrors
-                        # extension). That way we can log the original errors but
-                        # only return a sanitised version to the client.
-                        process_errors(result.errors, execution_context)
-
+                else:
+                    res = execution_context.result
     except (MissingQueryError, InvalidOperationTypeError) as e:
         raise e
     except Exception as exc:
-        error = (
-            exc
-            if isinstance(exc, GraphQLError)
-            else GraphQLError(str(exc), original_error=exc)
-        )
-        execution_context.errors = [error]
-        process_errors([error], execution_context)
-        return ExecutionResult(
-            data=None,
-            errors=[error],
-            extensions=await extensions_runner.get_extensions_results(),
+        return await _handle_execution_result(
+            execution_context,
+            PreExecutionError(data=None, errors=[_coerce_error(exc)]),
+            extensions_runner,
+            process_errors,
         )
 
-    return ExecutionResult(
-        data=execution_context.result.data,
-        errors=execution_context.result.errors,
-        extensions=await extensions_runner.get_extensions_results(),
+    # return results after all the operation completed.
+    return await _handle_execution_result(
+        execution_context, res, extensions_runner, process_errors
     )
 
 
@@ -190,16 +206,12 @@ def execute_sync(
     schema: GraphQLSchema,
     *,
     allowed_operation_types: Iterable[OperationType],
-    extensions: Sequence[Union[Type[SchemaExtension], SchemaExtension]],
+    extensions_runner: SchemaExtensionsRunner,
     execution_context: ExecutionContext,
     execution_context_class: Optional[Type[GraphQLExecutionContext]] = None,
-    process_errors: Callable[[List[GraphQLError], Optional[ExecutionContext]], None],
+    process_errors: ProcessErrors,
+    middleware_manager: MiddlewareManager,
 ) -> ExecutionResult:
-    extensions_runner = SchemaExtensionsRunner(
-        execution_context=execution_context,
-        extensions=list(extensions),
-    )
-
     try:
         with extensions_runner.operation():
             # Note: In graphql-core the schema would be validated here but in
@@ -214,12 +226,12 @@ def execute_sync(
                             execution_context.query, **execution_context.parse_options
                         )
 
-                except GraphQLError as exc:
-                    execution_context.errors = [exc]
-                    process_errors([exc], execution_context)
+                except GraphQLError as error:
+                    execution_context.errors = [error]
+                    process_errors([error], execution_context)
                     return ExecutionResult(
                         data=None,
-                        errors=[exc],
+                        errors=[error],
                         extensions=extensions_runner.get_extensions_results_sync(),
                     )
 
@@ -230,7 +242,11 @@ def execute_sync(
                 _run_validation(execution_context)
                 if execution_context.errors:
                     process_errors(execution_context.errors, execution_context)
-                    return ExecutionResult(data=None, errors=execution_context.errors)
+                    return ExecutionResult(
+                        data=None,
+                        errors=execution_context.errors,
+                        extensions=extensions_runner.get_extensions_results_sync(),
+                    )
 
             with extensions_runner.executing():
                 if not execution_context.result:
@@ -238,7 +254,7 @@ def execute_sync(
                         schema,
                         execution_context.graphql_document,
                         root_value=execution_context.root_value,
-                        middleware=extensions_runner.as_middleware_manager(),
+                        middleware=middleware_manager,
                         variable_values=execution_context.variables,
                         operation_name=execution_context.operation_name,
                         context_value=execution_context.context,
@@ -246,13 +262,15 @@ def execute_sync(
                     )
 
                     if isawaitable(result):
+                        result = cast(Awaitable[GraphQLExecutionResult], result)  # type: ignore[redundant-cast]
                         ensure_future(result).cancel()
                         raise RuntimeError(
                             "GraphQL execution failed to complete synchronously."
                         )
 
+                    result = cast(GraphQLExecutionResult, result)  # type: ignore[redundant-cast]
                     execution_context.result = result
-                    # Also set errors on the execution_context so that it's easier
+                    # Also set errors on the context so that it's easier
                     # to access in extensions
                     if result.errors:
                         execution_context.errors = result.errors
@@ -262,23 +280,17 @@ def execute_sync(
                         # extension). That way we can log the original errors but
                         # only return a sanitised version to the client.
                         process_errors(result.errors, execution_context)
-
     except (MissingQueryError, InvalidOperationTypeError) as e:
         raise e
     except Exception as exc:
-        error = (
-            exc
-            if isinstance(exc, GraphQLError)
-            else GraphQLError(str(exc), original_error=exc)
-        )
-        execution_context.errors = [error]
-        process_errors([error], execution_context)
+        errors = [_coerce_error(exc)]
+        execution_context.errors = errors
+        process_errors(errors, execution_context)
         return ExecutionResult(
             data=None,
-            errors=[error],
+            errors=errors,
             extensions=extensions_runner.get_extensions_results_sync(),
         )
-
     return ExecutionResult(
         data=execution_context.result.data,
         errors=execution_context.result.errors,