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

strawberry/http/sync_base_view.py

@@ -1,15 +1,13 @@
 import abc
 import json
-from collections.abc import Mapping
+from collections.abc import Callable
 from typing import (
-    Any,
-    Callable,
     Generic,
-    Optional,
-    Union,
+    Literal,
 )
 
 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,50 +27,18 @@ 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],
     Generic[Request, Response, SubResponse, Context, RootValue],
 ):
     schema: BaseSchema
-    graphiql: Optional[bool]
-    graphql_ide: Optional[GraphQL_IDE]
+    graphiql: bool | None
+    graphql_ide: GraphQL_IDE | None
     request_adapter_class: Callable[[Request], SyncHTTPRequestAdapter]
 
     # Methods that need to be implemented by individual frameworks
@@ -88,19 +54,25 @@ class SyncBaseHTTPView(
     def get_context(self, request: Request, response: SubResponse) -> Context: ...
 
     @abc.abstractmethod
-    def get_root_value(self, request: Request) -> Optional[RootValue]: ...
+    def get_root_value(self, request: Request) -> 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
     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: RootValue | None,
+        sub_response: SubResponse,
+    ) -> ExecutionResult | list[ExecutionResult]:
         request_adapter = self.request_adapter_class(request)
 
         try:
@@ -116,16 +88,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: 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 = 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 +155,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
+    ) -> 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 +182,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(
@@ -189,7 +231,7 @@ class SyncBaseHTTPView(
         self,
         request: Request,
         context: Context = UNSET,
-        root_value: Optional[RootValue] = UNSET,
+        root_value: RootValue | None = UNSET,
     ) -> Response:
         request_adapter = self.request_adapter_class(request)
 
@@ -209,25 +251,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: 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/http/types.py

@@ -1,12 +1,12 @@
 from collections.abc import Mapping
-from typing import Any, Optional
-from typing_extensions import Literal, TypedDict
+from typing import Any, Literal
+from typing_extensions import TypedDict
 
 HTTPMethod = Literal[
     "GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS", "TRACE"
 ]
 
-QueryParams = Mapping[str, Optional[str]]
+QueryParams = Mapping[str, str | None]
 
 
 class FormData(TypedDict):

strawberry/litestar/controller.py

@@ -8,17 +8,13 @@ from datetime import timedelta
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     ClassVar,
-    Optional,
+    TypeAlias,
     TypedDict,
-    Union,
-    cast,
+    TypeGuard,
 )
-from typing_extensions import TypeGuard
-
-from msgspec import Struct
 
+from lia import HTTPException, LitestarRequestAdapter
 from litestar import (
     Controller,
     MediaType,
@@ -38,35 +34,41 @@ from litestar.exceptions import (
 )
 from litestar.response.streaming import Stream
 from litestar.status_codes import HTTP_200_OK
+from msgspec import Struct
+
 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
 
 if TYPE_CHECKING:
-    from collections.abc import AsyncGenerator, AsyncIterator, Mapping, Sequence
+    from collections.abc import (
+        AsyncGenerator,
+        AsyncIterator,
+        Callable,
+        Mapping,
+        Sequence,
+    )
 
     from litestar.types import AnyCallable, Dependencies
+
     from strawberry.http import GraphQLHTTPResponse
     from strawberry.http.ides import GraphQL_IDE
     from strawberry.schema import BaseSchema
 
 
 class BaseContext(Struct, kw_only=True):
-    request: Optional[Request] = None
-    websocket: Optional[WebSocket] = None
-    response: Optional[Response] = None
+    request: Request | None = None
+    websocket: WebSocket | None = None
+    response: Response | None = None
 
 
 class HTTPContextType:
@@ -91,9 +93,9 @@ class WebSocketContextDict(TypedDict):
     socket: WebSocket
 
 
-MergedContext = Union[
-    BaseContext, WebSocketContextDict, HTTPContextDict, dict[str, Any]
-]
+MergedContext: TypeAlias = (
+    BaseContext | WebSocketContextDict | HTTPContextDict | dict[str, Any]
+)
 
 
 async def _none_custom_context_getter() -> None:
@@ -105,7 +107,7 @@ async def _none_root_value_getter() -> None:
 
 
 async def _context_getter_ws(
-    custom_context: Optional[Any], socket: WebSocket
+    custom_context: Any | None, socket: WebSocket
 ) -> MergedContext:
     if isinstance(custom_context, BaseContext):
         custom_context.websocket = socket
@@ -127,7 +129,7 @@ def _response_getter() -> Response:
 
 
 async def _context_getter_http(
-    custom_context: Optional[Any],
+    custom_context: Any | None,
     response: Response,
     request: Request[Any, Any, Any],
 ) -> MergedContext:
@@ -148,44 +150,9 @@ async def _context_getter_http(
 
 
 class GraphQLResource(Struct):
-    data: Optional[dict[str, object]]
-    errors: Optional[list[object]]
-    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)
+    data: dict[str, object] | None
+    errors: list[object] | None
+    extensions: dict[str, object] | None
 
 
 class LitestarWebSocketAdapter(AsyncWebSocketAdapter):
@@ -246,12 +213,11 @@ class GraphQLController(
     }
 
     request_adapter_class = LitestarRequestAdapter
-    websocket_adapter_class = LitestarWebSocketAdapter
+    websocket_adapter_class = LitestarWebSocketAdapter  # type: ignore
 
     allow_queries_via_get: bool = True
     graphiql_allowed_accept: frozenset[str] = frozenset({"text/html", "*/*"})
-    graphql_ide: Optional[GraphQL_IDE] = "graphiql"
-    debug: bool = False
+    graphql_ide: GraphQL_IDE | None = "graphiql"
     connection_init_wait_timeout: timedelta = timedelta(minutes=1)
     protocols: Sequence[str] = (
         GRAPHQL_TRANSPORT_WS_PROTOCOL,
@@ -261,18 +227,18 @@ class GraphQLController(
     keep_alive_interval: float = 1
 
     def is_websocket_request(
-        self, request: Union[Request, WebSocket]
+        self, request: Request | WebSocket
     ) -> TypeGuard[WebSocket]:
         return isinstance(request, WebSocket)
 
-    async def pick_websocket_subprotocol(self, request: WebSocket) -> Optional[str]:
+    async def pick_websocket_subprotocol(self, request: WebSocket) -> str | None:
         subprotocols = request.scope["subprotocols"]
         intersection = set(subprotocols) & set(self.protocols)
         sorted_intersection = sorted(intersection, key=subprotocols.index)
         return next(iter(sorted_intersection), None)
 
     async def create_websocket_response(
-        self, request: WebSocket, subprotocol: Optional[str]
+        self, request: WebSocket, subprotocol: str | None
     ) -> WebSocket:
         await request.accept(subprotocols=subprotocol)
         return request
@@ -282,7 +248,7 @@ class GraphQLController(
         request: Request[Any, Any, Any],
         context: Any,
         root_value: Any,
-    ) -> Response[Union[GraphQLResource, str]]:
+    ) -> Response[GraphQLResource | str]:
         try:
             return await self.run(
                 request,
@@ -302,7 +268,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: GraphQLHTTPResponse | list[GraphQLHTTPResponse],
+        sub_response: Response[bytes],
     ) -> Response[bytes]:
         response = Response(
             self.encode_json(response_data).encode(),
@@ -342,7 +310,7 @@ class GraphQLController(
         context: Any,
         root_value: Any,
         response: Response,
-    ) -> Response[Union[GraphQLResource, str]]:
+    ) -> Response[GraphQLResource | str]:
         self.temporal_response = response
 
         return await self.execute_request(
@@ -358,7 +326,7 @@ class GraphQLController(
         context: Any,
         root_value: Any,
         response: Response,
-    ) -> Response[Union[GraphQLResource, str]]:
+    ) -> Response[GraphQLResource | str]:
         self.temporal_response = response
 
         return await self.execute_request(
@@ -382,14 +350,14 @@ class GraphQLController(
 
     async def get_context(
         self,
-        request: Union[Request[Any, Any, Any], WebSocket],
-        response: Union[Response, WebSocket],
+        request: Request[Any, Any, Any] | WebSocket,
+        response: Response | WebSocket,
     ) -> Context:  # pragma: no cover
         msg = "`get_context` is not used by Litestar's controller"
         raise ValueError(msg)
 
     async def get_root_value(
-        self, request: Union[Request[Any, Any, Any], WebSocket]
+        self, request: Request[Any, Any, Any] | WebSocket
     ) -> RootValue | None:  # pragma: no cover
         msg = "`get_root_value` is not used by Litestar's controller"
         raise ValueError(msg)
@@ -401,16 +369,15 @@ class GraphQLController(
 def make_graphql_controller(
     schema: BaseSchema,
     path: str = "",
-    graphiql: Optional[bool] = None,
-    graphql_ide: Optional[GraphQL_IDE] = "graphiql",
+    graphiql: bool | None = None,
+    graphql_ide: GraphQL_IDE | None = "graphiql",
     allow_queries_via_get: bool = True,
     keep_alive: bool = False,
     keep_alive_interval: float = 1,
-    debug: bool = False,
     # TODO: root typevar
-    root_value_getter: Optional[AnyCallable] = None,
+    root_value_getter: AnyCallable | None = None,
     # TODO: context typevar
-    context_getter: Optional[AnyCallable] = None,
+    context_getter: AnyCallable | None = None,
     subscription_protocols: Sequence[str] = (
         GRAPHQL_TRANSPORT_WS_PROTOCOL,
         GRAPHQL_WS_PROTOCOL,
@@ -430,7 +397,7 @@ def make_graphql_controller(
 
     schema_: BaseSchema = schema
     allow_queries_via_get_: bool = allow_queries_via_get
-    graphql_ide_: Optional[GraphQL_IDE]
+    graphql_ide_: GraphQL_IDE | None
 
     if graphiql is not None:
         warnings.warn(
@@ -456,7 +423,6 @@ def make_graphql_controller(
 
     _GraphQLController.keep_alive = keep_alive
     _GraphQLController.keep_alive_interval = keep_alive_interval
-    _GraphQLController.debug = debug
     _GraphQLController.protocols = subscription_protocols
     _GraphQLController.connection_init_wait_timeout = connection_init_wait_timeout
     _GraphQLController.graphiql_allowed_accept = frozenset({"text/html", "*/*"})

strawberry/permission.py

@@ -7,8 +7,6 @@ from inspect import iscoroutinefunction
 from typing import (
     TYPE_CHECKING,
     Any,
-    Optional,
-    Union,
 )
 
 from strawberry.exceptions import StrawberryGraphQLError
@@ -50,18 +48,18 @@ class BasePermission(abc.ABC):
     ```
     """
 
-    message: Optional[str] = None
+    message: str | None = None
 
-    error_extensions: Optional[GraphQLErrorExtensions] = None
+    error_extensions: GraphQLErrorExtensions | None = None
 
     error_class: type[GraphQLError] = StrawberryGraphQLError
 
-    _schema_directive: Optional[object] = None
+    _schema_directive: object | None = None
 
     @abc.abstractmethod
     def has_permission(
         self, source: Any, info: Info, **kwargs: Any
-    ) -> Union[bool, Awaitable[bool]]:
+    ) -> bool | Awaitable[bool]:
         """Check if the permission should be accepted.
 
         This method should be overridden by the subclasses.

strawberry/printer/ast_from_value.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import re
 from collections.abc import Mapping
 from math import isfinite
-from typing import TYPE_CHECKING, Any, Optional, cast
+from typing import TYPE_CHECKING, Any, cast
 
 from graphql.language import (
     BooleanValueNode,
@@ -44,9 +44,7 @@ __all__ = ["ast_from_value"]
 _re_integer_string = re.compile("^-?(?:0|[1-9][0-9]*)$")
 
 
-def ast_from_leaf_type(
-    serialized: object, type_: Optional[GraphQLInputType]
-) -> ValueNode:
+def ast_from_leaf_type(serialized: object, type_: GraphQLInputType | None) -> ValueNode:
     # Others serialize based on their corresponding Python scalar types.
     if isinstance(serialized, bool):
         return BooleanValueNode(value=serialized)
@@ -86,7 +84,7 @@ def ast_from_leaf_type(
     )  # pragma: no cover
 
 
-def ast_from_value(value: Any, type_: GraphQLInputType) -> Optional[ValueNode]:
+def ast_from_value(value: Any, type_: GraphQLInputType) -> ValueNode | None:
     # custom ast_from_value that allows to also serialize custom scalar that aren't
     # basic types, namely JSON scalar types