strawberry-graphql 0.279.0.dev1754156227__py3-none-any.whl → 0.280.0__py3-none-any.whl

strawberry/flask/views.py

@@ -3,67 +3,27 @@ from __future__ import annotations
 import warnings
 from typing import (
     TYPE_CHECKING,
-    Any,
     ClassVar,
     Optional,
     Union,
-    cast,
 )
 from typing_extensions import TypeGuard
 
+from lia import AsyncFlaskHTTPRequestAdapter, FlaskHTTPRequestAdapter, HTTPException
+
 from flask import Request, Response, render_template_string, request
 from flask.views import View
-from strawberry.http.async_base_view import AsyncBaseHTTPView, AsyncHTTPRequestAdapter
-from strawberry.http.exceptions import HTTPException
-from strawberry.http.sync_base_view import (
-    SyncBaseHTTPView,
-    SyncHTTPRequestAdapter,
-)
-from strawberry.http.types import FormData, HTTPMethod, QueryParams
+from strawberry.http.async_base_view import AsyncBaseHTTPView
+from strawberry.http.sync_base_view import SyncBaseHTTPView
 from strawberry.http.typevars import Context, RootValue
 
 if TYPE_CHECKING:
-    from collections.abc import Mapping
-
     from flask.typing import ResponseReturnValue
     from strawberry.http import GraphQLHTTPResponse
     from strawberry.http.ides import GraphQL_IDE
     from strawberry.schema.base import BaseSchema
 
 
-class FlaskHTTPRequestAdapter(SyncHTTPRequestAdapter):
-    def __init__(self, request: Request) -> None:
-        self.request = request
-
-    @property
-    def query_params(self) -> QueryParams:
-        return self.request.args.to_dict()
-
-    @property
-    def body(self) -> Union[str, bytes]:
-        return self.request.data.decode()
-
-    @property
-    def method(self) -> HTTPMethod:
-        return cast("HTTPMethod", self.request.method.upper())
-
-    @property
-    def headers(self) -> Mapping[str, str]:
-        return self.request.headers  # type: ignore
-
-    @property
-    def post_data(self) -> Mapping[str, Union[str, bytes]]:
-        return self.request.form
-
-    @property
-    def files(self) -> Mapping[str, Any]:
-        return self.request.files
-
-    @property
-    def content_type(self) -> Optional[str]:
-        return self.request.content_type
-
-
 class BaseGraphQLView:
     graphql_ide: Optional[GraphQL_IDE]
 
@@ -131,36 +91,6 @@ class GraphQLView(
         return render_template_string(self.graphql_ide_html)  # type: ignore
 
 
-class AsyncFlaskHTTPRequestAdapter(AsyncHTTPRequestAdapter):
-    def __init__(self, request: Request) -> None:
-        self.request = request
-
-    @property
-    def query_params(self) -> QueryParams:
-        return self.request.args.to_dict()
-
-    @property
-    def method(self) -> HTTPMethod:
-        return cast("HTTPMethod", self.request.method.upper())
-
-    @property
-    def content_type(self) -> Optional[str]:
-        return self.request.content_type
-
-    @property
-    def headers(self) -> Mapping[str, str]:
-        return self.request.headers  # type: ignore
-
-    async def get_body(self) -> str:
-        return self.request.data.decode()
-
-    async def get_form_data(self) -> FormData:
-        return FormData(
-            files=self.request.files,
-            form=self.request.form,
-        )
-
-
 class AsyncGraphQLView(
     BaseGraphQLView,
     AsyncBaseHTTPView[

strawberry/http/async_base_view.py

@@ -17,6 +17,7 @@ from typing import (
 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
@@ -44,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,
@@ -58,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
@@ -284,8 +259,9 @@ class AsyncBaseHTTPView(
         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)
@@ -294,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
 

strawberry/http/base.py

@@ -3,12 +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
 
 

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,8 +1,6 @@
 import abc
 import json
-from collections.abc import Mapping
 from typing import (
-    Any,
     Callable,
     Generic,
     Literal,
@@ -11,6 +9,7 @@ from typing import (
 )
 
 from graphql import GraphQLError
+from lia import HTTPException, SyncHTTPRequestAdapter
 
 from strawberry.exceptions import MissingQueryError
 from strawberry.file_uploads.utils import replace_placeholders_with_files
@@ -30,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],

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

strawberry/quart/views.py

@@ -3,25 +3,24 @@ import warnings
 from collections.abc import AsyncGenerator, Mapping, Sequence
 from datetime import timedelta
 from json.decoder import JSONDecodeError
-from typing import TYPE_CHECKING, Callable, ClassVar, Optional, Union, cast
+from typing import TYPE_CHECKING, Callable, ClassVar, Optional, Union
 from typing_extensions import TypeGuard
 
+from lia import HTTPException, QuartHTTPRequestAdapter
+
 from quart import Request, Response, Websocket, request, websocket
 from quart.ctx import has_websocket_context
 from quart.views import View
 from strawberry.http.async_base_view import (
     AsyncBaseHTTPView,
-    AsyncHTTPRequestAdapter,
     AsyncWebSocketAdapter,
 )
 from strawberry.http.exceptions import (
-    HTTPException,
     NonJsonMessageReceived,
     NonTextMessageReceived,
     WebSocketDisconnected,
 )
 from strawberry.http.ides import GraphQL_IDE
-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
 
@@ -31,35 +30,6 @@ if TYPE_CHECKING:
     from strawberry.schema.base import BaseSchema
 
 
-class QuartHTTPRequestAdapter(AsyncHTTPRequestAdapter):
-    def __init__(self, request: Request) -> None:
-        self.request = request
-
-    @property
-    def query_params(self) -> QueryParams:
-        return self.request.args.to_dict()
-
-    @property
-    def method(self) -> HTTPMethod:
-        return cast("HTTPMethod", self.request.method.upper())
-
-    @property
-    def content_type(self) -> Optional[str]:
-        return self.request.content_type
-
-    @property
-    def headers(self) -> Mapping[str, str]:
-        return self.request.headers  # type: ignore
-
-    async def get_body(self) -> str:
-        return (await self.request.data).decode()
-
-    async def get_form_data(self) -> FormData:
-        files = await self.request.files
-        form = await self.request.form
-        return FormData(files=files, form=form)
-
-
 class QuartWebSocketAdapter(AsyncWebSocketAdapter):
     def __init__(
         self, view: AsyncBaseHTTPView, request: Websocket, response: Response

strawberry/sanic/views.py

@@ -8,68 +8,29 @@ from typing import (
     Callable,
     Optional,
     Union,
-    cast,
 )
 from typing_extensions import TypeGuard
 
+from lia import HTTPException, SanicHTTPRequestAdapter
+
 from sanic.request import Request
 from sanic.response import HTTPResponse, html
 from sanic.views import HTTPMethodView
-from strawberry.http.async_base_view import AsyncBaseHTTPView, AsyncHTTPRequestAdapter
-from strawberry.http.exceptions import HTTPException
+from strawberry.http.async_base_view import AsyncBaseHTTPView
 from strawberry.http.temporal_response import TemporalResponse
-from strawberry.http.types import FormData, HTTPMethod, QueryParams
 from strawberry.http.typevars import (
     Context,
     RootValue,
 )
-from strawberry.sanic.utils import convert_request_to_files_dict
 
 if TYPE_CHECKING:
-    from collections.abc import AsyncGenerator, Mapping
+    from collections.abc import AsyncGenerator
 
     from strawberry.http import GraphQLHTTPResponse
     from strawberry.http.ides import GraphQL_IDE
     from strawberry.schema import BaseSchema
 
 
-class SanicHTTPRequestAdapter(AsyncHTTPRequestAdapter):
-    def __init__(self, request: Request) -> None:
-        self.request = request
-
-    @property
-    def query_params(self) -> QueryParams:
-        # Just a heads up, Sanic's request.args uses urllib.parse.parse_qs
-        # to parse query string parameters. This returns a dictionary where
-        # the keys are the unique variable names and the values are lists
-        # of values for each variable name. To ensure consistency, we're
-        # enforcing the use of the first value in each list.
-        args = self.request.get_args(keep_blank_values=True)
-        return {k: args.get(k, None) for k in args}
-
-    @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]:
-        return self.request.content_type
-
-    async def get_body(self) -> str:
-        return self.request.body.decode()
-
-    async def get_form_data(self) -> FormData:
-        assert self.request.form is not None
-
-        files = convert_request_to_files_dict(self.request)
-
-        return FormData(form=self.request.form, files=files)
-
-
 class GraphQLView(
     AsyncBaseHTTPView[
         Request,

strawberry/schema/schema.py

@@ -50,6 +50,7 @@ from strawberry.extensions.directives import (
 from strawberry.extensions.runner import SchemaExtensionsRunner
 from strawberry.printer import print_schema
 from strawberry.schema.schema_converter import GraphQLCoreConverter
+from strawberry.schema.validation_rules.maybe_null import MaybeNullValidationRule
 from strawberry.schema.validation_rules.one_of import OneOfInputValidationRule
 from strawberry.types.base import (
     StrawberryObjectDefinition,
@@ -124,6 +125,7 @@ def validate_document(
 ) -> list[GraphQLError]:
     validation_rules = (
         *validation_rules,
+        MaybeNullValidationRule,
         OneOfInputValidationRule,
     )
     return validate(

strawberry/schema/schema_converter.py

@@ -854,6 +854,13 @@ class GraphQLCoreConverter:
         NoneType = type(None)
         if type_ is None or type_ is NoneType:
             return self.from_type(type_)
+        if isinstance(type_, StrawberryMaybe):
+            # StrawberryMaybe should always generate optional types
+            # because Maybe[T] = Union[Some[T], None] (field can be absent)
+            # But we need to handle the case where of_type is itself optional
+            if isinstance(type_.of_type, StrawberryOptional):
+                return self.from_type(type_.of_type.of_type)
+            return self.from_type(type_.of_type)
         if isinstance(type_, StrawberryOptional):
             return self.from_type(type_.of_type)
         return GraphQLNonNull(self.from_type(type_))

strawberry/schema/validation_rules/maybe_null.py

@@ -0,0 +1,136 @@
+from typing import Any
+
+from graphql import (
+    ArgumentNode,
+    GraphQLError,
+    GraphQLNamedType,
+    ObjectValueNode,
+    ValidationContext,
+    ValidationRule,
+    get_named_type,
+)
+
+from strawberry.types.base import StrawberryMaybe, StrawberryOptional
+from strawberry.utils.str_converters import to_camel_case
+
+
+class MaybeNullValidationRule(ValidationRule):
+    """Validates that Maybe[T] fields do not receive explicit null values.
+
+    This rule ensures that:
+    - Maybe[T] fields can only be omitted or have non-null values
+    - Maybe[T | None] fields can be omitted, null, or have non-null values
+
+    This provides clear semantics where Maybe[T] means "either present with value or absent"
+    and Maybe[T | None] means "present with value, present but null, or absent".
+    """
+
+    def __init__(self, validation_context: ValidationContext) -> None:
+        super().__init__(validation_context)
+
+    def enter_argument(self, node: ArgumentNode, *_args: Any) -> None:
+        # Check if this is a null value
+        if node.value.kind != "null_value":
+            return
+
+        # Get the argument definition from the schema
+        argument_def = self.context.get_argument()
+        if not argument_def:
+            return
+
+        # Check if this argument corresponds to a Maybe[T] (not Maybe[T | None])
+        # The argument type extensions should contain the Strawberry type info
+        strawberry_arg_info = argument_def.extensions.get("strawberry-definition")
+        if not strawberry_arg_info:
+            return
+
+        # Get the Strawberry type from the argument info
+        field_type = getattr(strawberry_arg_info, "type", None)
+        if not field_type:
+            return
+
+        if isinstance(field_type, StrawberryMaybe) and not isinstance(
+            field_type.of_type, StrawberryOptional
+        ):
+            # This is Maybe[T] - should not accept null values
+            type_name = self._get_type_name(field_type.of_type)
+
+            self.report_error(
+                GraphQLError(
+                    f"Expected value of type '{type_name}', found null. "
+                    f"Argument '{node.name.value}' of type 'Maybe[{type_name}]' cannot be explicitly set to null. "
+                    f"Use 'Maybe[{type_name} | None]' if you need to allow null values.",
+                    nodes=[node],
+                )
+            )
+
+    def enter_object_value(self, node: ObjectValueNode, *_args: Any) -> None:
+        # Get the input type for this object
+        input_type = get_named_type(self.context.get_input_type())
+        if not input_type:
+            return
+
+        # Get the Strawberry type definition from extensions
+        strawberry_type = input_type.extensions.get("strawberry-definition")
+        if not strawberry_type:
+            return
+
+        # Check each field in the object for null Maybe[T] violations
+        self.validate_maybe_fields(node, input_type, strawberry_type)
+
+    def validate_maybe_fields(
+        self, node: ObjectValueNode, input_type: GraphQLNamedType, strawberry_type: Any
+    ) -> None:
+        # Create a map of field names to field nodes for easy lookup
+        field_node_map = {field.name.value: field for field in node.fields}
+
+        # Check each field in the Strawberry type definition
+        if not hasattr(strawberry_type, "fields"):
+            return
+
+        for field_def in strawberry_type.fields:
+            # Resolve the actual GraphQL field name using the same logic as NameConverter
+            if field_def.graphql_name is not None:
+                field_name = field_def.graphql_name
+            else:
+                # Apply auto_camel_case conversion if enabled (default behavior)
+                field_name = to_camel_case(field_def.python_name)
+
+            # Check if this field is present in the input and has a null value
+            if field_name in field_node_map:
+                field_node = field_node_map[field_name]
+
+                # Check if this field has a null value
+                if field_node.value.kind == "null_value":
+                    # Check if this is a Maybe[T] (not Maybe[T | None])
+                    field_type = field_def.type
+                    if isinstance(field_type, StrawberryMaybe) and not isinstance(
+                        field_type.of_type, StrawberryOptional
+                    ):
+                        # This is Maybe[T] - should not accept null values
+                        type_name = self._get_type_name(field_type.of_type)
+                        self.report_error(
+                            GraphQLError(
+                                f"Expected value of type '{type_name}', found null. "
+                                f"Field '{field_name}' of type 'Maybe[{type_name}]' cannot be explicitly set to null. "
+                                f"Use 'Maybe[{type_name} | None]' if you need to allow null values.",
+                                nodes=[field_node],
+                            )
+                        )
+
+    def _get_type_name(self, type_: Any) -> str:
+        """Get a readable type name for error messages."""
+        if hasattr(type_, "__name__"):
+            return type_.__name__
+        # Handle Strawberry types that don't have __name__
+        if hasattr(type_, "of_type") and hasattr(type_.of_type, "__name__"):
+            # For StrawberryList, StrawberryOptional, etc.
+            return (
+                f"list[{type_.of_type.__name__}]"
+                if "List" in str(type_.__class__)
+                else type_.of_type.__name__
+            )
+        return str(type_)
+
+
+__all__ = ["MaybeNullValidationRule"]

strawberry/types/arguments.py

@@ -191,10 +191,24 @@ def convert_argument(
     from strawberry.relay.types import GlobalID
 
     # TODO: move this somewhere else and make it first class
-    if isinstance(type_, StrawberryOptional):
+    # Handle StrawberryMaybe first, since it extends StrawberryOptional
+    if isinstance(type_, StrawberryMaybe):
+        # Check if this is Maybe[T | None] (has StrawberryOptional as of_type)
+        if isinstance(type_.of_type, StrawberryOptional):
+            # This is Maybe[T | None] - allows null values
+            res = convert_argument(value, type_.of_type, scalar_registry, config)
+
+            return Some(res)
+
+        # This is Maybe[T] - validation for null values is handled by MaybeNullValidationRule
+        # Convert the value and wrap in Some()
         res = convert_argument(value, type_.of_type, scalar_registry, config)
 
-        return Some(res) if isinstance(type_, StrawberryMaybe) else res
+        return Some(res)
+
+    # Handle regular StrawberryOptional (not Maybe)
+    if isinstance(type_, StrawberryOptional):
+        return convert_argument(value, type_.of_type, scalar_registry, config)
 
     if value is None:
         return None

strawberry/types/maybe.py

@@ -31,7 +31,7 @@ class Some(Generic[T]):
 
 
 if TYPE_CHECKING:
-    Maybe: TypeAlias = Union[Some[Union[T, None]], None]
+    Maybe: TypeAlias = Union[Some[T], None]
 else:
     # we do this trick so we can inspect that at runtime
     class Maybe(Generic[T]): ...