strawberry-graphql 0.277.1__py3-none-any.whl → 0.278.1__py3-none-any.whl

strawberry/http/async_base_view.py

@@ -8,14 +8,16 @@ from typing import (
     Any,
     Callable,
     Generic,
+    Literal,
     Optional,
     Union,
     cast,
     overload,
 )
-from typing_extensions import Literal, TypeGuard
+from typing_extensions import 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
@@ -43,9 +45,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,
@@ -57,30 +57,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
@@ -153,7 +129,9 @@ class AsyncBaseHTTPView(
 
     @abc.abstractmethod
     def create_response(
-        self, response_data: GraphQLHTTPResponse, sub_response: SubResponse
+        self,
+        response_data: Union[GraphQLHTTPResponse, list[GraphQLHTTPResponse]],
+        sub_response: SubResponse,
     ) -> Response: ...
 
     @abc.abstractmethod
@@ -184,8 +162,12 @@ class AsyncBaseHTTPView(
     ) -> WebSocketResponse: ...
 
     async def execute_operation(
-        self, request: Request, context: Context, root_value: Optional[RootValue]
-    ) -> Union[ExecutionResult, SubscriptionExecutionResult]:
+        self,
+        request: Request,
+        context: Context,
+        root_value: Optional[RootValue],
+        sub_response: SubResponse,
+    ) -> Union[ExecutionResult, list[ExecutionResult], SubscriptionExecutionResult]:
         request_adapter = self.request_adapter_class(request)
 
         try:
@@ -201,6 +183,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
@@ -211,24 +209,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: Optional[RootValue],
+        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)
@@ -237,9 +270,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
 
@@ -330,18 +361,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)
@@ -425,10 +450,22 @@ class AsyncBaseHTTPView(
                 },
             )
 
-        response_data = await self.process_result(request=request, result=result)
+        response_data: Union[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
@@ -584,15 +621,16 @@ class AsyncBaseHTTPView(
 
     async def parse_http_body(
         self, request: AsyncHTTPRequestAdapter
-    ) -> GraphQLRequestData:
+    ) -> Union[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)
@@ -603,6 +641,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(

strawberry/http/base.py

@@ -3,10 +3,13 @@ from collections.abc import Mapping
 from typing import Any, Generic, Optional, Union
 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
 
 
@@ -24,6 +27,7 @@ class BaseRequestProtocol(Protocol):
 class BaseView(Generic[Request]):
     graphql_ide: Optional[GraphQL_IDE]
     multipart_uploads_enabled: bool = False
+    schema: BaseSchema
 
     def should_render_graphql_ide(self, request: BaseRequestProtocol) -> bool:
         return (
@@ -82,5 +86,19 @@ class BaseView(Generic[Request]):
 
         return params.get("subscriptionspec", "").startswith("1.0")
 
+    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"
+            )
+
+        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/sync_base_view.py

@@ -1,15 +1,15 @@
 import abc
 import json
-from collections.abc import Mapping
 from typing import (
-    Any,
     Callable,
     Generic,
+    Literal,
     Optional,
     Union,
 )
 
 from graphql import GraphQLError
+from lia import HTTPException, SyncHTTPRequestAdapter
 
 from strawberry.exceptions import MissingQueryError
 from strawberry.file_uploads.utils import replace_placeholders_with_files
@@ -29,42 +29,10 @@ from strawberry.types.graphql import OperationType
 from strawberry.types.unset import UNSET
 
 from .base import BaseView
-from .exceptions import HTTPException
 from .parse_content_type import parse_content_type
-from .types import HTTPMethod, QueryParams
 from .typevars import Context, Request, Response, RootValue, SubResponse
 
 
-class SyncHTTPRequestAdapter(abc.ABC):
-    @property
-    @abc.abstractmethod
-    def query_params(self) -> QueryParams: ...
-
-    @property
-    @abc.abstractmethod
-    def body(self) -> Union[str, bytes]: ...
-
-    @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]: ...
-
-    @property
-    @abc.abstractmethod
-    def post_data(self) -> Mapping[str, Union[str, bytes]]: ...
-
-    @property
-    @abc.abstractmethod
-    def files(self) -> Mapping[str, Any]: ...
-
-
 class SyncBaseHTTPView(
     abc.ABC,
     BaseView[Request],
@@ -92,15 +60,21 @@ class SyncBaseHTTPView(
 
     @abc.abstractmethod
     def create_response(
-        self, response_data: GraphQLHTTPResponse, sub_response: SubResponse
+        self,
+        response_data: Union[GraphQLHTTPResponse, list[GraphQLHTTPResponse]],
+        sub_response: SubResponse,
     ) -> Response: ...
 
     @abc.abstractmethod
     def render_graphql_ide(self, request: Request) -> Response: ...
 
     def execute_operation(
-        self, request: Request, context: Context, root_value: Optional[RootValue]
-    ) -> ExecutionResult:
+        self,
+        request: Request,
+        context: Context,
+        root_value: Optional[RootValue],
+        sub_response: SubResponse,
+    ) -> Union[ExecutionResult, list[ExecutionResult]]:
         request_adapter = self.request_adapter_class(request)
 
         try:
@@ -116,16 +90,64 @@ class SyncBaseHTTPView(
         if not self.allow_queries_via_get and request_adapter.method == "GET":
             allowed_operation_types = allowed_operation_types - {OperationType.QUERY}
 
-        return self.schema.execute_sync(
-            request_data.query,
+        if isinstance(request_data, list):
+            # batch GraphQL requests
+            return [
+                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
+            ]
+
+        return 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,
         )
 
+    def execute_single(
+        self,
+        request: Request,
+        request_adapter: SyncHTTPRequestAdapter,
+        sub_response: SubResponse,
+        context: Context,
+        root_value: Optional[RootValue],
+        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 = self.schema.execute_sync(
+                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
+
     def parse_multipart(self, request: SyncHTTPRequestAdapter) -> dict[str, str]:
         operations = self.parse_json(request.post_data.get("operations", "{}"))
         files_map = self.parse_json(request.post_data.get("map", "{}"))
@@ -135,8 +157,18 @@ class SyncBaseHTTPView(
         except KeyError as e:
             raise HTTPException(400, "File(s) missing in form data") from e
 
-    def parse_http_body(self, request: SyncHTTPRequestAdapter) -> GraphQLRequestData:
+    def parse_http_body(
+        self, request: SyncHTTPRequestAdapter
+    ) -> Union[GraphQLRequestData, list[GraphQLRequestData]]:
+        headers = {key.lower(): value for key, value in request.headers.items()}
         content_type, params = parse_content_type(request.content_type or "")
+        accept = headers.get("accept", "")
+
+        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)
@@ -152,6 +184,18 @@ class SyncBaseHTTPView(
         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"),
+                )
+                for item in data
+            ]
+
         query = data.get("query")
         if not isinstance(query, (str, type(None))):
             raise HTTPException(
@@ -209,25 +253,29 @@ class SyncBaseHTTPView(
         )
         root_value = self.get_root_value(request) if root_value is UNSET else root_value
 
-        try:
-            result = 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 = self.execute_operation(
+            request=request,
+            context=context,
+            root_value=root_value,
+            sub_response=sub_response,
+        )
 
-        response_data = self.process_result(request=request, result=result)
+        response_data: Union[GraphQLHTTPResponse, list[GraphQLHTTPResponse]]
+
+        if isinstance(result, list):
+            response_data = []
+            for execution_result in result:
+                processed_result = 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 = 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

strawberry/litestar/controller.py

@@ -13,10 +13,10 @@ from typing import (
     Optional,
     TypedDict,
     Union,
-    cast,
 )
 from typing_extensions import TypeGuard
 
+from lia import HTTPException, LitestarRequestAdapter
 from msgspec import Struct
 
 from litestar import (
@@ -41,16 +41,13 @@ from litestar.status_codes import HTTP_200_OK
 from strawberry.exceptions import InvalidCustomContext
 from strawberry.http.async_base_view import (
     AsyncBaseHTTPView,
-    AsyncHTTPRequestAdapter,
     AsyncWebSocketAdapter,
 )
 from strawberry.http.exceptions import (
-    HTTPException,
     NonJsonMessageReceived,
     NonTextMessageReceived,
     WebSocketDisconnected,
 )
-from strawberry.http.types import FormData, HTTPMethod, QueryParams
 from strawberry.http.typevars import Context, RootValue
 from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL, GRAPHQL_WS_PROTOCOL
 
@@ -153,41 +150,6 @@ class GraphQLResource(Struct):
     extensions: Optional[dict[str, object]]
 
 
-class LitestarRequestAdapter(AsyncHTTPRequestAdapter):
-    def __init__(self, request: Request[Any, Any, Any]) -> None:
-        self.request = request
-
-    @property
-    def query_params(self) -> QueryParams:
-        return self.request.query_params
-
-    @property
-    def method(self) -> HTTPMethod:
-        return cast("HTTPMethod", self.request.method.upper())
-
-    @property
-    def headers(self) -> Mapping[str, str]:
-        return self.request.headers
-
-    @property
-    def content_type(self) -> Optional[str]:
-        content_type, params = self.request.content_type
-
-        # combine content type and params
-        if params:
-            content_type += "; " + "; ".join(f"{k}={v}" for k, v in params.items())
-
-        return content_type
-
-    async def get_body(self) -> bytes:
-        return await self.request.body()
-
-    async def get_form_data(self) -> FormData:
-        multipart_data = await self.request.form()
-
-        return FormData(form=multipart_data, files=multipart_data)
-
-
 class LitestarWebSocketAdapter(AsyncWebSocketAdapter):
     def __init__(
         self, view: AsyncBaseHTTPView, request: WebSocket, response: WebSocket
@@ -302,7 +264,9 @@ class GraphQLController(
         return Response(self.graphql_ide_html, media_type=MediaType.HTML)
 
     def create_response(
-        self, response_data: GraphQLHTTPResponse, sub_response: Response[bytes]
+        self,
+        response_data: Union[GraphQLHTTPResponse, list[GraphQLHTTPResponse]],
+        sub_response: Response[bytes],
     ) -> Response[bytes]:
         response = Response(
             self.encode_json(response_data).encode(),