strawberry-graphql 0.249.0__tar.gz → 0.250.0__tar.gz

{strawberry_graphql-0.249.0 → strawberry_graphql-0.250.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strawberry-graphql
-Version: 0.249.0
+Version: 0.250.0
 Summary: A library for creating GraphQL APIs
 Home-page: https://strawberry.rocks/
 License: MIT

{strawberry_graphql-0.249.0 → strawberry_graphql-0.250.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "strawberry-graphql"
 packages = [ { include = "strawberry" } ]
-version = "0.249.0"
+version = "0.250.0"
 description = "A library for creating GraphQL APIs"
 authors = ["Patrick Arminio <patrick.arminio@gmail.com>"]
 license = "MIT"

{strawberry_graphql-0.249.0 → strawberry_graphql-0.250.0}/strawberry/channels/testing.py

@@ -17,23 +17,10 @@ from graphql import GraphQLError, GraphQLFormattedError
 
 from channels.testing.websocket import WebsocketCommunicator
 from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL, GRAPHQL_WS_PROTOCOL
-from strawberry.subscriptions.protocols.graphql_transport_ws.types import (
-    ConnectionAckMessage,
-    ConnectionInitMessage,
-    ErrorMessage,
-    NextMessage,
-    SubscribeMessage,
-    SubscribeMessagePayload,
-)
-from strawberry.subscriptions.protocols.graphql_ws.types import (
-    ConnectionAckMessage as GraphQLWSConnectionAckMessage,
-)
-from strawberry.subscriptions.protocols.graphql_ws.types import (
-    ConnectionInitMessage as GraphQLWSConnectionInitMessage,
-)
-from strawberry.subscriptions.protocols.graphql_ws.types import (
-    StartMessage as GraphQLWSStartMessage,
+from strawberry.subscriptions.protocols.graphql_transport_ws import (
+    types as transport_ws_types,
 )
+from strawberry.subscriptions.protocols.graphql_ws import types as ws_types
 from strawberry.types import ExecutionResult
 
 if TYPE_CHECKING:
@@ -109,19 +96,21 @@ class GraphQLWebsocketCommunicator(WebsocketCommunicator):
         if self.protocol == GRAPHQL_TRANSPORT_WS_PROTOCOL:
             assert res == (True, GRAPHQL_TRANSPORT_WS_PROTOCOL)
             await self.send_json_to(
-                ConnectionInitMessage(payload=self.connection_params).as_dict()
+                transport_ws_types.ConnectionInitMessage(
+                    {"type": "connection_init", "payload": self.connection_params}
+                )
             )
-            graphql_transport_ws_response = await self.receive_json_from()
-            assert graphql_transport_ws_response == ConnectionAckMessage().as_dict()
+            transport_ws_connection_ack_message: transport_ws_types.ConnectionAckMessage = await self.receive_json_from()
+            assert transport_ws_connection_ack_message == {"type": "connection_ack"}
         else:
             assert res == (True, GRAPHQL_WS_PROTOCOL)
             await self.send_json_to(
-                GraphQLWSConnectionInitMessage({"type": "connection_init"})
+                ws_types.ConnectionInitMessage({"type": "connection_init"})
             )
-            graphql_ws_response: GraphQLWSConnectionAckMessage = (
+            ws_connection_ack_message: ws_types.ConnectionAckMessage = (
                 await self.receive_json_from()
             )
-            assert graphql_ws_response["type"] == "connection_ack"
+            assert ws_connection_ack_message["type"] == "connection_ack"
 
     # Actual `ExecutionResult`` objects are not available client-side, since they
     # get transformed into `FormattedExecutionResult` on the wire, but we attempt
@@ -133,13 +122,16 @@ class GraphQLWebsocketCommunicator(WebsocketCommunicator):
 
         if self.protocol == GRAPHQL_TRANSPORT_WS_PROTOCOL:
             await self.send_json_to(
-                SubscribeMessage(
-                    id=id_,
-                    payload=SubscribeMessagePayload(query=query, variables=variables),
-                ).as_dict()
+                transport_ws_types.SubscribeMessage(
+                    {
+                        "id": id_,
+                        "type": "subscribe",
+                        "payload": {"query": query, "variables": variables},
+                    }
+                )
             )
         else:
-            start_message: GraphQLWSStartMessage = {
+            start_message: ws_types.StartMessage = {
                 "type": "start",
                 "id": id_,
                 "payload": {
@@ -153,17 +145,18 @@ class GraphQLWebsocketCommunicator(WebsocketCommunicator):
             await self.send_json_to(start_message)
 
         while True:
-            response = await self.receive_json_from(timeout=5)
-            message_type = response["type"]
-            if message_type == NextMessage.type:
-                payload = NextMessage(**response).payload
+            message: transport_ws_types.Message = await self.receive_json_from(
+                timeout=5
+            )
+            if message["type"] == "next":
+                payload = message["payload"]
                 ret = ExecutionResult(payload.get("data"), None)
                 if "errors" in payload:
                     ret.errors = self.process_errors(payload.get("errors") or [])
                 ret.extensions = payload.get("extensions", None)
                 yield ret
-            elif message_type == ErrorMessage.type:
-                error_payload = ErrorMessage(**response).payload
+            elif message["type"] == "error":
+                error_payload = message["payload"]
                 yield ExecutionResult(
                     data=None, errors=self.process_errors(error_payload)
                 )

{strawberry_graphql-0.249.0 → strawberry_graphql-0.250.0}/strawberry/permission.py

@@ -177,8 +177,7 @@ class PermissionExtension(FieldExtension):
             elif isinstance(field.type, StrawberryList):
                 self.return_empty_list = True
             else:
-                errror = PermissionFailSilentlyRequiresOptionalError(field)
-                raise errror
+                raise PermissionFailSilentlyRequiresOptionalError(field)
 
     def _on_unauthorized(self, permission: BasePermission) -> Any:
         if self.fail_silently:

{strawberry_graphql-0.249.0 → strawberry_graphql-0.250.0}/strawberry/subscriptions/protocols/graphql_transport_ws/handlers.py

@@ -5,11 +5,11 @@ import logging
 from contextlib import suppress
 from typing import (
     TYPE_CHECKING,
-    Any,
     Awaitable,
     Dict,
     List,
     Optional,
+    cast,
 )
 
 from graphql import GraphQLError, GraphQLSyntaxError, parse
@@ -21,20 +21,16 @@ from strawberry.http.exceptions import (
 )
 from strawberry.subscriptions.protocols.graphql_transport_ws.types import (
     CompleteMessage,
-    ConnectionAckMessage,
     ConnectionInitMessage,
-    ErrorMessage,
-    NextMessage,
-    NextPayload,
+    Message,
+    NextMessagePayload,
     PingMessage,
     PongMessage,
     SubscribeMessage,
-    SubscribeMessagePayload,
 )
 from strawberry.types import ExecutionResult
 from strawberry.types.execution import PreExecutionError
 from strawberry.types.graphql import OperationType
-from strawberry.types.unset import UNSET
 from strawberry.utils.debug import pretty_print_graphql_operation
 from strawberry.utils.operation import get_operation_type
 
@@ -44,9 +40,6 @@ if TYPE_CHECKING:
     from strawberry.http.async_base_view import AsyncWebSocketAdapter
     from strawberry.schema import BaseSchema
     from strawberry.schema.subscribe import SubscriptionResult
-    from strawberry.subscriptions.protocols.graphql_transport_ws.types import (
-        GraphQLTransportMessage,
-    )
 
 
 class BaseGraphQLTransportWSHandler:
@@ -73,15 +66,15 @@ class BaseGraphQLTransportWSHandler:
         self.connection_timed_out = False
         self.operations: Dict[str, Operation] = {}
         self.completed_tasks: List[asyncio.Task] = []
-        self.connection_params: Optional[Dict[str, Any]] = None
+        self.connection_params: Optional[Dict[str, object]] = None
 
-    async def handle(self) -> Any:
+    async def handle(self) -> None:
         self.on_request_accepted()
 
         try:
             try:
                 async for message in self.websocket.iter_json():
-                    await self.handle_message(message)
+                    await self.handle_message(cast(Message, message))
             except NonTextMessageReceived:
                 await self.handle_invalid_message("WebSocket message type must be text")
             except NonJsonMessageReceived:
@@ -134,39 +127,28 @@ class BaseGraphQLTransportWSHandler:
     async def handle_task_exception(self, error: Exception) -> None:  # pragma: no cover
         self.task_logger.exception("Exception in worker task", exc_info=error)
 
-    async def handle_message(self, message: dict) -> None:
+    async def handle_message(self, message: Message) -> None:
         try:
-            message_type = message.pop("type")
+            if message["type"] == "connection_init":
+                await self.handle_connection_init(message)
 
-            if message_type == ConnectionInitMessage.type:
-                await self.handle_connection_init(ConnectionInitMessage(**message))
+            elif message["type"] == "ping":
+                await self.handle_ping(message)
 
-            elif message_type == PingMessage.type:
-                await self.handle_ping(PingMessage(**message))
+            elif message["type"] == "pong":
+                await self.handle_pong(message)
 
-            elif message_type == PongMessage.type:
-                await self.handle_pong(PongMessage(**message))
+            elif message["type"] == "subscribe":
+                await self.handle_subscribe(message)
 
-            elif message_type == SubscribeMessage.type:
-                payload_args = message.pop("payload")
-                payload = SubscribeMessagePayload(
-                    query=payload_args["query"],
-                    operationName=payload_args.get("operationName"),
-                    variables=payload_args.get("variables"),
-                    extensions=payload_args.get("extensions"),
-                )
-                await self.handle_subscribe(
-                    SubscribeMessage(payload=payload, **message)
-                )
-
-            elif message_type == CompleteMessage.type:
-                await self.handle_complete(CompleteMessage(**message))
+            elif message["type"] == "complete":
+                await self.handle_complete(message)
 
             else:
-                error_message = f"Unknown message type: {message_type}"
+                error_message = f"Unknown message type: {message['type']}"
                 await self.handle_invalid_message(error_message)
 
-        except (KeyError, TypeError):
+        except KeyError:
             await self.handle_invalid_message("Failed to parse message")
         finally:
             await self.reap_completed_tasks()
@@ -175,14 +157,11 @@ class BaseGraphQLTransportWSHandler:
         if self.connection_timed_out:
             # No way to reliably excercise this case during testing
             return  # pragma: no cover
+
         if self.connection_init_timeout_task:
             self.connection_init_timeout_task.cancel()
 
-        payload = (
-            message.payload
-            if message.payload is not None and message.payload is not UNSET
-            else {}
-        )
+        payload = message.get("payload", {})
 
         if not isinstance(payload, dict):
             await self.websocket.close(
@@ -198,11 +177,11 @@ class BaseGraphQLTransportWSHandler:
             return
 
         self.connection_init_received = True
-        await self.send_message(ConnectionAckMessage())
+        await self.send_message({"type": "connection_ack"})
         self.connection_acknowledged = True
 
     async def handle_ping(self, message: PingMessage) -> None:
-        await self.send_message(PongMessage())
+        await self.send_message({"type": "pong"})
 
     async def handle_pong(self, message: PongMessage) -> None:
         pass
@@ -213,14 +192,14 @@ class BaseGraphQLTransportWSHandler:
             return
 
         try:
-            graphql_document = parse(message.payload.query)
+            graphql_document = parse(message["payload"]["query"])
         except GraphQLSyntaxError as exc:
             await self.websocket.close(code=4400, reason=exc.message)
             return
 
         try:
             operation_type = get_operation_type(
-                graphql_document, message.payload.operationName
+                graphql_document, message["payload"].get("operationName")
             )
         except RuntimeError:
             await self.websocket.close(
@@ -228,16 +207,16 @@ class BaseGraphQLTransportWSHandler:
             )
             return
 
-        if message.id in self.operations:
-            reason = f"Subscriber for {message.id} already exists"
+        if message["id"] in self.operations:
+            reason = f"Subscriber for {message['id']} already exists"
             await self.websocket.close(code=4409, reason=reason)
             return
 
         if self.debug:  # pragma: no cover
             pretty_print_graphql_operation(
-                message.payload.operationName,
-                message.payload.query,
-                message.payload.variables,
+                message["payload"].get("operationName"),
+                message["payload"]["query"],
+                message["payload"].get("variables"),
             )
 
         if isinstance(self.context, dict):
@@ -247,15 +226,15 @@ class BaseGraphQLTransportWSHandler:
 
         operation = Operation(
             self,
-            message.id,
+            message["id"],
             operation_type,
-            message.payload.query,
-            message.payload.variables,
-            message.payload.operationName,
+            message["payload"]["query"],
+            message["payload"].get("variables"),
+            message["payload"].get("operationName"),
         )
 
         operation.task = asyncio.create_task(self.run_operation(operation))
-        self.operations[message.id] = operation
+        self.operations[message["id"]] = operation
 
     async def run_operation(self, operation: Operation) -> None:
         """The operation task's top level method. Cleans-up and de-registers the operation once it is done."""
@@ -291,11 +270,15 @@ class BaseGraphQLTransportWSHandler:
             # that's a mutation / query result
             elif isinstance(first_res_or_agen, ExecutionResult):
                 await operation.send_next(first_res_or_agen)
-                await operation.send_message(CompleteMessage(id=operation.id))
+                await operation.send_operation_message(
+                    {"id": operation.id, "type": "complete"}
+                )
             else:
                 async for result in first_res_or_agen:
                     await operation.send_next(result)
-                await operation.send_message(CompleteMessage(id=operation.id))
+                await operation.send_operation_message(
+                    {"id": operation.id, "type": "complete"}
+                )
 
         except BaseException as e:  # pragma: no cover
             self.operations.pop(operation.id, None)
@@ -312,14 +295,13 @@ class BaseGraphQLTransportWSHandler:
         del self.operations[id]
 
     async def handle_complete(self, message: CompleteMessage) -> None:
-        await self.cleanup_operation(operation_id=message.id)
+        await self.cleanup_operation(operation_id=message["id"])
 
     async def handle_invalid_message(self, error_message: str) -> None:
         await self.websocket.close(code=4400, reason=error_message)
 
-    async def send_message(self, message: GraphQLTransportMessage) -> None:
-        data = message.as_dict()
-        await self.websocket.send_json(data)
+    async def send_message(self, message: Message) -> None:
+        await self.websocket.send_json(message)
 
     async def cleanup_operation(self, operation_id: str) -> None:
         if operation_id not in self.operations:
@@ -358,7 +340,7 @@ class Operation:
         id: str,
         operation_type: OperationType,
         query: str,
-        variables: Optional[Dict[str, Any]],
+        variables: Optional[Dict[str, object]],
         operation_name: Optional[str],
     ) -> None:
         self.handler = handler
@@ -370,10 +352,10 @@ class Operation:
         self.completed = False
         self.task: Optional[asyncio.Task] = None
 
-    async def send_message(self, message: GraphQLTransportMessage) -> None:
+    async def send_operation_message(self, message: Message) -> None:
         if self.completed:
             return
-        if isinstance(message, (CompleteMessage, ErrorMessage)):
+        if message["type"] == "complete" or message["type"] == "error":
             self.completed = True
             # de-register the operation _before_ sending the final message
             self.handler.forget_id(self.id)
@@ -383,17 +365,26 @@ class Operation:
         # Initial errors see https://github.com/enisdenjo/graphql-ws/blob/master/PROTOCOL.md#error
         # "This can occur before execution starts,
         # usually due to validation errors, or during the execution of the request"
-        await self.send_message(
-            ErrorMessage(id=self.id, payload=[err.formatted for err in errors])
+        await self.send_operation_message(
+            {
+                "id": self.id,
+                "type": "error",
+                "payload": [err.formatted for err in errors],
+            }
         )
 
     async def send_next(self, execution_result: ExecutionResult) -> None:
-        next_payload: NextPayload = {"data": execution_result.data}
+        next_payload: NextMessagePayload = {"data": execution_result.data}
+
         if execution_result.errors:
             next_payload["errors"] = [err.formatted for err in execution_result.errors]
+
         if execution_result.extensions:
             next_payload["extensions"] = execution_result.extensions
-        await self.send_message(NextMessage(id=self.id, payload=next_payload))
+
+        await self.send_operation_message(
+            {"id": self.id, "type": "next", "payload": next_payload}
+        )
 
 
 __all__ = ["BaseGraphQLTransportWSHandler", "Operation"]

strawberry_graphql-0.250.0/strawberry/subscriptions/protocols/graphql_transport_ws/types.py

@@ -0,0 +1,101 @@
+from typing import Dict, List, TypedDict, Union
+from typing_extensions import Literal, NotRequired
+
+from graphql import GraphQLFormattedError
+
+
+class ConnectionInitMessage(TypedDict):
+    """Direction: Client -> Server."""
+
+    type: Literal["connection_init"]
+    payload: NotRequired[Union[Dict[str, object], None]]
+
+
+class ConnectionAckMessage(TypedDict):
+    """Direction: Server -> Client."""
+
+    type: Literal["connection_ack"]
+    payload: NotRequired[Union[Dict[str, object], None]]
+
+
+class PingMessage(TypedDict):
+    """Direction: bidirectional."""
+
+    type: Literal["ping"]
+    payload: NotRequired[Union[Dict[str, object], None]]
+
+
+class PongMessage(TypedDict):
+    """Direction: bidirectional."""
+
+    type: Literal["pong"]
+    payload: NotRequired[Union[Dict[str, object], None]]
+
+
+class SubscribeMessagePayload(TypedDict):
+    operationName: NotRequired[Union[str, None]]
+    query: str
+    variables: NotRequired[Union[Dict[str, object], None]]
+    extensions: NotRequired[Union[Dict[str, object], None]]
+
+
+class SubscribeMessage(TypedDict):
+    """Direction: Client -> Server."""
+
+    id: str
+    type: Literal["subscribe"]
+    payload: SubscribeMessagePayload
+
+
+class NextMessagePayload(TypedDict):
+    errors: NotRequired[List[GraphQLFormattedError]]
+    data: NotRequired[Union[Dict[str, object], None]]
+    extensions: NotRequired[Dict[str, object]]
+
+
+class NextMessage(TypedDict):
+    """Direction: Server -> Client."""
+
+    id: str
+    type: Literal["next"]
+    payload: NextMessagePayload
+
+
+class ErrorMessage(TypedDict):
+    """Direction: Server -> Client."""
+
+    id: str
+    type: Literal["error"]
+    payload: List[GraphQLFormattedError]
+
+
+class CompleteMessage(TypedDict):
+    """Direction: bidirectional."""
+
+    id: str
+    type: Literal["complete"]
+
+
+Message = Union[
+    ConnectionInitMessage,
+    ConnectionAckMessage,
+    PingMessage,
+    PongMessage,
+    SubscribeMessage,
+    NextMessage,
+    ErrorMessage,
+    CompleteMessage,
+]
+
+
+__all__ = [
+    "ConnectionInitMessage",
+    "ConnectionAckMessage",
+    "PingMessage",
+    "PongMessage",
+    "SubscribeMessage",
+    "NextMessage",
+    "ErrorMessage",
+    "CompleteMessage",
+    "Message",
+]

strawberry_graphql-0.249.0/strawberry/subscriptions/protocols/graphql_transport_ws/types.py

@@ -1,117 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, TypedDict
-
-from strawberry.types.unset import UNSET
-
-if TYPE_CHECKING:
-    from graphql import GraphQLFormattedError
-
-
-@dataclass
-class GraphQLTransportMessage:
-    def as_dict(self) -> dict:
-        data = asdict(self)
-        if getattr(self, "payload", None) is UNSET:
-            # Unset fields must have a JSON value of "undefined" not "null"
-            data.pop("payload")
-        return data
-
-
-@dataclass
-class ConnectionInitMessage(GraphQLTransportMessage):
-    """Direction: Client -> Server."""
-
-    payload: Optional[Dict[str, Any]] = UNSET
-    type: str = "connection_init"
-
-
-@dataclass
-class ConnectionAckMessage(GraphQLTransportMessage):
-    """Direction: Server -> Client."""
-
-    payload: Optional[Dict[str, Any]] = UNSET
-    type: str = "connection_ack"
-
-
-@dataclass
-class PingMessage(GraphQLTransportMessage):
-    """Direction: bidirectional."""
-
-    payload: Optional[Dict[str, Any]] = UNSET
-    type: str = "ping"
-
-
-@dataclass
-class PongMessage(GraphQLTransportMessage):
-    """Direction: bidirectional."""
-
-    payload: Optional[Dict[str, Any]] = UNSET
-    type: str = "pong"
-
-
-@dataclass
-class SubscribeMessagePayload:
-    query: str
-    operationName: Optional[str] = None
-    variables: Optional[Dict[str, Any]] = None
-    extensions: Optional[Dict[str, Any]] = None
-
-
-@dataclass
-class SubscribeMessage(GraphQLTransportMessage):
-    """Direction: Client -> Server."""
-
-    id: str
-    payload: SubscribeMessagePayload
-    type: str = "subscribe"
-
-
-class NextPayload(TypedDict, total=False):
-    data: Any
-
-    # Optional list of formatted graphql.GraphQLError objects
-    errors: Optional[List[GraphQLFormattedError]]
-    extensions: Optional[Dict[str, Any]]
-
-
-@dataclass
-class NextMessage(GraphQLTransportMessage):
-    """Direction: Server -> Client."""
-
-    id: str
-    payload: NextPayload
-    type: str = "next"
-
-    def as_dict(self) -> dict:
-        return {"id": self.id, "payload": self.payload, "type": self.type}
-
-
-@dataclass
-class ErrorMessage(GraphQLTransportMessage):
-    """Direction: Server -> Client."""
-
-    id: str
-    payload: List[GraphQLFormattedError]
-    type: str = "error"
-
-
-@dataclass
-class CompleteMessage(GraphQLTransportMessage):
-    """Direction: bidirectional."""
-
-    id: str
-    type: str = "complete"
-
-
-__all__ = [
-    "ConnectionInitMessage",
-    "ConnectionAckMessage",
-    "PingMessage",
-    "PongMessage",
-    "SubscribeMessage",
-    "NextMessage",
-    "ErrorMessage",
-    "CompleteMessage",
-]