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

strawberry/http/async_base_view.py

@@ -2,20 +2,19 @@ import abc
 import asyncio
 import contextlib
 import json
-from collections.abc import AsyncGenerator, Mapping
+from collections.abc import AsyncGenerator, Callable, Mapping
 from datetime import timedelta
 from typing import (
     Any,
-    Callable,
     Generic,
-    Optional,
-    Union,
+    Literal,
+    TypeGuard,
     cast,
     overload,
 )
-from typing_extensions import Literal, TypeGuard
 
 from graphql import GraphQLError
+from lia import AsyncHTTPRequestAdapter, HTTPException
 
 from strawberry.exceptions import MissingQueryError
 from strawberry.file_uploads.utils import replace_placeholders_with_files
@@ -25,6 +24,9 @@ from strawberry.http import (
     process_result,
 )
 from strawberry.http.ides import GraphQL_IDE
+from strawberry.schema._graphql_core import (
+    GraphQLIncrementalExecutionResults,
+)
 from strawberry.schema.base import BaseSchema
 from strawberry.schema.exceptions import (
     CannotGetOperationTypeError,
@@ -40,9 +42,7 @@ from strawberry.types.graphql import OperationType
 from strawberry.types.unset import UNSET, UnsetType
 
 from .base import BaseView
-from .exceptions import HTTPException
 from .parse_content_type import parse_content_type
-from .types import FormData, HTTPMethod, QueryParams
 from .typevars import (
     Context,
     Request,
@@ -54,30 +54,6 @@ from .typevars import (
 )
 
 
-class AsyncHTTPRequestAdapter(abc.ABC):
-    @property
-    @abc.abstractmethod
-    def query_params(self) -> QueryParams: ...
-
-    @property
-    @abc.abstractmethod
-    def method(self) -> HTTPMethod: ...
-
-    @property
-    @abc.abstractmethod
-    def headers(self) -> Mapping[str, str]: ...
-
-    @property
-    @abc.abstractmethod
-    def content_type(self) -> Optional[str]: ...
-
-    @abc.abstractmethod
-    async def get_body(self) -> Union[str, bytes]: ...
-
-    @abc.abstractmethod
-    async def get_form_data(self) -> FormData: ...
-
-
 class AsyncWebSocketAdapter(abc.ABC):
     def __init__(self, view: "AsyncBaseHTTPView") -> None:
         self.view = view
@@ -108,10 +84,9 @@ class AsyncBaseHTTPView(
     ],
 ):
     schema: BaseSchema
-    graphql_ide: Optional[GraphQL_IDE]
-    debug: bool
+    graphql_ide: GraphQL_IDE | None
     keep_alive = False
-    keep_alive_interval: Optional[float] = None
+    keep_alive_interval: float | None = None
     connection_init_wait_timeout: timedelta = timedelta(minutes=1)
     request_adapter_class: Callable[[Request], AsyncHTTPRequestAdapter]
     websocket_adapter_class: Callable[
@@ -139,18 +114,20 @@ class AsyncBaseHTTPView(
     @abc.abstractmethod
     async def get_context(
         self,
-        request: Union[Request, WebSocketRequest],
-        response: Union[SubResponse, WebSocketResponse],
+        request: Request | WebSocketRequest,
+        response: SubResponse | WebSocketResponse,
     ) -> Context: ...
 
     @abc.abstractmethod
     async def get_root_value(
-        self, request: Union[Request, WebSocketRequest]
-    ) -> Optional[RootValue]: ...
+        self, request: Request | WebSocketRequest
+    ) -> RootValue | None: ...
 
     @abc.abstractmethod
     def create_response(
-        self, response_data: GraphQLHTTPResponse, sub_response: SubResponse
+        self,
+        response_data: GraphQLHTTPResponse | list[GraphQLHTTPResponse],
+        sub_response: SubResponse,
     ) -> Response: ...
 
     @abc.abstractmethod
@@ -167,22 +144,26 @@ class AsyncBaseHTTPView(
 
     @abc.abstractmethod
     def is_websocket_request(
-        self, request: Union[Request, WebSocketRequest]
+        self, request: Request | WebSocketRequest
     ) -> TypeGuard[WebSocketRequest]: ...
 
     @abc.abstractmethod
     async def pick_websocket_subprotocol(
         self, request: WebSocketRequest
-    ) -> Optional[str]: ...
+    ) -> str | None: ...
 
     @abc.abstractmethod
     async def create_websocket_response(
-        self, request: WebSocketRequest, subprotocol: Optional[str]
+        self, request: WebSocketRequest, subprotocol: str | None
     ) -> WebSocketResponse: ...
 
     async def execute_operation(
-        self, request: Request, context: Context, root_value: Optional[RootValue]
-    ) -> Union[ExecutionResult, SubscriptionExecutionResult]:
+        self,
+        request: Request,
+        context: Context,
+        root_value: RootValue | None,
+        sub_response: SubResponse,
+    ) -> ExecutionResult | list[ExecutionResult] | SubscriptionExecutionResult:
         request_adapter = self.request_adapter_class(request)
 
         try:
@@ -198,6 +179,22 @@ class AsyncBaseHTTPView(
         if not self.allow_queries_via_get and request_adapter.method == "GET":
             allowed_operation_types = allowed_operation_types - {OperationType.QUERY}
 
+        if isinstance(request_data, list):
+            # batch GraphQL requests
+            return await asyncio.gather(
+                *[
+                    self.execute_single(
+                        request=request,
+                        request_adapter=request_adapter,
+                        sub_response=sub_response,
+                        context=context,
+                        root_value=root_value,
+                        request_data=data,
+                    )
+                    for data in request_data
+                ]
+            )
+
         if request_data.protocol == "multipart-subscription":
             return await self.schema.subscribe(
                 request_data.query,  # type: ignore
@@ -208,24 +205,59 @@ class AsyncBaseHTTPView(
                 operation_extensions=request_data.extensions,
             )
 
-        return await self.schema.execute(
-            request_data.query,
+        return await self.execute_single(
+            request=request,
+            request_adapter=request_adapter,
+            sub_response=sub_response,
+            context=context,
             root_value=root_value,
-            variable_values=request_data.variables,
-            context_value=context,
-            operation_name=request_data.operation_name,
-            allowed_operation_types=allowed_operation_types,
-            operation_extensions=request_data.extensions,
+            request_data=request_data,
         )
 
+    async def execute_single(
+        self,
+        request: Request,
+        request_adapter: AsyncHTTPRequestAdapter,
+        sub_response: SubResponse,
+        context: Context,
+        root_value: RootValue | None,
+        request_data: GraphQLRequestData,
+    ) -> ExecutionResult:
+        allowed_operation_types = OperationType.from_http(request_adapter.method)
+
+        if not self.allow_queries_via_get and request_adapter.method == "GET":
+            allowed_operation_types = allowed_operation_types - {OperationType.QUERY}
+
+        try:
+            result = await self.schema.execute(
+                request_data.query,
+                root_value=root_value,
+                variable_values=request_data.variables,
+                context_value=context,
+                operation_name=request_data.operation_name,
+                allowed_operation_types=allowed_operation_types,
+                operation_extensions=request_data.extensions,
+            )
+        except CannotGetOperationTypeError as e:
+            raise HTTPException(400, e.as_http_error_reason()) from e
+        except InvalidOperationTypeError as e:
+            raise HTTPException(
+                400, e.as_http_error_reason(request_adapter.method)
+            ) from e
+        except MissingQueryError as e:
+            raise HTTPException(400, "No GraphQL query found in the request") from e
+
+        return result
+
     async def parse_multipart(self, request: AsyncHTTPRequestAdapter) -> dict[str, str]:
         try:
             form_data = await request.get_form_data()
         except ValueError as e:
             raise HTTPException(400, "Unable to parse the multipart body") from e
 
-        operations = form_data["form"].get("operations", "{}")
-        files_map = form_data["form"].get("map", "{}")
+        operations = form_data.form.get("operations", "{}")
+        files_map = form_data.form.get("map", "{}")
+        files = form_data.files
 
         if isinstance(operations, (bytes, str)):
             operations = self.parse_json(operations)
@@ -234,9 +266,7 @@ class AsyncBaseHTTPView(
             files_map = self.parse_json(files_map)
 
         try:
-            return replace_placeholders_with_files(
-                operations, files_map, form_data["files"]
-            )
+            return replace_placeholders_with_files(operations, files_map, files)
         except KeyError as e:
             raise HTTPException(400, "File(s) missing in form data") from e
 
@@ -250,7 +280,7 @@ class AsyncBaseHTTPView(
         self,
         request: Request,
         context: Context = UNSET,
-        root_value: Optional[RootValue] = UNSET,
+        root_value: RootValue | None = UNSET,
     ) -> Response: ...
 
     @overload
@@ -258,15 +288,15 @@ class AsyncBaseHTTPView(
         self,
         request: WebSocketRequest,
         context: Context = UNSET,
-        root_value: Optional[RootValue] = UNSET,
+        root_value: RootValue | None = UNSET,
     ) -> WebSocketResponse: ...
 
     async def run(
         self,
-        request: Union[Request, WebSocketRequest],
+        request: Request | WebSocketRequest,
         context: Context = UNSET,
-        root_value: Optional[RootValue] = UNSET,
-    ) -> Union[Response, WebSocketResponse]:
+        root_value: RootValue | None = UNSET,
+    ) -> Response | WebSocketResponse:
         root_value = (
             await self.get_root_value(request) if root_value is UNSET else root_value
         )
@@ -291,7 +321,6 @@ class AsyncBaseHTTPView(
                     context=context,
                     root_value=root_value,
                     schema=self.schema,
-                    debug=self.debug,
                     connection_init_wait_timeout=self.connection_init_wait_timeout,
                 ).handle()
             elif websocket_subprotocol == GRAPHQL_WS_PROTOCOL:
@@ -301,7 +330,6 @@ class AsyncBaseHTTPView(
                     context=context,
                     root_value=root_value,
                     schema=self.schema,
-                    debug=self.debug,
                     keep_alive=self.keep_alive,
                     keep_alive_interval=self.keep_alive_interval,
                 ).handle()
@@ -327,18 +355,12 @@ class AsyncBaseHTTPView(
                 return await self.render_graphql_ide(request)
             raise HTTPException(404, "Not Found")
 
-        try:
-            result = await self.execute_operation(
-                request=request, context=context, root_value=root_value
-            )
-        except CannotGetOperationTypeError as e:
-            raise HTTPException(400, e.as_http_error_reason()) from e
-        except InvalidOperationTypeError as e:
-            raise HTTPException(
-                400, e.as_http_error_reason(request_adapter.method)
-            ) from e
-        except MissingQueryError as e:
-            raise HTTPException(400, "No GraphQL query found in the request") from e
+        result = await self.execute_operation(
+            request=request,
+            context=context,
+            root_value=root_value,
+            sub_response=sub_response,
+        )
 
         if isinstance(result, SubscriptionExecutionResult):
             stream = self._get_stream(request, result)
@@ -348,27 +370,110 @@ class AsyncBaseHTTPView(
                 stream,
                 sub_response,
                 headers={
-                    "Transfer-Encoding": "chunked",
                     "Content-Type": "multipart/mixed;boundary=graphql;subscriptionSpec=1.0,application/json",
                 },
             )
+        if isinstance(result, GraphQLIncrementalExecutionResults):
+
+            async def stream() -> AsyncGenerator[str, None]:
+                yield "---"
+
+                response = await self.process_result(request, result.initial_result)
+
+                response["hasNext"] = result.initial_result.has_next
+                response["pending"] = [
+                    p.formatted for p in result.initial_result.pending
+                ]
+                response["extensions"] = result.initial_result.extensions
+
+                yield self.encode_multipart_data(response, "-")
+
+                all_pending = result.initial_result.pending
+
+                async for value in result.subsequent_results:
+                    response = {
+                        "hasNext": value.has_next,
+                        "extensions": value.extensions,
+                    }
+
+                    if value.pending:
+                        response["pending"] = [p.formatted for p in value.pending]
+
+                    if value.completed:
+                        response["completed"] = [p.formatted for p in value.completed]
+
+                    if value.incremental:
+                        incremental = []
+
+                        all_pending.extend(value.pending)
+
+                        for incremental_value in value.incremental:
+                            pending_value = next(
+                                (
+                                    v
+                                    for v in all_pending
+                                    if v.id == incremental_value.id
+                                ),
+                                None,
+                            )
+
+                            assert pending_value
+
+                            incremental.append(
+                                {
+                                    **incremental_value.formatted,
+                                    "path": pending_value.path,
+                                    "label": pending_value.label,
+                                }
+                            )
+
+                        response["incremental"] = incremental
+
+                    yield self.encode_multipart_data(response, "-")
+
+                yield "--\r\n"
+
+            return await self.create_streaming_response(
+                request,
+                stream,
+                sub_response,
+                headers={
+                    "Content-Type": 'multipart/mixed; boundary="-"',
+                },
+            )
 
-        response_data = await self.process_result(request=request, result=result)
+        response_data: GraphQLHTTPResponse | list[GraphQLHTTPResponse]
+
+        if isinstance(result, list):
+            response_data = []
+            for execution_result in result:
+                processed_result = await self.process_result(
+                    request=request, result=execution_result
+                )
+                if execution_result.errors:
+                    self._handle_errors(execution_result.errors, processed_result)
+                response_data.append(processed_result)
+        else:
+            response_data = await self.process_result(request=request, result=result)
 
-        if result.errors:
-            self._handle_errors(result.errors, response_data)
+            if result.errors:
+                self._handle_errors(result.errors, response_data)
 
         return self.create_response(
             response_data=response_data, sub_response=sub_response
         )
 
     def encode_multipart_data(self, data: Any, separator: str) -> str:
+        encoded_data = self.encode_json(data)
+
         return "".join(
             [
-                f"\r\n--{separator}\r\n",
-                "Content-Type: application/json\r\n\r\n",
-                self.encode_json(data),
-                "\n",
+                "\r\n",
+                "Content-Type: application/json; charset=utf-8\r\n",
+                "Content-Length: " + str(len(encoded_data)) + "\r\n",
+                "\r\n",
+                encoded_data,
+                f"\r\n--{separator}",
             ]
         )
 
@@ -508,15 +613,16 @@ class AsyncBaseHTTPView(
 
     async def parse_http_body(
         self, request: AsyncHTTPRequestAdapter
-    ) -> GraphQLRequestData:
+    ) -> GraphQLRequestData | list[GraphQLRequestData]:
         headers = {key.lower(): value for key, value in request.headers.items()}
         content_type, _ = parse_content_type(request.content_type or "")
         accept = headers.get("accept", "")
 
-        protocol: Literal["http", "multipart-subscription"] = "http"
-
-        if self._is_multipart_subscriptions(*parse_content_type(accept)):
-            protocol = "multipart-subscription"
+        protocol: Literal["http", "multipart-subscription"] = (
+            "multipart-subscription"
+            if self._is_multipart_subscriptions(*parse_content_type(accept))
+            else "http"
+        )
 
         if request.method == "GET":
             data = self.parse_query_params(request.query_params)
@@ -527,6 +633,19 @@ class AsyncBaseHTTPView(
         else:
             raise HTTPException(400, "Unsupported content type")
 
+        if isinstance(data, list):
+            self._validate_batch_request(data, protocol=protocol)
+            return [
+                GraphQLRequestData(
+                    query=item.get("query"),
+                    variables=item.get("variables"),
+                    operation_name=item.get("operationName"),
+                    extensions=item.get("extensions"),
+                    protocol=protocol,
+                )
+                for item in data
+            ]
+
         query = data.get("query")
         if not isinstance(query, (str, type(None))):
             raise HTTPException(
@@ -563,7 +682,7 @@ class AsyncBaseHTTPView(
 
     async def on_ws_connect(
         self, context: Context
-    ) -> Union[UnsetType, None, dict[str, object]]:
+    ) -> UnsetType | None | dict[str, object]:
         return UNSET
 
 

strawberry/http/base.py

@@ -1,18 +1,21 @@
 import json
 from collections.abc import Mapping
-from typing import Any, Generic, Optional, Union
+from typing import Any, Generic
 from typing_extensions import Protocol
 
+from lia import HTTPException
+
+from strawberry.http import GraphQLRequestData
 from strawberry.http.ides import GraphQL_IDE, get_graphql_ide_html
 from strawberry.http.types import HTTPMethod, QueryParams
+from strawberry.schema.base import BaseSchema
 
-from .exceptions import HTTPException
 from .typevars import Request
 
 
 class BaseRequestProtocol(Protocol):
     @property
-    def query_params(self) -> Mapping[str, Optional[Union[str, list[str]]]]: ...
+    def query_params(self) -> Mapping[str, str | list[str] | None]: ...
 
     @property
     def method(self) -> HTTPMethod: ...
@@ -22,8 +25,9 @@ class BaseRequestProtocol(Protocol):
 
 
 class BaseView(Generic[Request]):
-    graphql_ide: Optional[GraphQL_IDE]
+    graphql_ide: GraphQL_IDE | None
     multipart_uploads_enabled: bool = False
+    schema: BaseSchema
 
     def should_render_graphql_ide(self, request: BaseRequestProtocol) -> bool:
         return (
@@ -38,13 +42,13 @@ class BaseView(Generic[Request]):
     def is_request_allowed(self, request: BaseRequestProtocol) -> bool:
         return request.method in ("GET", "POST")
 
-    def parse_json(self, data: Union[str, bytes]) -> Any:
+    def parse_json(self, data: str | bytes) -> Any:
         try:
             return self.decode_json(data)
         except json.JSONDecodeError as e:
             raise HTTPException(400, "Unable to parse request body as JSON") from e
 
-    def decode_json(self, data: Union[str, bytes]) -> object:
+    def decode_json(self, data: str | bytes) -> object:
         return json.loads(data)
 
     def encode_json(self, data: object) -> str:
@@ -74,13 +78,26 @@ class BaseView(Generic[Request]):
     def _is_multipart_subscriptions(
         self, content_type: str, params: dict[str, str]
     ) -> bool:
-        if content_type != "multipart/mixed":
-            return False
+        subscription_spec = params.get("subscriptionspec", "").strip("'\"")
+        return (
+            content_type == "multipart/mixed"
+            and ("boundary" not in params or params["boundary"] == "graphql")
+            and subscription_spec.startswith("1.0")
+        )
 
-        if params.get("boundary") != "graphql":
-            return False
+    def _validate_batch_request(
+        self, request_data: list[GraphQLRequestData], protocol: str
+    ) -> None:
+        if self.schema.config.batching_config is None:
+            raise HTTPException(400, "Batching is not enabled")
+
+        if protocol == "multipart-subscription":
+            raise HTTPException(
+                400, "Batching is not supported for multipart subscriptions"
+            )
 
-        return params.get("subscriptionspec", "").startswith("1.0")
+        if len(request_data) > self.schema.config.batching_config["max_operations"]:
+            raise HTTPException(400, "Too many operations")
 
 
 __all__ = ["BaseView"]

strawberry/http/exceptions.py

@@ -1,9 +1,3 @@
-class HTTPException(Exception):
-    def __init__(self, status_code: int, reason: str) -> None:
-        self.status_code = status_code
-        self.reason = reason
-
-
 class NonTextMessageReceived(Exception):
     pass
 
@@ -16,4 +10,8 @@ class WebSocketDisconnected(Exception):
     pass
 
 
-__all__ = ["HTTPException"]
+__all__ = [
+    "NonJsonMessageReceived",
+    "NonTextMessageReceived",
+    "WebSocketDisconnected",
+]

strawberry/http/ides.py

@@ -1,12 +1,11 @@
 import pathlib
-from typing import Optional
-from typing_extensions import Literal
+from typing import Literal
 
 GraphQL_IDE = Literal["graphiql", "apollo-sandbox", "pathfinder"]
 
 
 def get_graphql_ide_html(
-    graphql_ide: Optional[GraphQL_IDE] = "graphiql",
+    graphql_ide: GraphQL_IDE | None = "graphiql",
 ) -> str:
     here = pathlib.Path(__file__).parents[1]