strawberry-graphql 0.246.3__tar.gz → 0.247.1__tar.gz

{strawberry_graphql-0.246.3 → strawberry_graphql-0.247.1}/PKG-INFO

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

{strawberry_graphql-0.246.3 → strawberry_graphql-0.247.1}/pyproject.toml

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

{strawberry_graphql-0.246.3 → strawberry_graphql-0.247.1}/strawberry/aiohttp/views.py

@@ -26,7 +26,12 @@ from strawberry.http.async_base_view import (
     AsyncHTTPRequestAdapter,
     AsyncWebSocketAdapter,
 )
-from strawberry.http.exceptions import HTTPException, NonJsonMessageReceived
+from strawberry.http.exceptions import (
+    HTTPException,
+    NonJsonMessageReceived,
+    NonTextMessageReceived,
+    WebSocketDisconnected,
+)
 from strawberry.http.types import FormData, HTTPMethod, QueryParams
 from strawberry.http.typevars import (
     Context,
@@ -86,19 +91,25 @@ class AioHTTPWebSocketAdapter(AsyncWebSocketAdapter):
         self.request = request
         self.ws = ws
 
-    async def iter_json(self) -> AsyncGenerator[Dict[str, object], None]:
+    async def iter_json(
+        self, *, ignore_parsing_errors: bool = False
+    ) -> AsyncGenerator[Dict[str, object], None]:
         async for ws_message in self.ws:
             if ws_message.type == http.WSMsgType.TEXT:
                 try:
                     yield ws_message.json()
                 except JSONDecodeError:
-                    raise NonJsonMessageReceived()
+                    if not ignore_parsing_errors:
+                        raise NonJsonMessageReceived()
 
             elif ws_message.type == http.WSMsgType.BINARY:
-                raise NonJsonMessageReceived()
+                raise NonTextMessageReceived()
 
     async def send_json(self, message: Mapping[str, object]) -> None:
-        await self.ws.send_json(message)
+        try:
+            await self.ws.send_json(message)
+        except RuntimeError as exc:
+            raise WebSocketDisconnected from exc
 
     async def close(self, code: int, reason: str) -> None:
         await self.ws.close(code=code, message=reason.encode())

{strawberry_graphql-0.246.3 → strawberry_graphql-0.247.1}/strawberry/asgi/__init__.py

@@ -33,7 +33,12 @@ from strawberry.http.async_base_view import (
     AsyncHTTPRequestAdapter,
     AsyncWebSocketAdapter,
 )
-from strawberry.http.exceptions import HTTPException, NonJsonMessageReceived
+from strawberry.http.exceptions import (
+    HTTPException,
+    NonJsonMessageReceived,
+    NonTextMessageReceived,
+    WebSocketDisconnected,
+)
 from strawberry.http.types import FormData, HTTPMethod, QueryParams
 from strawberry.http.typevars import (
     Context,
@@ -85,18 +90,26 @@ class ASGIWebSocketAdapter(AsyncWebSocketAdapter):
     def __init__(self, request: WebSocket, response: WebSocket) -> None:
         self.ws = response
 
-    async def iter_json(self) -> AsyncGenerator[Dict[str, object], None]:
+    async def iter_json(
+        self, *, ignore_parsing_errors: bool = False
+    ) -> AsyncGenerator[Dict[str, object], None]:
         try:
-            try:
-                while self.ws.application_state != WebSocketState.DISCONNECTED:
+            while self.ws.application_state != WebSocketState.DISCONNECTED:
+                try:
                     yield await self.ws.receive_json()
-            except (KeyError, JSONDecodeError):
-                raise NonJsonMessageReceived()
+                except JSONDecodeError:  # noqa: PERF203
+                    if not ignore_parsing_errors:
+                        raise NonJsonMessageReceived()
+        except KeyError:
+            raise NonTextMessageReceived()
         except WebSocketDisconnect:  # pragma: no cover
             pass
 
     async def send_json(self, message: Mapping[str, object]) -> None:
-        await self.ws.send_json(message)
+        try:
+            await self.ws.send_json(message)
+        except WebSocketDisconnect as exc:
+            raise WebSocketDisconnected from exc
 
     async def close(self, code: int, reason: str) -> None:
         await self.ws.close(code=code, reason=reason)

{strawberry_graphql-0.246.3 → strawberry_graphql-0.247.1}/strawberry/channels/handlers/ws_handler.py

@@ -16,7 +16,7 @@ from typing import (
 from typing_extensions import TypeGuard
 
 from strawberry.http.async_base_view import AsyncBaseHTTPView, AsyncWebSocketAdapter
-from strawberry.http.exceptions import NonJsonMessageReceived
+from strawberry.http.exceptions import NonJsonMessageReceived, NonTextMessageReceived
 from strawberry.http.typevars import Context, RootValue
 from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL, GRAPHQL_WS_PROTOCOL
 
@@ -31,7 +31,9 @@ class ChannelsWebSocketAdapter(AsyncWebSocketAdapter):
     def __init__(self, request: GraphQLWSConsumer, response: GraphQLWSConsumer) -> None:
         self.ws_consumer = response
 
-    async def iter_json(self) -> AsyncGenerator[Dict[str, object], None]:
+    async def iter_json(
+        self, *, ignore_parsing_errors: bool = False
+    ) -> AsyncGenerator[Dict[str, object], None]:
         while True:
             message = await self.ws_consumer.message_queue.get()
 
@@ -39,12 +41,13 @@ class ChannelsWebSocketAdapter(AsyncWebSocketAdapter):
                 break
 
             if message["message"] is None:
-                raise NonJsonMessageReceived()
+                raise NonTextMessageReceived()
 
             try:
                 yield json.loads(message["message"])
             except json.JSONDecodeError:
-                raise NonJsonMessageReceived()
+                if not ignore_parsing_errors:
+                    raise NonJsonMessageReceived()
 
     async def send_json(self, message: Mapping[str, object]) -> None:
         serialized_message = json.dumps(message)

{strawberry_graphql-0.246.3 → strawberry_graphql-0.247.1}/strawberry/http/async_base_view.py

@@ -81,7 +81,9 @@ class AsyncHTTPRequestAdapter(abc.ABC):
 
 class AsyncWebSocketAdapter(abc.ABC):
     @abc.abstractmethod
-    def iter_json(self) -> AsyncGenerator[Dict[str, object], None]: ...
+    def iter_json(
+        self, *, ignore_parsing_errors: bool = False
+    ) -> AsyncGenerator[Dict[str, object], None]: ...
 
     @abc.abstractmethod
     async def send_json(self, message: Mapping[str, object]) -> None: ...

{strawberry_graphql-0.246.3 → strawberry_graphql-0.247.1}/strawberry/http/exceptions.py

@@ -4,8 +4,16 @@ class HTTPException(Exception):
         self.reason = reason
 
 
+class NonTextMessageReceived(Exception):
+    pass
+
+
 class NonJsonMessageReceived(Exception):
     pass
 
 
+class WebSocketDisconnected(Exception):
+    pass
+
+
 __all__ = ["HTTPException"]

{strawberry_graphql-0.246.3 → strawberry_graphql-0.247.1}/strawberry/litestar/controller.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 import warnings
 from datetime import timedelta
 from typing import (
@@ -37,7 +38,6 @@ from litestar.background_tasks import BackgroundTasks
 from litestar.di import Provide
 from litestar.exceptions import (
     NotFoundException,
-    SerializationException,
     ValidationException,
     WebSocketDisconnect,
 )
@@ -49,7 +49,12 @@ from strawberry.http.async_base_view import (
     AsyncHTTPRequestAdapter,
     AsyncWebSocketAdapter,
 )
-from strawberry.http.exceptions import HTTPException, NonJsonMessageReceived
+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
@@ -192,18 +197,30 @@ class LitestarWebSocketAdapter(AsyncWebSocketAdapter):
     def __init__(self, request: WebSocket, response: WebSocket) -> None:
         self.ws = response
 
-    async def iter_json(self) -> AsyncGenerator[Dict[str, object], None]:
+    async def iter_json(
+        self, *, ignore_parsing_errors: bool = False
+    ) -> AsyncGenerator[Dict[str, object], None]:
         try:
-            try:
-                while self.ws.connection_state != "disconnect":
-                    yield await self.ws.receive_json()
-            except (SerializationException, ValueError):
-                raise NonJsonMessageReceived()
+            while self.ws.connection_state != "disconnect":
+                text = await self.ws.receive_text()
+
+                # Litestar internally defaults to an empty string for non-text messages
+                if text == "":
+                    raise NonTextMessageReceived()
+
+                try:
+                    yield json.loads(text)
+                except json.JSONDecodeError:
+                    if not ignore_parsing_errors:
+                        raise NonJsonMessageReceived()
         except WebSocketDisconnect:
             pass
 
     async def send_json(self, message: Mapping[str, object]) -> None:
-        await self.ws.send_json(message)
+        try:
+            await self.ws.send_json(message)
+        except WebSocketDisconnect as exc:
+            raise WebSocketDisconnected from exc
 
     async def close(self, code: int, reason: str) -> None:
         await self.ws.close(code=code, reason=reason)

{strawberry_graphql-0.246.3 → strawberry_graphql-0.247.1}/strawberry/subscriptions/protocols/graphql_transport_ws/handlers.py

@@ -7,7 +7,6 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Awaitable,
-    Callable,
     Dict,
     List,
     Optional,
@@ -15,7 +14,11 @@ from typing import (
 
 from graphql import GraphQLError, GraphQLSyntaxError, parse
 
-from strawberry.http.exceptions import NonJsonMessageReceived
+from strawberry.http.exceptions import (
+    NonJsonMessageReceived,
+    NonTextMessageReceived,
+    WebSocketDisconnected,
+)
 from strawberry.subscriptions.protocols.graphql_transport_ws.types import (
     CompleteMessage,
     ConnectionAckMessage,
@@ -76,10 +79,17 @@ class BaseGraphQLTransportWSHandler:
         self.on_request_accepted()
 
         try:
-            async for message in self.websocket.iter_json():
-                await self.handle_message(message)
-        except NonJsonMessageReceived:
-            await self.handle_invalid_message("WebSocket message type must be text")
+            try:
+                async for message in self.websocket.iter_json():
+                    await self.handle_message(message)
+            except NonTextMessageReceived:
+                await self.handle_invalid_message("WebSocket message type must be text")
+            except NonJsonMessageReceived:
+                await self.handle_invalid_message(
+                    "WebSocket message must be valid JSON"
+                )
+        except WebSocketDisconnected:
+            pass
         finally:
             await self.shutdown()
 
@@ -125,50 +135,41 @@ class BaseGraphQLTransportWSHandler:
         self.task_logger.exception("Exception in worker task", exc_info=error)
 
     async def handle_message(self, message: dict) -> None:
-        handler: Callable
-        handler_arg: Any
         try:
             message_type = message.pop("type")
 
             if message_type == ConnectionInitMessage.type:
-                handler = self.handle_connection_init
-                handler_arg = ConnectionInitMessage(**message)
+                await self.handle_connection_init(ConnectionInitMessage(**message))
 
             elif message_type == PingMessage.type:
-                handler = self.handle_ping
-                handler_arg = PingMessage(**message)
+                await self.handle_ping(PingMessage(**message))
 
             elif message_type == PongMessage.type:
-                handler = self.handle_pong
-                handler_arg = PongMessage(**message)
+                await self.handle_pong(PongMessage(**message))
 
             elif message_type == SubscribeMessage.type:
-                handler = self.handle_subscribe
-
                 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"),
                 )
-                handler_arg = SubscribeMessage(payload=payload, **message)
+                await self.handle_subscribe(
+                    SubscribeMessage(payload=payload, **message)
+                )
 
             elif message_type == CompleteMessage.type:
-                handler = self.handle_complete
-                handler_arg = CompleteMessage(**message)
+                await self.handle_complete(CompleteMessage(**message))
 
             else:
-                handler = self.handle_invalid_message
-                handler_arg = f"Unknown message type: {message_type}"
+                error_message = f"Unknown message type: {message_type}"
+                await self.handle_invalid_message(error_message)
 
         except (KeyError, TypeError):
-            handler = self.handle_invalid_message
-            handler_arg = "Failed to parse message"
-
-        await handler(handler_arg)
-        await self.reap_completed_tasks()
+            await self.handle_invalid_message("Failed to parse message")
+        finally:
+            await self.reap_completed_tasks()
 
     async def handle_connection_init(self, message: ConnectionInitMessage) -> None:
         if self.connection_timed_out:

{strawberry_graphql-0.246.3 → strawberry_graphql-0.247.1}/strawberry/subscriptions/protocols/graphql_ws/handlers.py

@@ -11,7 +11,7 @@ from typing import (
     cast,
 )
 
-from strawberry.http.exceptions import NonJsonMessageReceived
+from strawberry.http.exceptions import NonTextMessageReceived, WebSocketDisconnected
 from strawberry.subscriptions.protocols.graphql_ws import (
     GQL_COMPLETE,
     GQL_CONNECTION_ACK,
@@ -65,12 +65,17 @@ class BaseGraphQLWSHandler:
 
     async def handle(self) -> None:
         try:
-            async for message in self.websocket.iter_json():
-                await self.handle_message(cast(OperationMessage, message))
-        except NonJsonMessageReceived:
-            await self.websocket.close(
-                code=1002, reason="WebSocket message type must be text"
-            )
+            try:
+                async for message in self.websocket.iter_json(
+                    ignore_parsing_errors=True
+                ):
+                    await self.handle_message(cast(OperationMessage, message))
+            except NonTextMessageReceived:
+                await self.websocket.close(
+                    code=1002, reason="WebSocket message type must be text"
+                )
+        except WebSocketDisconnected:
+            pass
         finally:
             if self.keep_alive_task:
                 self.keep_alive_task.cancel()