Add Query Batching Support

RELEASE.md

@@ -0,0 +1,68 @@
+Release type: minor
+
+## Add GraphQL Query batching support
+
+GraphQL query batching is now supported across all frameworks (sync and async)
+To enable query batching, set `batching_config.enabled` to True in the schema configuration.
+
+This makes your GraphQL API compatible with batching features supported by various
+client side libraries, such as [Apollo GraphQL](https://www.apollographql.com/docs/react/api/link/apollo-link-batch-http) and [Relay](https://github.com/relay-tools/react-relay-network-modern?tab=readme-ov-file#batching-several-requests-into-one).
+
+Example (FastAPI):
+
+```py
+import strawberry
+
+from fastapi import FastAPI
+from strawberry.fastapi import GraphQLRouter
+from strawberry.schema.config import StrawberryConfig
+
+
+@strawberry.type
+class Query:
+    @strawberry.field
+    def hello(self) -> str:
+        return "Hello World"
+
+
+schema = strawberry.Schema(
+    Query, config=StrawberryConfig(batching_config={"enabled": True})
+)
+
+graphql_app = GraphQLRouter(schema)
+
+app = FastAPI()
+app.include_router(graphql_app, prefix="/graphql")
+```
+
+Example (Flask):
+```py
+import strawberry
+
+from flask import Flask
+from strawberry.flask.views import GraphQLView
+
+app = Flask(__name__)
+
+
+@strawberry.type
+class Query:
+    @strawberry.field
+    def hello(self) -> str:
+        return "Hello World"
+
+
+schema = strawberry.Schema(
+    Query, config=StrawberryConfig(batching_config={"enabled": True})
+)
+
+app.add_url_rule(
+    "/graphql/batch",
+    view_func=GraphQLView.as_view("graphql_view", schema=schema),
+)
+
+if __name__ == "__main__":
+    app.run()
+```
+
+Note: Query Batching is not supported for multipart subscriptions

strawberry/aiohttp/views.py

@@ -210,7 +210,9 @@ async def get_context(
         return {"request": request, "response": response}  # type: ignore
 
     def create_response(
-        self, response_data: GraphQLHTTPResponse, sub_response: web.Response
+        self,
+        response_data: Union[GraphQLHTTPResponse, list[GraphQLHTTPResponse]],
+        sub_response: web.Response,
     ) -> web.Response:
         sub_response.text = self.encode_json(response_data)
         sub_response.content_type = "application/json"

strawberry/asgi/__init__.py

@@ -205,7 +205,9 @@ async def render_graphql_ide(self, request: Request) -> Response:
         return HTMLResponse(self.graphql_ide_html)
 
     def create_response(
-        self, response_data: GraphQLHTTPResponse, sub_response: Response
+        self,
+        response_data: Union[GraphQLHTTPResponse, list[GraphQLHTTPResponse]],
+        sub_response: Response,
     ) -> Response:
         response = Response(
             self.encode_json(response_data),

strawberry/chalice/views.py

@@ -114,7 +114,9 @@ def get_context(self, request: Request, response: TemporalResponse) -> Context:
         return {"request": request, "response": response}  # type: ignore
 
     def create_response(
-        self, response_data: GraphQLHTTPResponse, sub_response: TemporalResponse
+        self,
+        response_data: Union[GraphQLHTTPResponse, list[GraphQLHTTPResponse]],
+        sub_response: TemporalResponse,
     ) -> Response:
         status_code = 200
 

strawberry/channels/handlers/http_handler.py

@@ -5,13 +5,7 @@
 import warnings
 from functools import cached_property
 from io import BytesIO
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Optional,
-    Union,
-)
+from typing import TYPE_CHECKING, Any, Callable, Optional, Union
 from typing_extensions import TypeGuard, assert_never
 from urllib.parse import parse_qs
 
@@ -186,7 +180,9 @@ def __init__(
         super().__init__(**kwargs)
 
     def create_response(
-        self, response_data: GraphQLHTTPResponse, sub_response: TemporalResponse
+        self,
+        response_data: Union[GraphQLHTTPResponse, list[GraphQLHTTPResponse]],
+        sub_response: TemporalResponse,
     ) -> ChannelsResponse:
         return ChannelsResponse(
             content=json.dumps(response_data).encode(),

strawberry/django/apps.py

@@ -1,5 +1,5 @@
 from django.apps import AppConfig  # pragma: no cover
 
 
-class StrawberryConfig(AppConfig):  # pragma: no cover
+class StrawberryAppConfig(AppConfig):  # pragma: no cover
     name = "strawberry"

strawberry/django/views.py

@@ -163,7 +163,9 @@ def __init__(
         super().__init__(**kwargs)
 
     def create_response(
-        self, response_data: GraphQLHTTPResponse, sub_response: HttpResponse
+        self,
+        response_data: Union[GraphQLHTTPResponse, list[GraphQLHTTPResponse]],
+        sub_response: HttpResponse,
     ) -> HttpResponseBase:
         data = self.encode_json(response_data)
 

strawberry/fastapi/router.py

@@ -274,7 +274,9 @@ async def get_sub_response(self, request: Request) -> Response:
         return self.temporal_response
 
     def create_response(
-        self, response_data: GraphQLHTTPResponse, sub_response: Response
+        self,
+        response_data: Union[GraphQLHTTPResponse, list[GraphQLHTTPResponse]],
+        sub_response: Response,
     ) -> Response:
         response = Response(
             self.encode_json(response_data),

strawberry/flask/views.py

@@ -91,7 +91,9 @@ def __init__(
             self.graphql_ide = graphql_ide
 
     def create_response(
-        self, response_data: GraphQLHTTPResponse, sub_response: Response
+        self,
+        response_data: Union[GraphQLHTTPResponse, list[GraphQLHTTPResponse]],
+        sub_response: Response,
     ) -> Response:
         sub_response.set_data(self.encode_json(response_data))  # type: ignore
 

strawberry/http/async_base_view.py

@@ -147,7 +147,9 @@ async def get_root_value(
 
     @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
@@ -178,8 +180,12 @@ async def create_websocket_response(
     ) -> 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:
@@ -197,6 +203,22 @@ async def execute_operation(
 
         assert self.schema
 
+        if isinstance(request_data, list):
+            # batch GraphQL requests
+            tasks = [
+                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 await asyncio.gather(*tasks)
+
         if request_data.protocol == "multipart-subscription":
             return await self.schema.subscribe(
                 request_data.query,  # type: ignore
@@ -206,15 +228,49 @@ async def execute_operation(
                 operation_name=request_data.operation_name,
             )
 
-        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,
+            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}
+
+        assert self.schema
+
+        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,
+            )
+        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()
@@ -326,16 +382,12 @@ async def run(
                 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 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)
@@ -350,10 +402,20 @@ async def run(
                 },
             )
 
-        response_data = await self.process_result(request=request, result=result)
+        if isinstance(result, list):
+            response_data = []
+            for execution_result in result:
+                result = await self.process_result(
+                    request=request, result=execution_result
+                )
+                if execution_result.errors:
+                    self._handle_errors(execution_result.errors, result)
+                response_data.append(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
@@ -449,7 +511,7 @@ async def parse_multipart_subscriptions(
 
     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", "")
@@ -468,13 +530,29 @@ async def parse_http_body(
         else:
             raise HTTPException(400, "Unsupported content type")
 
+        if isinstance(data, list):
+            await self.validate_batch_request(data, protocol=protocol)
+            return [
+                GraphQLRequestData(
+                    query=item.get("query"),
+                    variables=item.get("variables"),
+                    operation_name=item.get("operationName"),
+                    protocol=protocol,
+                )
+                for item in data
+            ]
         return GraphQLRequestData(
             query=data.get("query"),
             variables=data.get("variables"),
             operation_name=data.get("operationName"),
             protocol=protocol,
         )
 
+    async def validate_batch_request(
+        self, request_data: list[GraphQLRequestData], protocol: str
+    ) -> None:
+        self._validate_batch_request(request_data=request_data, protocol=protocol)
+
     async def process_result(
         self, request: Request, result: ExecutionResult
     ) -> GraphQLHTTPResponse: