Use latest feature of GraphQL-core

Author: patrick91

strawberry/http/__init__.py

@@ -1,13 +1,10 @@
 from __future__ import annotations
 
-import json
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Optional
 from typing_extensions import Literal, TypedDict
 
 if TYPE_CHECKING:
-    from collections.abc import Mapping
-
     from strawberry.types import ExecutionResult
 
 
@@ -39,22 +36,6 @@ class GraphQLRequestData:
     protocol: Literal["http", "multipart-subscription"] = "http"
 
 
-def parse_query_params(params: dict[str, str]) -> dict[str, Any]:
-    if "variables" in params:
-        params["variables"] = json.loads(params["variables"])
-
-    return params
-
-
-def parse_request_data(data: Mapping[str, Any]) -> GraphQLRequestData:
-    return GraphQLRequestData(
-        query=data.get("query"),
-        variables=data.get("variables"),
-        operation_name=data.get("operationName"),
-        extensions=data.get("extensions"),
-    )
-
-
 __all__ = [
     "GraphQLHTTPResponse",
     "GraphQLRequestData",

strawberry/http/async_base_view.py

@@ -33,7 +33,6 @@
 )
 from strawberry.subscriptions.protocols.graphql_ws.handlers import BaseGraphQLWSHandler
 from strawberry.types import ExecutionResult, SubscriptionExecutionResult
-from strawberry.types.context_wrapper import ContextWrapper
 from strawberry.types.graphql import OperationType
 from strawberry.types.unset import UNSET, UnsetType
 
@@ -198,26 +197,24 @@ async def execute_operation(
 
         assert self.schema
 
-        context_wrapper = ContextWrapper(
-            context=context, extensions=request_data.extensions
-        )
-
         if request_data.protocol == "multipart-subscription":
             return await self.schema.subscribe(
                 request_data.query,  # type: ignore
                 variable_values=request_data.variables,
                 context_value=context,
                 root_value=root_value,
                 operation_name=request_data.operation_name,
+                operation_extensions=request_data.extensions,
             )
 
         return await self.schema.execute(
             request_data.query,
             root_value=root_value,
             variable_values=request_data.variables,
-            context_value=context_wrapper,
+            context_value=context,
             operation_name=request_data.operation_name,
             allowed_operation_types=allowed_operation_types,
+            operation_extensions=request_data.extensions,
         )
 
     async def parse_multipart(self, request: AsyncHTTPRequestAdapter) -> dict[str, str]:

strawberry/http/sync_base_view.py

@@ -23,7 +23,6 @@
 from strawberry.schema import BaseSchema
 from strawberry.schema.exceptions import InvalidOperationTypeError
 from strawberry.types import ExecutionResult
-from strawberry.types.context_wrapper import ContextWrapper
 from strawberry.types.graphql import OperationType
 
 from .base import BaseView
@@ -116,17 +115,14 @@ def execute_operation(
 
         assert self.schema
 
-        context_wrapper = ContextWrapper(
-            context=context, extensions=request_data.extensions
-        )
-
         return self.schema.execute_sync(
             request_data.query,
             root_value=root_value,
             variable_values=request_data.variables,
-            context_value=context_wrapper,
+            context_value=context,
             operation_name=request_data.operation_name,
             allowed_operation_types=allowed_operation_types,
+            operation_extensions=request_data.extensions,
         )
 
     def parse_multipart(self, request: SyncHTTPRequestAdapter) -> dict[str, str]:

strawberry/schema/base.py

@@ -47,6 +47,7 @@ async def execute(
         root_value: Optional[Any] = None,
         operation_name: Optional[str] = None,
         allowed_operation_types: Optional[Iterable[OperationType]] = None,
+        operation_extensions: Optional[dict[str, Any]] = None,
     ) -> ExecutionResult:
         raise NotImplementedError
 
@@ -59,6 +60,7 @@ def execute_sync(
         root_value: Optional[Any] = None,
         operation_name: Optional[str] = None,
         allowed_operation_types: Optional[Iterable[OperationType]] = None,
+        operation_extensions: Optional[dict[str, Any]] = None,
     ) -> ExecutionResult:
         raise NotImplementedError
 
@@ -70,6 +72,7 @@ async def subscribe(
         context_value: Optional[Any] = None,
         root_value: Optional[Any] = None,
         operation_name: Optional[str] = None,
+        operation_extensions: Optional[dict[str, Any]] = None,
     ) -> SubscriptionResult:
         raise NotImplementedError
 

strawberry/schema/schema.py

@@ -9,27 +9,33 @@
     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,
 )
 from graphql import (
+    FieldNode,
+    FragmentDefinitionNode,
     GraphQLBoolean,
     GraphQLError,
     GraphQLField,
     GraphQLNamedType,
     GraphQLNonNull,
+    GraphQLObjectType,
+    GraphQLOutputType,
     GraphQLSchema,
+    OperationDefinitionNode,
     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
@@ -58,7 +64,7 @@
     PreExecutionError,
 )
 from strawberry.types.graphql import OperationType
-from strawberry.utils import IS_GQL_32
+from strawberry.utils import IS_GQL_32, IS_GQL_33
 from strawberry.utils.aio import aclosing
 from strawberry.utils.await_maybe import await_maybe
 
@@ -71,8 +77,10 @@
     from collections.abc import Iterable, Mapping
     from typing_extensions import TypeAlias
 
-    from graphql import ExecutionContext as GraphQLExecutionContext
+    from graphql.execution.collect_fields import FieldGroup
     from graphql.language import DocumentNode
+    from graphql.pyutils import Path
+    from graphql.type import GraphQLResolveInfo
     from graphql.validation import ASTValidationRule
 
     from strawberry.directive import StrawberryDirective
@@ -136,6 +144,54 @@ def _coerce_error(error: Union[GraphQLError, Exception]) -> GraphQLError:
     return GraphQLError(str(error), original_error=error)
 
 
+class OperationContextAwareGraphQLResolveInfo(NamedTuple):  # pyright: ignore
+    field_name: str
+    field_nodes: list[FieldNode]
+    return_type: GraphQLOutputType
+    parent_type: GraphQLObjectType
+    path: Path
+    schema: GraphQLSchema
+    fragments: dict[str, FragmentDefinitionNode]
+    root_value: Any
+    operation: OperationDefinitionNode
+    variable_values: dict[str, Any]
+    context: Any
+    is_awaitable: Callable[[Any], bool]
+    operation_extensions: dict[str, Any]
+
+
+class OperationContextAwareGraphQLExecutionContext(GraphQLExecutionContext):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        operation_extensions = kwargs.pop("operation_extensions", None)
+
+        super().__init__(*args, **kwargs)
+
+        self.operation_extensions = operation_extensions
+
+    def build_resolve_info(
+        self,
+        field_def: GraphQLField,
+        field_group: FieldGroup,
+        parent_type: GraphQLObjectType,
+        path: Path,
+    ) -> GraphQLResolveInfo:
+        return OperationContextAwareGraphQLResolveInfo(
+            field_group.fields[0].node.name.value,
+            field_group.to_nodes(),
+            field_def.type,
+            parent_type,
+            path,
+            self.schema,
+            self.fragments,
+            self.root_value,
+            self.operation,
+            self.variable_values,
+            self.context_value,
+            self.is_awaitable,
+            self.operation_extensions,
+        )
+
+
 class Schema(BaseSchema):
     def __init__(
         self,
@@ -195,7 +251,9 @@ class Query:
 
         self.extensions = extensions
         self._cached_middleware_manager: MiddlewareManager | None = None
-        self.execution_context_class = execution_context_class
+        self.execution_context_class = (
+            execution_context_class or OperationContextAwareGraphQLExecutionContext
+        )
         self.config = config or StrawberryConfig()
 
         self.schema_converter = GraphQLCoreConverter(
@@ -320,6 +378,14 @@ def create_extensions_runner(
             extensions=extensions,
         )
 
+    def _get_custom_context_kwargs(
+        self, operation_extensions: Optional[dict[str, Any]] = None
+    ) -> dict[str, Any]:
+        if not IS_GQL_33:
+            return {}
+
+        return {"operation_extensions": operation_extensions}
+
     def _get_middleware_manager(
         self, extensions: list[SchemaExtension]
     ) -> MiddlewareManager:
@@ -463,6 +529,7 @@ async def execute(
         root_value: Optional[Any] = None,
         operation_name: Optional[str] = None,
         allowed_operation_types: Optional[Iterable[OperationType]] = None,
+        operation_extensions: Optional[dict[str, Any]] = None,
     ) -> ExecutionResult:
         if allowed_operation_types is None:
             allowed_operation_types = DEFAULT_ALLOWED_OPERATION_TYPES
@@ -483,6 +550,8 @@ async def execute(
         extensions_runner = self.create_extensions_runner(execution_context, extensions)
         middleware_manager = self._get_middleware_manager(extensions)
 
+        custom_context_kwargs = self._get_custom_context_kwargs(operation_extensions)
+
         try:
             async with extensions_runner.operation():
                 # Note: In graphql-core the schema would be validated here but in
@@ -510,6 +579,7 @@ async def execute(
                                 operation_name=execution_context.operation_name,
                                 context_value=execution_context.context,
                                 execution_context_class=self.execution_context_class,
+                                **custom_context_kwargs,
                             )
                         )
                         execution_context.result = result
@@ -547,6 +617,7 @@ def execute_sync(
         root_value: Optional[Any] = None,
         operation_name: Optional[str] = None,
         allowed_operation_types: Optional[Iterable[OperationType]] = None,
+        operation_extensions: Optional[dict[str, Any]] = None,
     ) -> ExecutionResult:
         if allowed_operation_types is None:
             allowed_operation_types = DEFAULT_ALLOWED_OPERATION_TYPES
@@ -567,6 +638,8 @@ def execute_sync(
         extensions_runner = self.create_extensions_runner(execution_context, extensions)
         middleware_manager = self._get_middleware_manager(extensions)
 
+        custom_context_kwargs = self._get_custom_context_kwargs(operation_extensions)
+
         try:
             with extensions_runner.operation():
                 # Note: In graphql-core the schema would be validated here but in
@@ -617,6 +690,7 @@ def execute_sync(
                             operation_name=execution_context.operation_name,
                             context_value=execution_context.context,
                             execution_context_class=self.execution_context_class,
+                            **custom_context_kwargs,
                         )
 
                         if isawaitable(result):
@@ -661,6 +735,7 @@ async def _subscribe(
         extensions_runner: SchemaExtensionsRunner,
         middleware_manager: MiddlewareManager,
         execution_context_class: type[GraphQLExecutionContext] | None = None,
+        operation_extensions: Optional[dict[str, Any]] = None,
     ) -> AsyncGenerator[ExecutionResult, None]:
         async with extensions_runner.operation():
             if initial_error := await self._parse_and_validate_async(
@@ -679,6 +754,7 @@ async def _subscribe(
                     gql_33_kwargs = {
                         "middleware": middleware_manager,
                         "execution_context_class": execution_context_class,
+                        "operation_extensions": operation_extensions,
                     }
                     try:
                         # Might not be awaitable for pre-execution errors.
@@ -743,6 +819,7 @@ async def subscribe(
         context_value: Optional[Any] = None,
         root_value: Optional[Any] = None,
         operation_name: Optional[str] = None,
+        operation_extensions: Optional[dict[str, Any]] = None,
     ) -> SubscriptionResult:
         execution_context = self._create_execution_context(
             query=query,
@@ -764,6 +841,7 @@ async def subscribe(
             ),
             middleware_manager=self._get_middleware_manager(extensions),
             execution_context_class=self.execution_context_class,
+            operation_extensions=operation_extensions,
         )
 
     def _resolve_node_ids(self) -> None:

strawberry/types/context_wrapper.py

@@ -12,7 +12,6 @@
 )
 from typing_extensions import TypeVar
 
-from .context_wrapper import ContextWrapper
 from .nodes import convert_selections
 
 if TYPE_CHECKING:
@@ -112,18 +111,12 @@ def selected_fields(self) -> list[Selection]:
     @property
     def context(self) -> ContextType:
         """The context passed to the query execution."""
-        if isinstance(self._raw_info.context, ContextWrapper):
-            return self._raw_info.context.context
-
         return self._raw_info.context
 
     @property
     def input_extensions(self) -> dict[str, Any]:
         """The input extensions passed to the query execution."""
-        if isinstance(self._raw_info.context, ContextWrapper):
-            return self._raw_info.context.extensions
-
-        return {}
+        return self._raw_info.operation_extensions
 
     @property
     def root_value(self) -> RootValueType: