strawberry-graphql 0.258.1__tar.gz → 0.259.0__tar.gz

{strawberry_graphql-0.258.1 → strawberry_graphql-0.259.0}/PKG-INFO

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

{strawberry_graphql-0.258.1 → strawberry_graphql-0.259.0}/pyproject.toml

@@ -1,17 +1,15 @@
 [tool.poetry]
 name = "strawberry-graphql"
 packages = [ { include = "strawberry" } ]
-version = "0.258.1"
+version = "0.259.0"
 description = "A library for creating GraphQL APIs"
 authors = ["Patrick Arminio <patrick.arminio@gmail.com>"]
 license = "MIT"
 readme = "README.md"
 keywords = ["graphql", "api", "rest", "starlette", "async"]
-
 homepage = "https://strawberry.rocks/"
 repository = "https://github.com/strawberry-graphql/strawberry"
 documentation = "https://strawberry.rocks/"
-
 classifiers = [
     "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Developers",
@@ -29,10 +27,6 @@ include = ["strawberry/py.typed"]
 "Sponsor on GitHub" = "https://github.com/sponsors/strawberry-graphql"
 "Sponsor on Open Collective" = "https://opencollective.com/strawberry-graphql"
 
-[build-system]
-requires = ["poetry-core>=1.6"]
-build-backend = "poetry.core.masonry.api"
-
 [tool.poetry.dependencies]
 python = "^3.9"
 graphql-core = ">=3.2.0,<3.4.0"
@@ -102,6 +96,7 @@ types-deprecated = "^1.2.15.20241117"
 types-six = "^1.17.0.20241205"
 types-pyyaml = "^6.0.12.20240917"
 mypy = "^1.13.0"
+codeflash = "^0.9.2"
 
 [tool.poetry.group.integrations]
 optional = true
@@ -123,6 +118,7 @@ litestar = {version = ">=2", optional = false}
 uvicorn = ">=0.11.6"
 daphne = "^4.0.0"
 
+
 [tool.poetry.extras]
 aiohttp = ["aiohttp"]
 asgi = ["starlette", "python-multipart"]
@@ -144,6 +140,7 @@ pyinstrument = ["pyinstrument"]
 [tool.poetry.scripts]
 strawberry = "strawberry.cli:run"
 
+
 [tool.pytest.ini_options]
 addopts = "--emoji"
 DJANGO_SETTINGS_MODULE = "tests.django.django_settings"
@@ -182,6 +179,7 @@ filterwarnings = [
     "ignore::DeprecationWarning:pkg_resources.*",
 ]
 
+
 [tool.autopub]
 git-username = "Botberry"
 git-email = "bot@strawberry.rocks"
@@ -384,3 +382,15 @@ exclude =[
 
 [tool.ruff.lint.pydocstyle]
 convention = "google"
+
+[tool.codeflash]
+# All paths are relative to this pyproject.toml's directory.
+module-root = "strawberry"
+tests-root = "tests"
+test-framework = "pytest"
+ignore-paths = []
+formatter-cmds = ["ruff check --exit-zero --fix $file", "ruff format $file"]
+
+[build-system]
+requires = ["poetry-core>=1.6"]
+build-backend = "poetry.core.masonry.api"

{strawberry_graphql-0.258.1 → strawberry_graphql-0.259.0}/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_graphql-0.258.1 → strawberry_graphql-0.259.0}/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_graphql-0.258.1 → strawberry_graphql-0.259.0}/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,