add support for including pydantic computed fields

RELEASE.md

@@ -0,0 +1,23 @@
+Release type: minor
+
+Adds the ability to include pydantic computed fields when using pydantic.type decorator.
+
+Example:
+```python
+class UserModel(pydantic.BaseModel):
+    age: int
+
+    @computed_field
+    @property
+    def next_age(self) -> int:
+        return self.age + 1
+
+
+@strawberry.experimental.pydantic.type(
+    UserModel, all_fields=True, include_computed=True
+)
+class User:
+    pass
+```
+
+Will allow `nextAge` to be requested from a user entity.

docs/integrations/pydantic.md

@@ -63,6 +63,22 @@ class UserType:
     pass
 ```
 
+By default, computed fields are excluded. To also include all computed fields
+pass `include_computed=True` to the decorator.
+
+```python
+import strawberry
+
+from .models import User
+
+
+@strawberry.experimental.pydantic.type(
+    model=User, all_fields=True, include_computed=True
+)
+class UserType:
+    pass
+```
+
 ## Input types
 
 Input types are similar to types; we can create one by using the

strawberry/experimental/pydantic/_compat.py

@@ -12,7 +12,7 @@
 from strawberry.experimental.pydantic.exceptions import UnsupportedTypeError
 
 if TYPE_CHECKING:
-    from pydantic.fields import FieldInfo
+    from pydantic.fields import ComputedFieldInfo, FieldInfo
 
 IS_PYDANTIC_V2: bool = PYDANTIC_VERSION.startswith("2.")
 IS_PYDANTIC_V1: bool = not IS_PYDANTIC_V2
@@ -128,7 +128,33 @@
 
         return PydanticUndefined
 
-    def get_model_fields(self, model: type[BaseModel]) -> dict[str, CompatModelField]:
+    def get_model_computed_fields(
+        self, model: type[BaseModel]
+    ) -> dict[str, CompatModelField]:
+        computed_field_info: dict[str, ComputedFieldInfo] = model.model_computed_fields
+        new_fields = {}
+        # Convert it into CompatModelField
+        for name, field in computed_field_info.items():
+            new_fields[name] = CompatModelField(
+                name=name,
+                type_=field.return_type,
+                outer_type_=field.return_type,
+                default=None,
+                default_factory=None,
+                required=False,
+                alias=field.alias,
+                # v2 doesn't have allow_none
+                allow_none=False,
+                has_alias=field is not None,
+                description=field.description,
+                _missing_type=self.PYDANTIC_MISSING_TYPE,
+                is_v1=False,
+            )
+        return new_fields
+
+    def get_model_fields(
+        self, model: type[BaseModel], include_computed: bool = False
+    ) -> dict[str, CompatModelField]:
         field_info: dict[str, FieldInfo] = model.model_fields
         new_fields = {}
         # Convert it into CompatModelField
@@ -148,6 +174,8 @@
                 _missing_type=self.PYDANTIC_MISSING_TYPE,
                 is_v1=False,
             )
+        if include_computed:
+            new_fields |= self.get_model_computed_fields(model)
         return new_fields
 
     @cached_property
@@ -175,7 +203,10 @@
     def PYDANTIC_MISSING_TYPE(self) -> Any:  # noqa: N802
         return dataclasses.MISSING
 
-    def get_model_fields(self, model: type[BaseModel]) -> dict[str, CompatModelField]:
+    def get_model_fields(
+        self, model: type[BaseModel], include_computed: bool = False
+    ) -> dict[str, CompatModelField]:
+        """`include_computed` is a noop for PydanticV1Compat."""
         new_fields = {}
         # Convert it into CompatModelField
         for name, field in model.__fields__.items():  # type: ignore[attr-defined]
@@ -284,7 +315,6 @@
         smart_deepcopy,
     )
 
-
 __all__ = [
     "PydanticCompat",
     "get_args",

strawberry/experimental/pydantic/object_type.py

@@ -126,11 +126,12 @@ def type(  # noqa: PLR0915
     description: Optional[str] = None,
     directives: Optional[Sequence[object]] = (),
     all_fields: bool = False,
+    include_computed: bool = False,
     use_pydantic_alias: bool = True,
 ) -> Callable[..., builtins.type[StrawberryTypeFromPydantic[PydanticModel]]]:
     def wrap(cls: Any) -> builtins.type[StrawberryTypeFromPydantic[PydanticModel]]:  # noqa: PLR0915
         compat = PydanticCompat.from_model(model)
-        model_fields = compat.get_model_fields(model)
+        model_fields = compat.get_model_fields(model, include_computed=include_computed)
         original_fields_set = set(fields) if fields else set()
 
         if fields:
@@ -171,7 +172,10 @@ def wrap(cls: Any) -> builtins.type[StrawberryTypeFromPydantic[PydanticModel]]:
             raise MissingFieldsListError(cls)
 
         ensure_all_auto_fields_in_pydantic(
-            model=model, auto_fields=auto_fields_set, cls_name=cls.__name__
+            model=model,
+            auto_fields=auto_fields_set,
+            cls_name=cls.__name__,
+            include_computed=include_computed,
         )
 
         wrapped = _wrap_dataclass(cls)

strawberry/experimental/pydantic/utils.py

@@ -117,11 +117,17 @@ def get_default_factory_for_field(
 
 
 def ensure_all_auto_fields_in_pydantic(
-    model: type[BaseModel], auto_fields: set[str], cls_name: str
+    model: type[BaseModel],
+    auto_fields: set[str],
+    cls_name: str,
+    include_computed: bool = False,
 ) -> None:
     compat = PydanticCompat.from_model(model)
     # Raise error if user defined a strawberry.auto field not present in the model
-    non_existing_fields = list(auto_fields - compat.get_model_fields(model).keys())
+    non_existing_fields = list(
+        auto_fields
+        - compat.get_model_fields(model, include_computed=include_computed).keys()
+    )
 
     if non_existing_fields:
         raise AutoFieldsNotInBaseModelError(

tests/experimental/pydantic/schema/test_computed.py

@@ -0,0 +1,72 @@
+import textwrap
+
+import pydantic
+import pytest
+from pydantic.version import VERSION as PYDANTIC_VERSION
+
+import strawberry
+
+IS_PYDANTIC_V2: bool = PYDANTIC_VERSION.startswith("2.")
+
+if IS_PYDANTIC_V2:
+    from pydantic import computed_field
+
+
+@pytest.mark.skipif(
+    not IS_PYDANTIC_V2, reason="Requires Pydantic v2 for computed_field"
+)
+def test_computed_field():
+    class UserModel(pydantic.BaseModel):
+        age: int
+
+        @computed_field
+        @property
+        def next_age(self) -> int:
+            return self.age + 1
+
+    @strawberry.experimental.pydantic.type(
+        UserModel, all_fields=True, include_computed=True
+    )
+    class User:
+        pass
+
+    @strawberry.experimental.pydantic.type(UserModel, all_fields=True)
+    class UserNoComputed:
+        pass
+
+    @strawberry.type
+    class Query:
+        @strawberry.field
+        def user(self) -> User:
+            return User.from_pydantic(UserModel(age=1))
+
+        @strawberry.field
+        def user_no_computed(self) -> UserNoComputed:
+            return UserNoComputed.from_pydantic(UserModel(age=1))
+
+    schema = strawberry.Schema(query=Query)
+
+    expected_schema = """
+    type Query {
+      user: User!
+      userNoComputed: UserNoComputed!
+    }
+
+    type User {
+      age: Int!
+      nextAge: Int!
+    }
+
+    type UserNoComputed {
+      age: Int!
+    }
+    """
+
+    assert str(schema) == textwrap.dedent(expected_schema).strip()
+
+    query = "{ user { age nextAge } }"
+
+    result = schema.execute_sync(query)
+    assert not result.errors
+    assert result.data["user"]["age"] == 1
+    assert result.data["user"]["nextAge"] == 2