strawberry-graphql 0.279.0.dev1754159379__py3-none-any.whl → 0.281.0__py3-none-any.whl

strawberry/relay/utils.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING, Any, Union
 from typing_extensions import Self, assert_never
 
 from strawberry.types.base import StrawberryObjectDefinition
-from strawberry.types.nodes import InlineFragment, Selection
+from strawberry.types.nodes import InlineFragment
 
 if TYPE_CHECKING:
     from strawberry.types.info import Info
@@ -83,31 +83,19 @@ def should_resolve_list_connection_edges(info: Info) -> bool:
 
     """
     resolve_for_field_names = {"edges", "pageInfo"}
-
-    def _check_selection(selection: Selection) -> bool:
-        """Recursively inspect the selection to check if the user requested to resolve the `edges` field.
-
-        Args:
-            selection (Selection): The selection to check.
-
-        Returns:
-            bool: True if the user requested to resolve the `edges` field of a connection, False otherwise.
-        """
+    # Recursively inspect the selection to check if the user requested to resolve the `edges` field.
+    stack = []
+    for selection_field in info.selected_fields:
+        stack.extend(selection_field.selections)
+    while stack:
+        selection = stack.pop()
         if (
             not isinstance(selection, InlineFragment)
             and selection.name in resolve_for_field_names
         ):
             return True
-        if selection.selections:
-            return any(
-                _check_selection(selection) for selection in selection.selections
-            )
-        return False
-
-    for selection_field in info.selected_fields:
-        for selection in selection_field.selections:
-            if _check_selection(selection):
-                return True
+        if nested_selections := getattr(selection, "selections", None):
+            stack.extend(nested_selections)
     return False
 
 

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

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import contextlib
 import dataclasses
 import sys
 from functools import partial, reduce
@@ -732,27 +731,14 @@ class GraphQLCoreConverter:
             ) -> Any:
                 # parse field arguments into Strawberry input types and convert
                 # field names to Python equivalents
-                try:
-                    field_args, field_kwargs = get_arguments(
-                        field=field,
-                        source=_source,
-                        info=info,
-                        kwargs=kwargs,
-                        config=self.config,
-                        scalar_registry=self.scalar_registry,
-                    )
-                except Exception as exc:
-                    # Try to import Pydantic ValidationError
-                    with contextlib.suppress(ImportError):
-                        from pydantic import ValidationError
-
-                        if isinstance(
-                            exc, ValidationError
-                        ) and self._should_convert_validation_error(field):
-                            from strawberry.pydantic import Error
-
-                            return Error.from_validation_error(exc)
-                    raise
+                field_args, field_kwargs = get_arguments(
+                    field=field,
+                    source=_source,
+                    info=info,
+                    kwargs=kwargs,
+                    config=self.config,
+                    scalar_registry=self.scalar_registry,
+                )
 
                 resolver_requested_info = False
                 if "info" in field_kwargs:
@@ -813,22 +799,6 @@ class GraphQLCoreConverter:
         _resolver._is_default = not field.base_resolver  # type: ignore
         return _resolver
 
-    def _should_convert_validation_error(self, field: StrawberryField) -> bool:
-        """Check if field return type is a Union containing strawberry.pydantic.Error."""
-        from strawberry.types.union import StrawberryUnion
-
-        field_type = field.type
-        if isinstance(field_type, StrawberryUnion):
-            # Import Error dynamically to avoid circular imports
-            try:
-                from strawberry.pydantic import Error
-
-                return any(union_type is Error for union_type in field_type.types)
-            except ImportError:
-                # If strawberry.pydantic doesn't exist or Error isn't available
-                return False
-        return False
-
     def from_scalar(self, scalar: type) -> GraphQLScalarType:
         from strawberry.relay.types import GlobalID
 
@@ -884,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/subscriptions/protocols/graphql_transport_ws/handlers.py

@@ -34,7 +34,6 @@ from strawberry.types import ExecutionResult
 from strawberry.types.execution import PreExecutionError
 from strawberry.types.graphql import OperationType
 from strawberry.types.unset import UnsetType
-from strawberry.utils.debug import pretty_print_graphql_operation
 from strawberry.utils.operation import get_operation_type
 
 if TYPE_CHECKING:
@@ -55,7 +54,6 @@ class BaseGraphQLTransportWSHandler(Generic[Context, RootValue]):
         context: Context,
         root_value: Optional[RootValue],
         schema: BaseSchema,
-        debug: bool,
         connection_init_wait_timeout: timedelta,
     ) -> None:
         self.view = view
@@ -63,7 +61,6 @@ class BaseGraphQLTransportWSHandler(Generic[Context, RootValue]):
         self.context = context
         self.root_value = root_value
         self.schema = schema
-        self.debug = debug
         self.connection_init_wait_timeout = connection_init_wait_timeout
         self.connection_init_timeout_task: Optional[asyncio.Task] = None
         self.connection_init_received = False
@@ -237,13 +234,6 @@ class BaseGraphQLTransportWSHandler(Generic[Context, RootValue]):
             await self.websocket.close(code=4409, reason=reason)
             return
 
-        if self.debug:  # pragma: no cover
-            pretty_print_graphql_operation(
-                message["payload"].get("operationName"),
-                message["payload"]["query"],
-                message["payload"].get("variables"),
-            )
-
         operation = Operation(
             self,
             message["id"],

strawberry/subscriptions/protocols/graphql_ws/handlers.py

@@ -27,7 +27,6 @@ from strawberry.subscriptions.protocols.graphql_ws.types import (
 )
 from strawberry.types.execution import ExecutionResult, PreExecutionError
 from strawberry.types.unset import UnsetType
-from strawberry.utils.debug import pretty_print_graphql_operation
 
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator
@@ -44,7 +43,6 @@ class BaseGraphQLWSHandler(Generic[Context, RootValue]):
         context: Context,
         root_value: Optional[RootValue],
         schema: BaseSchema,
-        debug: bool,
         keep_alive: bool,
         keep_alive_interval: Optional[float],
     ) -> None:
@@ -53,7 +51,6 @@ class BaseGraphQLWSHandler(Generic[Context, RootValue]):
         self.context = context
         self.root_value = root_value
         self.schema = schema
-        self.debug = debug
         self.keep_alive = keep_alive
         self.keep_alive_interval = keep_alive_interval
         self.keep_alive_task: Optional[asyncio.Task] = None
@@ -139,9 +136,6 @@ class BaseGraphQLWSHandler(Generic[Context, RootValue]):
         operation_name = payload.get("operationName")
         variables = payload.get("variables")
 
-        if self.debug:
-            pretty_print_graphql_operation(operation_name, query, variables)
-
         result_handler = self.handle_async_results(
             operation_id, query, operation_name, variables
         )

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]): ...

{strawberry_graphql-0.279.0.dev1754159379.dist-info → strawberry_graphql-0.281.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: strawberry-graphql
-Version: 0.279.0.dev1754159379
+Version: 0.281.0
 Summary: A library for creating GraphQL APIs
 License: MIT
 Keywords: graphql,api,rest,starlette,async
@@ -37,6 +37,7 @@ Requires-Dist: channels (>=3.0.5) ; extra == "channels"
 Requires-Dist: fastapi (>=0.65.2) ; extra == "fastapi"
 Requires-Dist: flask (>=1.1) ; extra == "flask"
 Requires-Dist: graphql-core (>=3.2.0,<3.4.0)
+Requires-Dist: lia-web (>=0.2.1)
 Requires-Dist: libcst ; extra == "cli"
 Requires-Dist: libcst ; extra == "debug"
 Requires-Dist: libcst ; extra == "debug-server"