Fix Maybe usage with Annotated and explicit field definition (#4084)

Co-authored-by: Jacob Allen <jacoballen@moshipco.com>
Co-authored-by: Thiago Bellini Ribeiro <hackedbellini@gmail.com>

Author: 3 people

RELEASE.md

@@ -0,0 +1,5 @@
+Release type: patch
+
+Fixed two bugs where using `strawberry.Maybe` wrapped in `Annotated` or using an explicit field definition would raise a `TypeError` about "missing 1 required keyword-only argument", even though a `Maybe` field should allow `None` in all cases.
+
+This fix addresses this via custom handling for annotations wrapped with `Annotated` and handling custom `field` with no `default` and no `default_factory` as possible to be `None`.

strawberry/types/maybe.py

@@ -1,6 +1,6 @@
 import re
 import typing
-from typing import TYPE_CHECKING, Any, Generic, TypeAlias, TypeVar
+from typing import TYPE_CHECKING, Annotated, Any, Generic, TypeAlias, TypeVar
 
 T = TypeVar("T")
 
@@ -47,7 +47,10 @@ def _annotation_is_maybe(annotation: Any) -> bool:
         # Checking for the pattern should be good enough for now.
         return _maybe_re.match(annotation) is not None
 
-    return (orig := typing.get_origin(annotation)) and orig is Maybe
+    orig = typing.get_origin(annotation)
+    if orig is Annotated:
+        return _annotation_is_maybe(typing.get_args(annotation)[0])
+    return orig is Maybe
 
 
 __all__ = [

strawberry/types/object_type.py

@@ -109,8 +109,15 @@ def _inject_default_for_maybe_annotations(
 ) -> None:
     """Inject `= None` for fields with `Maybe` annotations and no default value."""
     for name, annotation in annotations.copy().items():
-        if _annotation_is_maybe(annotation) and not hasattr(cls, name):
-            setattr(cls, name, None)
+        if _annotation_is_maybe(annotation):
+            if not hasattr(cls, name):
+                setattr(cls, name, None)
+            elif (
+                isinstance(attr := getattr(cls, name), StrawberryField)
+                and attr.default is dataclasses.MISSING
+                and attr.default_factory is dataclasses.MISSING
+            ):
+                attr.default = None
 
 
 def _process_type(

tests/schema/test_maybe.py

@@ -1,4 +1,5 @@
 from textwrap import dedent
+from typing import Annotated
 
 import pytest
 
@@ -998,3 +999,166 @@ def test_comprehensive(self, input: ComprehensiveInput) -> str:
     """)
     assert not result5.errors  # No error - both fields are optional in schema
     assert result5.data == {"testComprehensive": "strict=absent, flexible=world"}
+
+
+def test_maybe_with_explicit_field_description():
+    """Handle case where strawberry.field annotation is used on a field with Maybe[T] type."""
+
+    @strawberry.input
+    class InputData:
+        name: strawberry.Maybe[str | None] = strawberry.field(
+            description="This strawberry.field annotation was breaking in default injection"
+        )
+
+    @strawberry.type
+    class Query:
+        @strawberry.field
+        def test(self, data: InputData) -> str:
+            if data.name is None:
+                return "I am a test, and I received: None"
+            return "I am a test, and I received: " + str(data.name.value)
+
+    schema = strawberry.Schema(Query)
+
+    assert str(schema) == dedent(
+        '''\
+        input InputData {
+          """This strawberry.field annotation was breaking in default injection"""
+          name: String
+        }
+
+        type Query {
+          test(data: InputData!): String!
+        }'''
+    )
+
+    query1 = """
+    query {
+        test(data: { name: null })
+    }
+    """
+    result1 = schema.execute_sync(query1)
+    assert not result1.errors
+
+    query2 = """
+    query {
+        test(data: { name: "hello" })
+    }
+    """
+    result2 = schema.execute_sync(query2)
+    assert not result2.errors
+
+    query3 = """
+    query {
+        test(data: {})
+    }
+    """
+    result3 = schema.execute_sync(query3)
+    assert not result3.errors
+
+
+def test_maybe_wrapped_with_annotated_typing():
+    """Handle case where Maybe is wrapped with Annotated typing."""
+
+    @strawberry.input
+    class InputData:
+        name: Annotated[strawberry.Maybe[str | None], "some meta"]
+
+    @strawberry.type
+    class Query:
+        @strawberry.field
+        def test(self, data: InputData) -> str:
+            if data.name is None:
+                return "I am a test, and I received: None"
+            return "I am a test, and I received: " + str(data.name.value)
+
+    schema = strawberry.Schema(Query)
+
+    assert str(schema) == dedent(
+        """\
+        input InputData {
+          name: String
+        }
+
+        type Query {
+          test(data: InputData!): String!
+        }"""
+    )
+    query1 = """
+    query {
+        test(data: { name: null })
+    }
+    """
+    result1 = schema.execute_sync(query1)
+    assert not result1.errors
+
+    query2 = """
+    query {
+        test(data: { name: "hello" })
+    }
+    """
+    result2 = schema.execute_sync(query2)
+    assert not result2.errors
+
+    query3 = """
+    query {
+        test(data: {})
+    }
+    """
+    result3 = schema.execute_sync(query3)
+    assert not result3.errors
+
+
+def test_maybe_with_annotated_and_explicit_definition():
+    """Handle case where Maybe is wrapped with Annotated typing."""
+
+    @strawberry.input
+    class InputData:
+        name: Annotated[strawberry.Maybe[str | None], "some meta"] = strawberry.field(
+            description="This strawberry.field annotation was breaking in default injection"
+        )
+
+    @strawberry.type
+    class Query:
+        @strawberry.field
+        def test(self, data: InputData) -> str:
+            if data.name is None:
+                return "I am a test, and I received: None"
+            return "I am a test, and I received: " + str(data.name.value)
+
+    schema = strawberry.Schema(Query)
+
+    assert str(schema) == dedent(
+        '''\
+        input InputData {
+          """This strawberry.field annotation was breaking in default injection"""
+          name: String
+        }
+
+        type Query {
+          test(data: InputData!): String!
+        }'''
+    )
+    query1 = """
+    query {
+        test(data: { name: null })
+    }
+    """
+    result1 = schema.execute_sync(query1)
+    assert not result1.errors
+
+    query2 = """
+    query {
+        test(data: { name: "hello" })
+    }
+    """
+    result2 = schema.execute_sync(query2)
+    assert not result2.errors
+
+    query3 = """
+    query {
+        test(data: {})
+    }
+    """
+    result3 = schema.execute_sync(query3)
+    assert not result3.errors