strawberry-graphql 0.275.7__py3-none-any.whl → 0.284.3__py3-none-any.whl

strawberry/schema/schema.py

@@ -2,20 +2,16 @@ from __future__ import annotations
 
 import warnings
 from asyncio import ensure_future
-from collections.abc import AsyncGenerator, AsyncIterator, Awaitable, Iterable
+from collections.abc import AsyncGenerator, AsyncIterator, Awaitable, Callable, Iterable
 from functools import cached_property, lru_cache
 from inspect import isawaitable
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     NamedTuple,
-    Optional,
-    Union,
     cast,
 )
 
-from graphql import ExecutionContext as GraphQLExecutionContext
 from graphql import ExecutionResult as GraphQLExecutionResult
 from graphql import (
     ExecutionResult as OriginalExecutionResult,
@@ -36,7 +32,6 @@ from graphql import (
     parse,
     validate_schema,
 )
-from graphql.execution import execute, subscribe
 from graphql.execution.middleware import MiddlewareManager
 from graphql.type.directives import specified_directives
 from graphql.validation import validate
@@ -52,6 +47,7 @@ from strawberry.extensions.directives import (
 from strawberry.extensions.runner import SchemaExtensionsRunner
 from strawberry.printer import print_schema
 from strawberry.schema.schema_converter import GraphQLCoreConverter
+from strawberry.schema.validation_rules.maybe_null import MaybeNullValidationRule
 from strawberry.schema.validation_rules.one_of import OneOfInputValidationRule
 from strawberry.types.base import (
     StrawberryObjectDefinition,
@@ -69,15 +65,23 @@ from strawberry.utils.aio import aclosing
 from strawberry.utils.await_maybe import await_maybe
 
 from . import compat
+from ._graphql_core import (
+    GraphQLExecutionContext,
+    GraphQLIncrementalExecutionResults,
+    ResultType,
+    execute,
+    experimental_execute_incrementally,
+    incremental_execution_directives,
+    subscribe,
+)
 from .base import BaseSchema
 from .config import StrawberryConfig
 from .exceptions import CannotGetOperationTypeError, InvalidOperationTypeError
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, Mapping
-    from typing_extensions import TypeAlias
+    from typing import TypeAlias
 
-    from graphql.execution.collect_fields import FieldGroup  # type: ignore
     from graphql.language import DocumentNode
     from graphql.pyutils import Path
     from graphql.type import GraphQLResolveInfo
@@ -91,13 +95,13 @@ if TYPE_CHECKING:
     from strawberry.types.union import StrawberryUnion
 
 SubscriptionResult: TypeAlias = AsyncGenerator[
-    Union[PreExecutionError, ExecutionResult], None
+    PreExecutionError | ExecutionResult, None
 ]
 
-OriginSubscriptionResult = Union[
-    OriginalExecutionResult,
-    AsyncIterator[OriginalExecutionResult],
-]
+OriginSubscriptionResult: TypeAlias = (
+    OriginalExecutionResult | AsyncIterator[OriginalExecutionResult]
+)
+
 
 DEFAULT_ALLOWED_OPERATION_TYPES = {
     OperationType.QUERY,
@@ -105,7 +109,7 @@ DEFAULT_ALLOWED_OPERATION_TYPES = {
     OperationType.SUBSCRIPTION,
 }
 ProcessErrors: TypeAlias = (
-    "Callable[[list[GraphQLError], Optional[ExecutionContext]], None]"
+    "Callable[[list[GraphQLError], ExecutionContext | None], None]"
 )
 
 
@@ -117,6 +121,7 @@ def validate_document(
 ) -> list[GraphQLError]:
     validation_rules = (
         *validation_rules,
+        MaybeNullValidationRule,
         OneOfInputValidationRule,
     )
     return validate(
@@ -129,16 +134,19 @@ def validate_document(
 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:
+    if (
+        len(execution_context.validation_rules) > 0
+        and execution_context.pre_execution_errors is None
+    ):
         assert execution_context.graphql_document
-        execution_context.errors = validate_document(
+        execution_context.pre_execution_errors = validate_document(
             execution_context.schema._schema,
             execution_context.graphql_document,
             execution_context.validation_rules,
         )
 
 
-def _coerce_error(error: Union[GraphQLError, Exception]) -> GraphQLError:
+def _coerce_error(error: GraphQLError | Exception) -> GraphQLError:
     if isinstance(error, GraphQLError):
         return error
     return GraphQLError(str(error), original_error=error)
@@ -168,17 +176,18 @@ class StrawberryGraphQLCoreExecutionContext(GraphQLExecutionContext):
 
         self.operation_extensions = operation_extensions
 
-    def build_resolve_info(
-        self,
-        field_def: GraphQLField,
-        field_group: FieldGroup,
-        parent_type: GraphQLObjectType,
-        path: Path,
-    ) -> GraphQLResolveInfo:
-        if IS_GQL_33:
+    if IS_GQL_33:
+
+        def build_resolve_info(
+            self,
+            field_def: GraphQLField,
+            field_nodes: list[FieldNode],
+            parent_type: GraphQLObjectType,
+            path: Path,
+        ) -> GraphQLResolveInfo:
             return _OperationContextAwareGraphQLResolveInfo(  # type: ignore
-                field_group.fields[0].node.name.value,
-                field_group.to_nodes(),
+                field_nodes[0].name.value,
+                field_nodes,
                 field_def.type,
                 parent_type,
                 path,
@@ -192,13 +201,6 @@ class StrawberryGraphQLCoreExecutionContext(GraphQLExecutionContext):
                 self.operation_extensions,
             )
 
-        return super().build_resolve_info(
-            field_def,
-            field_group,
-            parent_type,
-            path,
-        )
-
 
 class Schema(BaseSchema):
     def __init__(
@@ -206,16 +208,16 @@ class Schema(BaseSchema):
         # TODO: can we make sure we only allow to pass
         # something that has been decorated?
         query: type,
-        mutation: Optional[type] = None,
-        subscription: Optional[type] = None,
+        mutation: type | None = None,
+        subscription: type | None = None,
         directives: Iterable[StrawberryDirective] = (),
-        types: Iterable[Union[type, StrawberryType]] = (),
-        extensions: Iterable[Union[type[SchemaExtension], SchemaExtension]] = (),
-        execution_context_class: Optional[type[GraphQLExecutionContext]] = None,
-        config: Optional[StrawberryConfig] = None,
-        scalar_overrides: Optional[
-            Mapping[object, Union[type, ScalarWrapper, ScalarDefinition]],
-        ] = None,
+        types: Iterable[type | StrawberryType] = (),
+        extensions: Iterable[type[SchemaExtension] | SchemaExtension] = (),
+        execution_context_class: type[GraphQLExecutionContext] | None = None,
+        config: StrawberryConfig | None = None,
+        scalar_overrides: (
+            Mapping[object, type | ScalarWrapper | ScalarDefinition] | None
+        ) = None,
         schema_directives: Iterable[object] = (),
     ) -> None:
         """Default Schema to be used in a Strawberry application.
@@ -321,11 +323,16 @@ class Schema(BaseSchema):
                 graphql_types.append(graphql_type)
 
         try:
+            directives = specified_directives + tuple(graphql_directives)  # type: ignore
+
+            if self.config.enable_experimental_incremental_execution:
+                directives = tuple(directives) + tuple(incremental_execution_directives)
+
             self._schema = GraphQLSchema(
                 query=query_type,
                 mutation=mutation_type,
                 subscription=subscription_type if subscription else None,
-                directives=specified_directives + tuple(graphql_directives),
+                directives=directives,  # type: ignore
                 types=graphql_types,
                 extensions={
                     GraphQLCoreConverter.DEFINITION_BACKREF: self,
@@ -387,7 +394,7 @@ class Schema(BaseSchema):
         )
 
     def _get_custom_context_kwargs(
-        self, operation_extensions: Optional[dict[str, Any]] = None
+        self, operation_extensions: dict[str, Any] | None = None
     ) -> dict[str, Any]:
         if not IS_GQL_33:
             return {}
@@ -406,13 +413,13 @@ class Schema(BaseSchema):
 
     def _create_execution_context(
         self,
-        query: Optional[str],
+        query: str | None,
         allowed_operation_types: Iterable[OperationType],
-        variable_values: Optional[dict[str, Any]] = None,
-        context_value: Optional[Any] = None,
-        root_value: Optional[Any] = None,
-        operation_name: Optional[str] = None,
-        operation_extensions: Optional[dict[str, Any]] = None,
+        variable_values: dict[str, Any] | None = None,
+        context_value: Any | None = None,
+        root_value: Any | None = None,
+        operation_name: str | None = None,
+        operation_extensions: dict[str, Any] | None = None,
     ) -> ExecutionContext:
         return ExecutionContext(
             query=query,
@@ -428,14 +435,13 @@ class Schema(BaseSchema):
     @lru_cache
     def get_type_by_name(
         self, name: str
-    ) -> Optional[
-        Union[
-            StrawberryObjectDefinition,
-            ScalarDefinition,
-            EnumDefinition,
-            StrawberryUnion,
-        ]
-    ]:
+    ) -> (
+        StrawberryObjectDefinition
+        | ScalarDefinition
+        | EnumDefinition
+        | StrawberryUnion
+        | None
+    ):
         # TODO: respect auto_camel_case
         if name in self.schema_converter.type_map:
             return self.schema_converter.type_map[name].definition
@@ -444,7 +450,7 @@ class Schema(BaseSchema):
 
     def get_field_for_type(
         self, field_name: str, type_name: str
-    ) -> Optional[StrawberryField]:
+    ) -> StrawberryField | None:
         type_ = self.get_type_by_name(type_name)
 
         if not type_:
@@ -462,7 +468,7 @@ class Schema(BaseSchema):
         )
 
     @lru_cache
-    def get_directive_by_name(self, graphql_name: str) -> Optional[StrawberryDirective]:
+    def get_directive_by_name(self, graphql_name: str) -> StrawberryDirective | None:
         return next(
             (
                 directive
@@ -479,7 +485,7 @@ class Schema(BaseSchema):
 
     async def _parse_and_validate_async(
         self, context: ExecutionContext, extensions_runner: SchemaExtensionsRunner
-    ) -> Optional[PreExecutionError]:
+    ) -> PreExecutionError | None:
         if not context.query:
             raise MissingQueryError
 
@@ -489,12 +495,12 @@ class Schema(BaseSchema):
                     context.graphql_document = parse(context.query)
 
             except GraphQLError as error:
-                context.errors = [error]
+                context.pre_execution_errors = [error]
                 return PreExecutionError(data=None, errors=[error])
 
             except Exception as error:  # noqa: BLE001
                 error = GraphQLError(str(error), original_error=error)
-                context.errors = [error]
+                context.pre_execution_errors = [error]
                 return PreExecutionError(data=None, errors=[error])
 
         try:
@@ -507,10 +513,10 @@ class Schema(BaseSchema):
 
         async with extensions_runner.validation():
             _run_validation(context)
-            if context.errors:
+            if context.pre_execution_errors:
                 return PreExecutionError(
                     data=None,
-                    errors=context.errors,
+                    errors=context.pre_execution_errors,
                 )
 
         return None
@@ -518,33 +524,37 @@ class Schema(BaseSchema):
     async def _handle_execution_result(
         self,
         context: ExecutionContext,
-        result: Union[GraphQLExecutionResult, ExecutionResult],
+        result: ResultType,
         extensions_runner: SchemaExtensionsRunner,
         *,
         # TODO: can we remove this somehow, see comment in execute
         skip_process_errors: bool = False,
     ) -> ExecutionResult:
+        # TODO: handle this, also, why do we have both GraphQLExecutionResult and ExecutionResult?
+        if isinstance(result, GraphQLIncrementalExecutionResults):
+            return result
+
         # Set errors on the context so that it's easier
         # to access in extensions
         if result.errors:
-            context.errors = result.errors
+            context.pre_execution_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.
+        context.result = result
         return result
 
     async def execute(
         self,
-        query: Optional[str],
-        variable_values: Optional[dict[str, Any]] = None,
-        context_value: Optional[Any] = None,
-        root_value: Optional[Any] = None,
-        operation_name: Optional[str] = None,
-        allowed_operation_types: Optional[Iterable[OperationType]] = None,
-        operation_extensions: Optional[dict[str, Any]] = None,
+        query: str | None,
+        variable_values: dict[str, Any] | None = None,
+        context_value: Any | None = None,
+        root_value: Any | None = None,
+        operation_name: str | None = None,
+        allowed_operation_types: Iterable[OperationType] | None = None,
+        operation_extensions: dict[str, Any] | None = None,
     ) -> ExecutionResult:
         if allowed_operation_types is None:
             allowed_operation_types = DEFAULT_ALLOWED_OPERATION_TYPES
@@ -566,6 +576,17 @@ class Schema(BaseSchema):
         extensions_runner = self.create_extensions_runner(execution_context, extensions)
         middleware_manager = self._get_middleware_manager(extensions)
 
+        execute_function = execute
+
+        if self.config.enable_experimental_incremental_execution:
+            execute_function = experimental_execute_incrementally
+
+            if execute_function is None:
+                raise RuntimeError(
+                    "Incremental execution is enabled but experimental_execute_incrementally is not available, "
+                    "please install graphql-core>=3.3.0"
+                )
+
         custom_context_kwargs = self._get_custom_context_kwargs(operation_extensions)
 
         try:
@@ -586,7 +607,7 @@ class Schema(BaseSchema):
                 async with extensions_runner.executing():
                     if not execution_context.result:
                         result = await await_maybe(
-                            execute(
+                            execute_function(
                                 self._schema,
                                 execution_context.graphql_document,
                                 root_value=execution_context.root_value,
@@ -603,8 +624,10 @@ class Schema(BaseSchema):
                         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
+
+                    # TODO: maybe here use the first result from incremental execution if it exists
+                    if isinstance(result, GraphQLExecutionResult) and result.errors:
+                        execution_context.pre_execution_errors = result.errors
 
                         # Run the `Schema.process_errors` function here before
                         # extensions have a chance to modify them (see the MaskErrors
@@ -631,13 +654,13 @@ class Schema(BaseSchema):
 
     def execute_sync(
         self,
-        query: Optional[str],
-        variable_values: Optional[dict[str, Any]] = None,
-        context_value: Optional[Any] = None,
-        root_value: Optional[Any] = None,
-        operation_name: Optional[str] = None,
-        allowed_operation_types: Optional[Iterable[OperationType]] = None,
-        operation_extensions: Optional[dict[str, Any]] = None,
+        query: str | None,
+        variable_values: dict[str, Any] | None = None,
+        context_value: Any | None = None,
+        root_value: Any | None = None,
+        operation_name: str | None = None,
+        allowed_operation_types: Iterable[OperationType] | None = None,
+        operation_extensions: dict[str, Any] | None = None,
     ) -> ExecutionResult:
         if allowed_operation_types is None:
             allowed_operation_types = DEFAULT_ALLOWED_OPERATION_TYPES
@@ -659,6 +682,16 @@ class Schema(BaseSchema):
         extensions_runner = self.create_extensions_runner(execution_context, extensions)
         middleware_manager = self._get_middleware_manager(extensions)
 
+        execute_function = execute
+
+        if self.config.enable_experimental_incremental_execution:
+            execute_function = experimental_execute_incrementally
+
+            if execute_function is None:
+                raise RuntimeError(
+                    "Incremental execution is enabled but experimental_execute_incrementally is not available, "
+                    "please install graphql-core>=3.3.0"
+                )
         custom_context_kwargs = self._get_custom_context_kwargs(operation_extensions)
 
         try:
@@ -677,7 +710,7 @@ class Schema(BaseSchema):
                             )
 
                     except GraphQLError as error:
-                        execution_context.errors = [error]
+                        execution_context.pre_execution_errors = [error]
                         self._process_errors([error], execution_context)
                         return ExecutionResult(
                             data=None,
@@ -697,19 +730,19 @@ class Schema(BaseSchema):
 
                 with extensions_runner.validation():
                     _run_validation(execution_context)
-                    if execution_context.errors:
+                    if execution_context.pre_execution_errors:
                         self._process_errors(
-                            execution_context.errors, execution_context
+                            execution_context.pre_execution_errors, execution_context
                         )
                         return ExecutionResult(
                             data=None,
-                            errors=execution_context.errors,
+                            errors=execution_context.pre_execution_errors,
                             extensions=extensions_runner.get_extensions_results_sync(),
                         )
 
                 with extensions_runner.executing():
                     if not execution_context.result:
-                        result = execute(
+                        result = execute_function(
                             self._schema,
                             execution_context.graphql_document,
                             root_value=execution_context.root_value,
@@ -733,7 +766,7 @@ class Schema(BaseSchema):
                         # Also set errors on the context so that it's easier
                         # to access in extensions
                         if result.errors:
-                            execution_context.errors = result.errors
+                            execution_context.pre_execution_errors = result.errors
 
                             # Run the `Schema.process_errors` function here before
                             # extensions have a chance to modify them (see the MaskErrors
@@ -748,7 +781,7 @@ class Schema(BaseSchema):
             raise
         except Exception as exc:  # noqa: BLE001
             errors = [_coerce_error(exc)]
-            execution_context.errors = errors
+            execution_context.pre_execution_errors = errors
             self._process_errors(errors, execution_context)
             return ExecutionResult(
                 data=None,
@@ -767,7 +800,7 @@ class Schema(BaseSchema):
         extensions_runner: SchemaExtensionsRunner,
         middleware_manager: MiddlewareManager,
         execution_context_class: type[GraphQLExecutionContext] | None = None,
-        operation_extensions: Optional[dict[str, Any]] = None,
+        operation_extensions: dict[str, Any] | None = None,
     ) -> AsyncGenerator[ExecutionResult, None]:
         async with extensions_runner.operation():
             if initial_error := await self._parse_and_validate_async(
@@ -846,12 +879,12 @@ class Schema(BaseSchema):
 
     async def subscribe(
         self,
-        query: Optional[str],
-        variable_values: Optional[dict[str, Any]] = None,
-        context_value: Optional[Any] = None,
-        root_value: Optional[Any] = None,
-        operation_name: Optional[str] = None,
-        operation_extensions: Optional[dict[str, Any]] = None,
+        query: str | None,
+        variable_values: dict[str, Any] | None = None,
+        context_value: Any | None = None,
+        root_value: Any | None = None,
+        operation_name: str | None = None,
+        operation_extensions: dict[str, Any] | None = None,
     ) -> SubscriptionResult:
         execution_context = self._create_execution_context(
             query=query,