strawberry-graphql 0.258.1__py3-none-any.whl → 0.259.1__py3-none-any.whl

strawberry/extensions/parser_cache.py

@@ -2,8 +2,9 @@ from collections.abc import Iterator
 from functools import lru_cache
 from typing import Optional
 
+from graphql.language.parser import parse
+
 from strawberry.extensions.base_extension import SchemaExtension
-from strawberry.schema.execute import parse_document
 
 
 class ParserCache(SchemaExtension):
@@ -32,7 +33,7 @@ class ParserCache(SchemaExtension):
                 cache will grow without bound.
                 More info: https://docs.python.org/3/library/functools.html#functools.lru_cache
         """
-        self.cached_parse_document = lru_cache(maxsize=maxsize)(parse_document)
+        self.cached_parse_document = lru_cache(maxsize=maxsize)(parse)
 
     def on_parse(self) -> Iterator[None]:
         execution_context = self.execution_context

strawberry/extensions/validation_cache.py

@@ -3,7 +3,6 @@ from functools import lru_cache
 from typing import Optional
 
 from strawberry.extensions.base_extension import SchemaExtension
-from strawberry.schema.execute import validate_document
 
 
 class ValidationCache(SchemaExtension):
@@ -32,6 +31,8 @@ class ValidationCache(SchemaExtension):
 
         More info: https://docs.python.org/3/library/functools.html#functools.lru_cache
         """
+        from strawberry.schema.schema import validate_document
+
         self.cached_validate_document = lru_cache(maxsize=maxsize)(validate_document)
 
     def on_validate(self) -> Iterator[None]:

strawberry/fastapi/router.py

@@ -125,7 +125,9 @@ class GraphQLRouter(
         keep_alive_interval: float = 1,
         debug: bool = False,
         root_value_getter: Optional[Callable[[], RootValue]] = None,
-        context_getter: Optional[Callable[..., Optional[Context]]] = None,
+        context_getter: Optional[
+            Callable[..., Union[Optional[Context], Awaitable[Optional[Context]]]]
+        ] = None,
         subscription_protocols: Sequence[str] = (
             GRAPHQL_TRANSPORT_WS_PROTOCOL,
             GRAPHQL_WS_PROTOCOL,

strawberry/schema/schema.py

@@ -1,29 +1,43 @@
 from __future__ import annotations
 
 import warnings
+from asyncio import ensure_future
+from collections.abc import AsyncGenerator, AsyncIterator, Awaitable, Iterable
 from functools import cached_property, lru_cache
+from inspect import isawaitable
 from typing import (
     TYPE_CHECKING,
     Any,
+    Callable,
     Optional,
     Union,
     cast,
 )
 
+from graphql import ExecutionResult as GraphQLExecutionResult
+from graphql import (
+    ExecutionResult as OriginalExecutionResult,
+)
 from graphql import (
     GraphQLBoolean,
+    GraphQLError,
     GraphQLField,
     GraphQLNamedType,
     GraphQLNonNull,
     GraphQLSchema,
     get_introspection_query,
+    parse,
     validate_schema,
 )
+from graphql.execution import ExecutionContext as GraphQLExecutionContext
+from graphql.execution import execute, subscribe
 from graphql.execution.middleware import MiddlewareManager
 from graphql.type.directives import specified_directives
+from graphql.validation import validate
 
 from strawberry import relay
 from strawberry.annotation import StrawberryAnnotation
+from strawberry.exceptions import MissingQueryError
 from strawberry.extensions import SchemaExtension
 from strawberry.extensions.directives import (
     DirectivesExtension,
@@ -33,38 +47,93 @@ from strawberry.extensions.runner import SchemaExtensionsRunner
 from strawberry.printer import print_schema
 from strawberry.schema.schema_converter import GraphQLCoreConverter
 from strawberry.schema.types.scalar import DEFAULT_SCALAR_REGISTRY
-from strawberry.types import ExecutionContext
+from strawberry.schema.validation_rules.one_of import OneOfInputValidationRule
 from strawberry.types.base import (
     StrawberryObjectDefinition,
     WithStrawberryObjectDefinition,
     has_object_definition,
 )
+from strawberry.types.execution import (
+    ExecutionContext,
+    ExecutionResult,
+    PreExecutionError,
+)
 from strawberry.types.graphql import OperationType
+from strawberry.utils import IS_GQL_32
+from strawberry.utils.await_maybe import await_maybe
 
 from . import compat
 from .base import BaseSchema
 from .config import StrawberryConfig
-from .execute import execute, execute_sync
-from .subscribe import SubscriptionResult, subscribe
+from .exceptions import InvalidOperationTypeError
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
+    from typing_extensions import TypeAlias
 
     from graphql import ExecutionContext as GraphQLExecutionContext
+    from graphql.language import DocumentNode
+    from graphql.validation import ASTValidationRule
 
     from strawberry.directive import StrawberryDirective
-    from strawberry.types import ExecutionResult
     from strawberry.types.base import StrawberryType
     from strawberry.types.enum import EnumDefinition
     from strawberry.types.field import StrawberryField
     from strawberry.types.scalar import ScalarDefinition, ScalarWrapper
     from strawberry.types.union import StrawberryUnion
 
+SubscriptionResult: TypeAlias = Union[
+    PreExecutionError, AsyncGenerator[ExecutionResult, None]
+]
+
+OriginSubscriptionResult = Union[
+    OriginalExecutionResult,
+    AsyncIterator[OriginalExecutionResult],
+]
+
 DEFAULT_ALLOWED_OPERATION_TYPES = {
     OperationType.QUERY,
     OperationType.MUTATION,
     OperationType.SUBSCRIPTION,
 }
+ProcessErrors: TypeAlias = (
+    "Callable[[list[GraphQLError], Optional[ExecutionContext]], None]"
+)
+
+
+# TODO: merge with below
+def validate_document(
+    schema: GraphQLSchema,
+    document: DocumentNode,
+    validation_rules: tuple[type[ASTValidationRule], ...],
+) -> list[GraphQLError]:
+    validation_rules = (
+        *validation_rules,
+        OneOfInputValidationRule,
+    )
+    return validate(
+        schema,
+        document,
+        validation_rules,
+    )
+
+
+def _run_validation(execution_context: ExecutionContext) -> None:
+    # Check if there are any validation rules or if validation has
+    # already been run by an extension
+    if len(execution_context.validation_rules) > 0 and execution_context.errors is None:
+        assert execution_context.graphql_document
+        execution_context.errors = validate_document(
+            execution_context.schema._schema,
+            execution_context.graphql_document,
+            execution_context.validation_rules,
+        )
+
+
+def _coerce_error(error: Union[GraphQLError, Exception]) -> GraphQLError:
+    if isinstance(error, GraphQLError):
+        return error
+    return GraphQLError(str(error), original_error=error)
 
 
 class Schema(BaseSchema):
@@ -337,6 +406,60 @@ class Schema(BaseSchema):
     ) -> list[StrawberryField]:
         return type_definition.fields
 
+    async def _parse_and_validate_async(
+        self, 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(context.query)
+
+            except GraphQLError as error:
+                context.errors = [error]
+                return PreExecutionError(data=None, errors=[error])
+
+            except Exception as error:  # noqa: BLE001
+                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(
+        self,
+        context: ExecutionContext,
+        result: Union[GraphQLExecutionResult, ExecutionResult],
+        extensions_runner: SchemaExtensionsRunner,
+        *,
+        # TODO: can we remove this somehow, see comment in execute
+        skip_process_errors: bool = False,
+    ) -> ExecutionResult:
+        # Set errors on the context so that it's easier
+        # to access in extensions
+        if result.errors:
+            context.errors = result.errors
+            if not skip_process_errors:
+                self._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
+
     async def execute(
         self,
         query: Optional[str],
@@ -361,15 +484,64 @@ class Schema(BaseSchema):
         # TODO (#3571): remove this when we implement execution context as parameter.
         for extension in extensions:
             extension.execution_context = execution_context
-        return await execute(
-            self._schema,
-            execution_context=execution_context,
-            extensions_runner=self.create_extensions_runner(
-                execution_context, extensions
-            ),
-            process_errors=self._process_errors,
-            middleware_manager=self._get_middleware_manager(extensions),
-            execution_context_class=self.execution_context_class,
+
+        extensions_runner = self.create_extensions_runner(execution_context, extensions)
+        middleware_manager = self._get_middleware_manager(extensions)
+
+        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 errors := await self._parse_and_validate_async(
+                    execution_context, extensions_runner
+                ):
+                    return await self._handle_execution_result(
+                        execution_context,
+                        errors,
+                        extensions_runner,
+                    )
+
+                assert execution_context.graphql_document
+                async with extensions_runner.executing():
+                    if not execution_context.result:
+                        result = await await_maybe(
+                            execute(
+                                self._schema,
+                                execution_context.graphql_document,
+                                root_value=execution_context.root_value,
+                                middleware=middleware_manager,
+                                variable_values=execution_context.variables,
+                                operation_name=execution_context.operation_name,
+                                context_value=execution_context.context,
+                                execution_context_class=self.execution_context_class,
+                            )
+                        )
+                        execution_context.result = result
+                    else:
+                        result = execution_context.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.
+                        self._process_errors(result.errors, execution_context)
+
+        except (MissingQueryError, InvalidOperationTypeError):
+            raise
+        except Exception as exc:  # noqa: BLE001
+            return await self._handle_execution_result(
+                execution_context,
+                PreExecutionError(data=None, errors=[_coerce_error(exc)]),
+                extensions_runner,
+            )
+        # return results after all the operation completed.
+        return await self._handle_execution_result(
+            execution_context, result, extensions_runner, skip_process_errors=True
         )
 
     def execute_sync(
@@ -396,18 +568,178 @@ class Schema(BaseSchema):
         # TODO (#3571): remove this when we implement execution context as parameter.
         for extension in extensions:
             extension.execution_context = execution_context
-        return execute_sync(
-            self._schema,
-            execution_context=execution_context,
-            extensions_runner=self.create_extensions_runner(
-                execution_context, extensions
-            ),
-            execution_context_class=self.execution_context_class,
-            allowed_operation_types=allowed_operation_types,
-            process_errors=self._process_errors,
-            middleware_manager=self._get_middleware_manager(extensions),
+
+        extensions_runner = self.create_extensions_runner(execution_context, extensions)
+        middleware_manager = self._get_middleware_manager(extensions)
+
+        try:
+            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  # noqa: TRY301
+
+                with extensions_runner.parsing():
+                    try:
+                        if not execution_context.graphql_document:
+                            execution_context.graphql_document = parse(
+                                execution_context.query,
+                                **execution_context.parse_options,
+                            )
+
+                    except GraphQLError as error:
+                        execution_context.errors = [error]
+                        self._process_errors([error], execution_context)
+                        return ExecutionResult(
+                            data=None,
+                            errors=[error],
+                            extensions=extensions_runner.get_extensions_results_sync(),
+                        )
+
+                if execution_context.operation_type not in allowed_operation_types:
+                    raise InvalidOperationTypeError(execution_context.operation_type)  # noqa: TRY301
+
+                with extensions_runner.validation():
+                    _run_validation(execution_context)
+                    if execution_context.errors:
+                        self._process_errors(
+                            execution_context.errors, execution_context
+                        )
+                        return ExecutionResult(
+                            data=None,
+                            errors=execution_context.errors,
+                            extensions=extensions_runner.get_extensions_results_sync(),
+                        )
+
+                with extensions_runner.executing():
+                    if not execution_context.result:
+                        result = execute(
+                            self._schema,
+                            execution_context.graphql_document,
+                            root_value=execution_context.root_value,
+                            middleware=middleware_manager,
+                            variable_values=execution_context.variables,
+                            operation_name=execution_context.operation_name,
+                            context_value=execution_context.context,
+                            execution_context_class=self.execution_context_class,
+                        )
+
+                        if isawaitable(result):
+                            result = cast(Awaitable[GraphQLExecutionResult], result)  # type: ignore[redundant-cast]
+                            ensure_future(result).cancel()
+                            raise RuntimeError(  # noqa: TRY301
+                                "GraphQL execution failed to complete synchronously."
+                            )
+
+                        result = cast(GraphQLExecutionResult, result)  # type: ignore[redundant-cast]
+                        execution_context.result = result
+                        # Also set errors on the 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.
+                            self._process_errors(result.errors, execution_context)
+        except (MissingQueryError, InvalidOperationTypeError):
+            raise
+        except Exception as exc:  # noqa: BLE001
+            errors = [_coerce_error(exc)]
+            execution_context.errors = errors
+            self._process_errors(errors, execution_context)
+            return ExecutionResult(
+                data=None,
+                errors=errors,
+                extensions=extensions_runner.get_extensions_results_sync(),
+            )
+        return ExecutionResult(
+            data=execution_context.result.data,
+            errors=execution_context.result.errors,
+            extensions=extensions_runner.get_extensions_results_sync(),
         )
 
+    async def _subscribe(
+        self,
+        execution_context: ExecutionContext,
+        extensions_runner: SchemaExtensionsRunner,
+        middleware_manager: MiddlewareManager,
+        execution_context_class: type[GraphQLExecutionContext] | None = None,
+    ) -> AsyncGenerator[ExecutionResult, None]:
+        async with extensions_runner.operation():
+            if initial_error := await self._parse_and_validate_async(
+                context=execution_context,
+                extensions_runner=extensions_runner,
+            ):
+                initial_error.extensions = (
+                    await extensions_runner.get_extensions_results(execution_context)
+                )
+                yield await self._handle_execution_result(
+                    execution_context, initial_error, extensions_runner
+                )
+            try:
+                async with extensions_runner.executing():
+                    assert execution_context.graphql_document is not None
+                    gql_33_kwargs = {
+                        "middleware": middleware_manager,
+                        "execution_context_class": execution_context_class,
+                    }
+                    try:
+                        # Might not be awaitable for pre-execution errors.
+                        aiter_or_result: OriginSubscriptionResult = await await_maybe(
+                            subscribe(
+                                self._schema,
+                                execution_context.graphql_document,
+                                root_value=execution_context.root_value,
+                                variable_values=execution_context.variables,
+                                operation_name=execution_context.operation_name,
+                                context_value=execution_context.context,
+                                **{} if IS_GQL_32 else gql_33_kwargs,  # type: ignore[arg-type]
+                            )
+                        )
+                    # graphql-core 3.2 doesn't handle some of the pre-execution errors.
+                    # see `test_subscription_immediate_error`
+                    except Exception as exc:  # noqa: BLE001
+                        aiter_or_result = OriginalExecutionResult(
+                            data=None, errors=[_coerce_error(exc)]
+                        )
+
+                # Handle pre-execution errors.
+                if isinstance(aiter_or_result, OriginalExecutionResult):
+                    yield await self._handle_execution_result(
+                        execution_context,
+                        PreExecutionError(data=None, errors=aiter_or_result.errors),
+                        extensions_runner,
+                    )
+                else:
+                    try:
+                        async for result in aiter_or_result:
+                            yield await self._handle_execution_result(
+                                execution_context,
+                                result,
+                                extensions_runner,
+                            )
+                    # graphql-core doesn't handle exceptions raised while executing.
+                    except Exception as exc:  # noqa: BLE001
+                        yield await self._handle_execution_result(
+                            execution_context,
+                            OriginalExecutionResult(
+                                data=None, errors=[_coerce_error(exc)]
+                            ),
+                            extensions_runner,
+                        )
+            # catch exceptions raised in `on_execute` hook.
+            except Exception as exc:  # noqa: BLE001
+                origin_result = OriginalExecutionResult(
+                    data=None, errors=[_coerce_error(exc)]
+                )
+                yield await self._handle_execution_result(
+                    execution_context,
+                    origin_result,
+                    extensions_runner,
+                )
+
     async def subscribe(
         self,
         query: Optional[str],
@@ -428,6 +760,30 @@ class Schema(BaseSchema):
         # TODO (#3571): remove this when we implement execution context as parameter.
         for extension in extensions:
             extension.execution_context = execution_context
+
+        asyncgen = self._subscribe(
+            execution_context,
+            extensions_runner=self.create_extensions_runner(
+                execution_context, extensions
+            ),
+            middleware_manager=self._get_middleware_manager(extensions),
+            execution_context_class=self.execution_context_class,
+        )
+        # GraphQL-core might return an initial error result instead of an async iterator.
+        # This happens when "there was an immediate error" i.e resolver is not an async iterator.
+        # To overcome this while maintaining the extension contexts we do this trick.
+        first = await asyncgen.__anext__()
+        if isinstance(first, PreExecutionError):
+            await asyncgen.aclose()
+            return first
+
+        async def _wrapper() -> AsyncGenerator[ExecutionResult, None]:
+            yield first
+            async for result in asyncgen:
+                yield result
+
+        return _wrapper()
+
         return await subscribe(
             self._schema,
             execution_context=execution_context,

{strawberry_graphql-0.258.1.dist-info → strawberry_graphql-0.259.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: strawberry-graphql
-Version: 0.258.1
+Version: 0.259.1
 Summary: A library for creating GraphQL APIs
 License: MIT
 Keywords: graphql,api,rest,starlette,async

{strawberry_graphql-0.258.1.dist-info → strawberry_graphql-0.259.1.dist-info}/RECORD

@@ -97,7 +97,7 @@ strawberry/extensions/field_extension.py,sha256=VUwUBbf57Vp_Ukc3Rh9eZDRuF2ubzRRi
 strawberry/extensions/mask_errors.py,sha256=xPGN24l6C_zZ174jHQbOhSShTqqAB58ithhuTZjBXGQ,1481
 strawberry/extensions/max_aliases.py,sha256=qaV9rqHTqfhh7YdFnXVvjf14wmAiXBtKHGAxb1Yv4DQ,2547
 strawberry/extensions/max_tokens.py,sha256=53Gb0tSj-G7so_vLokdmtUal4KCXQBYLJi1LSIvdkXE,1045
-strawberry/extensions/parser_cache.py,sha256=1ExyBxA8JFVaT-I81Kwlfb6mxgQwRD_zJUhfm5KK9F4,1310
+strawberry/extensions/parser_cache.py,sha256=oi6Svpy21_YP-d9G3nv_5HzJPw5FyBhWplCYnzcKwO8,1291
 strawberry/extensions/pyinstrument.py,sha256=c5qmVQMmvA2Wtivvlgkvx1C2EMexoG-XFxMenaItGYU,753
 strawberry/extensions/query_depth_limiter.py,sha256=qhVLfZTpp1gpx4O6Qe6bpNBWO7tI39vcH3FLbkpdosk,9727
 strawberry/extensions/runner.py,sha256=LCUSzKUrwTYhoIr1nS8uFDN15_YEQ_3BFK1zpPfOfsA,1873
@@ -107,10 +107,10 @@ strawberry/extensions/tracing/datadog.py,sha256=9hICpmLWKj7dWNRECGHc3TVX69SI9arb
 strawberry/extensions/tracing/opentelemetry.py,sha256=4czsWhJnwXbFii3vs4kqKD7r0iOakvnlGr2dlsQ7OwI,7207
 strawberry/extensions/tracing/utils.py,sha256=tXZNyqfct6YNSWi3GRj4GU1fKQGvSce8ZESfoVeys7U,654
 strawberry/extensions/utils.py,sha256=sjhxItHzbDhqHtnR63WbE35qzHhTyf9NSffidet79Hc,995
-strawberry/extensions/validation_cache.py,sha256=YAZRQKyhW-aMFniDK9XTEK7TOlTC9UkLZdk_9lo81V4,1425
+strawberry/extensions/validation_cache.py,sha256=D4Jyj7WoUkgp_UH6bo9ytRZbPwJnencbti5Z1GszGhM,1433
 strawberry/fastapi/__init__.py,sha256=p5qg9AlkYjNOWKcT4uRiebIpR6pIb1HqDMiDfF5O3tg,147
 strawberry/fastapi/context.py,sha256=O_cDNppfUJJecM0ZU_RJ-dhdF0o1x39JfYvYg-7uob4,684
-strawberry/fastapi/router.py,sha256=cgcZBqmb3srRChr0QM6tz7f3tP57x7vOVPz7iH2M8pk,11957
+strawberry/fastapi/router.py,sha256=4CqapWgqma_mU-s7TpFhpJwlO7UzBClAgouD7HN8NKs,12016
 strawberry/federation/__init__.py,sha256=Pw01N0rG9o0NaUxXLMNGeW5oLENeWVx_d8Kuef1ES4s,549
 strawberry/federation/argument.py,sha256=rs71S1utiNUd4XOLRa9KVtSMA3yqvKJnR_qdJqX6PPM,860
 strawberry/federation/enum.py,sha256=MdtblT4Z8_-2L8gUdo0ROnw3aY8RAAtTvyfHbCBBPrA,3033
@@ -166,11 +166,9 @@ strawberry/schema/base.py,sha256=CxVxEDk2U3aaOuABEkGhqNyFDs_xf2FF60yfnGT144g,385
 strawberry/schema/compat.py,sha256=9qJ0lhYJeaN43ayFgVz708ZMvedBhofiTSw9kpFqmjU,1830
 strawberry/schema/config.py,sha256=6BpCbNNCuekGgiKEPt2mliMqLH_wIjJmSW0tLbnJwk4,924
 strawberry/schema/exceptions.py,sha256=rqVNb_oYrKM0dHPgvAemqCG6Um282LPPu4zwQ5cZqs4,584
-strawberry/schema/execute.py,sha256=JgjtMCSCOuvHqAqI-dwmMV7bzpNEpiB9hVWTPS-GrFo,11979
 strawberry/schema/name_converter.py,sha256=1rrpch-wBidlWfZ7hVouvIIhJpdxWfB5tWnO6PqYug8,6544
-strawberry/schema/schema.py,sha256=oCsBg1yb3HmeIiMnT0PE3D7F2RSPHRk7k8pd7UyUSO4,19416
+strawberry/schema/schema.py,sha256=Co4vJ7dsSvtXuAy9AO1OquEGTDjDoBPN4AhYJl07bIo,35431
 strawberry/schema/schema_converter.py,sha256=-_QZCcmHWIEjRPqEChtPMPbFtgz6YmLn8V6KXvZJMOk,37192
-strawberry/schema/subscribe.py,sha256=UPXkmfudZjkf-quCZ6ZixPqrPz9wQDhHBChbjjYFJeY,6086
 strawberry/schema/types/__init__.py,sha256=oHO3COWhL3L1KLYCJNY1XFf5xt2GGtHiMC-UaYbFfnA,68
 strawberry/schema/types/base_scalars.py,sha256=JRUq0WjEkR9dFewstZnqnZKp0uOEipo4UXNF5dzRf4M,1971
 strawberry/schema/types/concrete_type.py,sha256=axIyFZgdwNv-XYkiqX67464wuFX6Vp0jYATwnBZSUvM,750
@@ -230,8 +228,8 @@ strawberry/utils/logging.py,sha256=U1cseHGquN09YFhFmRkiphfASKCyK0HUZREImPgVb0c,7
 strawberry/utils/operation.py,sha256=SSXxN-vMqdHO6W2OZtip-1z7y4_A-eTVFdhDvhKeLCk,1193
 strawberry/utils/str_converters.py,sha256=-eH1Cl16IO_wrBlsGM-km4IY0IKsjhjnSNGRGOwQjVM,897
 strawberry/utils/typing.py,sha256=Ux0Hl46lhuXvOKK-C5hj6nlz3zDn8P4CUGH2nUVD2vU,13373
-strawberry_graphql-0.258.1.dist-info/LICENSE,sha256=m-XnIVUKqlG_AWnfi9NReh9JfKhYOB-gJfKE45WM1W8,1072
-strawberry_graphql-0.258.1.dist-info/METADATA,sha256=43UddiOsqnfI0MrQ_Keg2JA4VN7JDKyAI3okbpaE7fY,7539
-strawberry_graphql-0.258.1.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-strawberry_graphql-0.258.1.dist-info/entry_points.txt,sha256=Nk7-aT3_uEwCgyqtHESV9H6Mc31cK-VAvhnQNTzTb4k,49
-strawberry_graphql-0.258.1.dist-info/RECORD,,
+strawberry_graphql-0.259.1.dist-info/LICENSE,sha256=m-XnIVUKqlG_AWnfi9NReh9JfKhYOB-gJfKE45WM1W8,1072
+strawberry_graphql-0.259.1.dist-info/METADATA,sha256=KuCcwxcDNqNi0f5yvUL1AmTfpupYqJnXTHk8r-1zxco,7539
+strawberry_graphql-0.259.1.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+strawberry_graphql-0.259.1.dist-info/entry_points.txt,sha256=Nk7-aT3_uEwCgyqtHESV9H6Mc31cK-VAvhnQNTzTb4k,49
+strawberry_graphql-0.259.1.dist-info/RECORD,,

strawberry/schema/execute.py

@@ -1,303 +0,0 @@
-from __future__ import annotations
-
-from asyncio import ensure_future
-from collections.abc import Awaitable, Iterable
-from inspect import isawaitable
-from typing import (
-    TYPE_CHECKING,
-    Callable,
-    Optional,
-    TypedDict,
-    Union,
-    cast,
-)
-
-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.schema.validation_rules.one_of import OneOfInputValidationRule
-from strawberry.types import ExecutionResult
-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, 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.runner import SchemaExtensionsRunner
-    from strawberry.types import ExecutionContext
-    from strawberry.types.graphql import OperationType
-
-
-# duplicated because of https://github.com/mkdocstrings/griffe-typingdoc/issues/7
-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)
-
-
-def validate_document(
-    schema: GraphQLSchema,
-    document: DocumentNode,
-    validation_rules: tuple[type[ASTValidationRule], ...],
-) -> list[GraphQLError]:
-    validation_rules = (
-        *validation_rules,
-        OneOfInputValidationRule,
-    )
-    return validate(
-        schema,
-        document,
-        validation_rules,
-    )
-
-
-def _run_validation(execution_context: ExecutionContext) -> None:
-    # Check if there are any validation rules or if validation has
-    # already been run by an extension
-    if len(execution_context.validation_rules) > 0 and execution_context.errors is None:
-        assert execution_context.graphql_document
-        execution_context.errors = validate_document(
-            execution_context.schema._schema,
-            execution_context.graphql_document,
-            execution_context.validation_rules,
-        )
-
-
-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:  # noqa: BLE001
-            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 | None,
-) -> ExecutionResult:
-    # Set errors on the context so that it's easier
-    # to access in extensions
-    if result.errors:
-        context.errors = result.errors
-        if process_errors:
-            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,
-    execution_context: ExecutionContext,
-    extensions_runner: SchemaExtensionsRunner,
-    process_errors: ProcessErrors,
-    middleware_manager: MiddlewareManager,
-    execution_context_class: Optional[type[GraphQLExecutionContext]] = None,
-) -> 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 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:
-                    result = await await_maybe(
-                        original_execute(
-                            schema,
-                            execution_context.graphql_document,
-                            root_value=execution_context.root_value,
-                            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,
-                        )
-                    )
-                    execution_context.result = result
-                else:
-                    result = execution_context.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)
-
-    except (MissingQueryError, InvalidOperationTypeError):
-        raise
-    except Exception as exc:  # noqa: BLE001
-        return await _handle_execution_result(
-            execution_context,
-            PreExecutionError(data=None, errors=[_coerce_error(exc)]),
-            extensions_runner,
-            process_errors,
-        )
-    # return results after all the operation completed.
-    return await _handle_execution_result(
-        execution_context, result, extensions_runner, None
-    )
-
-
-def execute_sync(
-    schema: GraphQLSchema,
-    *,
-    allowed_operation_types: Iterable[OperationType],
-    extensions_runner: SchemaExtensionsRunner,
-    execution_context: ExecutionContext,
-    execution_context_class: Optional[type[GraphQLExecutionContext]] = None,
-    process_errors: ProcessErrors,
-    middleware_manager: MiddlewareManager,
-) -> ExecutionResult:
-    try:
-        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  # noqa: TRY301
-
-            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 error:
-                    execution_context.errors = [error]
-                    process_errors([error], execution_context)
-                    return ExecutionResult(
-                        data=None,
-                        errors=[error],
-                        extensions=extensions_runner.get_extensions_results_sync(),
-                    )
-
-            if execution_context.operation_type not in allowed_operation_types:
-                raise InvalidOperationTypeError(execution_context.operation_type)  # noqa: TRY301
-
-            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,
-                        extensions=extensions_runner.get_extensions_results_sync(),
-                    )
-
-            with extensions_runner.executing():
-                if not execution_context.result:
-                    result = original_execute(
-                        schema,
-                        execution_context.graphql_document,
-                        root_value=execution_context.root_value,
-                        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 = cast(Awaitable[GraphQLExecutionResult], result)  # type: ignore[redundant-cast]
-                        ensure_future(result).cancel()
-                        raise RuntimeError(  # noqa: TRY301
-                            "GraphQL execution failed to complete synchronously."
-                        )
-
-                    result = cast(GraphQLExecutionResult, result)  # type: ignore[redundant-cast]
-                    execution_context.result = result
-                    # Also set errors on the 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)
-    except (MissingQueryError, InvalidOperationTypeError):
-        raise
-    except Exception as exc:  # noqa: BLE001
-        errors = [_coerce_error(exc)]
-        execution_context.errors = errors
-        process_errors(errors, execution_context)
-        return ExecutionResult(
-            data=None,
-            errors=errors,
-            extensions=extensions_runner.get_extensions_results_sync(),
-        )
-    return ExecutionResult(
-        data=execution_context.result.data,
-        errors=execution_context.result.errors,
-        extensions=extensions_runner.get_extensions_results_sync(),
-    )
-
-
-__all__ = ["execute", "execute_sync"]

strawberry/schema/subscribe.py

@@ -1,155 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import AsyncGenerator, AsyncIterator
-from typing import TYPE_CHECKING, Optional, Union
-
-from graphql import (
-    ExecutionResult as OriginalExecutionResult,
-)
-from graphql.execution import ExecutionContext as GraphQLExecutionContext
-from graphql.execution import subscribe as original_subscribe
-
-from strawberry.types import ExecutionResult
-from strawberry.types.execution import ExecutionContext, PreExecutionError
-from strawberry.utils import IS_GQL_32
-from strawberry.utils.await_maybe import await_maybe
-
-from .execute import (
-    ProcessErrors,
-    _coerce_error,
-    _handle_execution_result,
-    _parse_and_validate_async,
-)
-
-if TYPE_CHECKING:
-    from typing_extensions import TypeAlias
-
-    from graphql.execution.middleware import MiddlewareManager
-    from graphql.type.schema import GraphQLSchema
-
-    from strawberry.extensions.runner import SchemaExtensionsRunner
-
-SubscriptionResult: TypeAlias = Union[
-    PreExecutionError, AsyncGenerator[ExecutionResult, None]
-]
-
-OriginSubscriptionResult = Union[
-    OriginalExecutionResult,
-    AsyncIterator[OriginalExecutionResult],
-]
-
-
-async def _subscribe(
-    schema: GraphQLSchema,
-    execution_context: ExecutionContext,
-    extensions_runner: SchemaExtensionsRunner,
-    process_errors: ProcessErrors,
-    middleware_manager: MiddlewareManager,
-    execution_context_class: Optional[type[GraphQLExecutionContext]] = None,
-) -> AsyncGenerator[Union[PreExecutionError, ExecutionResult], None]:
-    async with extensions_runner.operation():
-        if initial_error := await _parse_and_validate_async(
-            context=execution_context,
-            extensions_runner=extensions_runner,
-        ):
-            initial_error.extensions = await extensions_runner.get_extensions_results(
-                execution_context
-            )
-            yield await _handle_execution_result(
-                execution_context, initial_error, extensions_runner, process_errors
-            )
-        try:
-            async with extensions_runner.executing():
-                assert execution_context.graphql_document is not None
-                gql_33_kwargs = {
-                    "middleware": middleware_manager,
-                    "execution_context_class": execution_context_class,
-                }
-                try:
-                    # Might not be awaitable for pre-execution errors.
-                    aiter_or_result: OriginSubscriptionResult = await await_maybe(
-                        original_subscribe(
-                            schema,
-                            execution_context.graphql_document,
-                            root_value=execution_context.root_value,
-                            variable_values=execution_context.variables,
-                            operation_name=execution_context.operation_name,
-                            context_value=execution_context.context,
-                            **{} if IS_GQL_32 else gql_33_kwargs,  # type: ignore[arg-type]
-                        )
-                    )
-                # graphql-core 3.2 doesn't handle some of the pre-execution errors.
-                # see `test_subscription_immediate_error`
-                except Exception as exc:  # noqa: BLE001
-                    aiter_or_result = OriginalExecutionResult(
-                        data=None, errors=[_coerce_error(exc)]
-                    )
-
-            # Handle pre-execution errors.
-            if isinstance(aiter_or_result, OriginalExecutionResult):
-                yield await _handle_execution_result(
-                    execution_context,
-                    PreExecutionError(data=None, errors=aiter_or_result.errors),
-                    extensions_runner,
-                    process_errors,
-                )
-            else:
-                try:
-                    async for result in aiter_or_result:
-                        yield await _handle_execution_result(
-                            execution_context,
-                            result,
-                            extensions_runner,
-                            process_errors,
-                        )
-                # graphql-core doesn't handle exceptions raised while executing.
-                except Exception as exc:  # noqa: BLE001
-                    yield await _handle_execution_result(
-                        execution_context,
-                        OriginalExecutionResult(data=None, errors=[_coerce_error(exc)]),
-                        extensions_runner,
-                        process_errors,
-                    )
-        # catch exceptions raised in `on_execute` hook.
-        except Exception as exc:  # noqa: BLE001
-            origin_result = OriginalExecutionResult(
-                data=None, errors=[_coerce_error(exc)]
-            )
-            yield await _handle_execution_result(
-                execution_context,
-                origin_result,
-                extensions_runner,
-                process_errors,
-            )
-
-
-async def subscribe(
-    schema: GraphQLSchema,
-    execution_context: ExecutionContext,
-    extensions_runner: SchemaExtensionsRunner,
-    process_errors: ProcessErrors,
-    middleware_manager: MiddlewareManager,
-    execution_context_class: Optional[type[GraphQLExecutionContext]] = None,
-) -> SubscriptionResult:
-    asyncgen = _subscribe(
-        schema,
-        execution_context,
-        extensions_runner,
-        process_errors,
-        middleware_manager,
-        execution_context_class,
-    )
-    # GraphQL-core might return an initial error result instead of an async iterator.
-    # This happens when "there was an immediate error" i.e resolver is not an async iterator.
-    # To overcome this while maintaining the extension contexts we do this trick.
-    first = await asyncgen.__anext__()
-    if isinstance(first, PreExecutionError):
-        await asyncgen.aclose()
-        return first
-
-    async def _wrapper() -> AsyncGenerator[ExecutionResult, None]:
-        yield first
-        async for result in asyncgen:
-            yield result
-
-    return _wrapper()