Fix pydantic generics and add ability to directive json schema

Author: Boudewijn26

RELEASE.md

@@ -0,0 +1,4 @@
+Release type: minor
+
+This release fixes the pydantic support for generics and allows capture of the Pydantic 
+JSON schema attributes through a schema directive.

docs/integrations/pydantic.md

@@ -519,3 +519,55 @@ user_type = UserType(id="abc", content_name="Bob", content_description=None)
 print(user_type.to_pydantic())
 # id='abc' content={<ContentType.NAME: 'name'>: 'Bob'}
 ```
+
+## Schema directives to capture JSON schema data
+
+The pydantic conversion also supports capturing the JSON schema metadata from Pydantic. Note the fields in the directive must match the json schema names.
+
+```python
+from pydantic import BaseModel, Field
+from typing import Annotated, Optional
+from strawberry.schema_directive import Location
+import strawberry
+
+class User(BaseModel):
+    id: Annotated[int, Field(gt=0)]
+    name: Annotated[str, Field(json_schema_extra={"name_type": "full"})]
+
+
+@strawberry.schema_directive(locations=[Location.FIELD_DEFINITION])
+class MyJsonSchema:
+    exclusive_minimum: Optional[int] = None
+    name_type: Optional[str] = None
+
+
+@strawberry.experimental.pydantic.type(model=User, json_schema_directive=MyJsonSchema)
+class UserType:
+    id: strawberry.auto
+    name: strawberry.auto
+
+
+@strawberry.type
+class Query:
+    @strawberry.field
+    def test() -> UserType:
+        return UserType.from_pydantic(User(id=123, name="John Doe"))
+
+
+schema = strawberry.Schema(query=Query)
+```
+
+Now if [the schema is exported](../guides/schema-export), the result will contain:
+
+```graphql
+directive @myJsonSchema(exclusiveMinimum: Int = null, nameType: String = null) on FIELD_DEFINITION
+
+type Query {
+  test: UserType!
+}
+
+type UserType {
+  id: Int!
+  name: String! @myJsonSchema(exclusiveMinimum: null, nameType: "full")
+}
+```

strawberry/experimental/pydantic/_compat.py

@@ -178,6 +178,9 @@ def get_model_fields(
             new_fields |= self.get_model_computed_fields(model)
         return new_fields
 
+    def get_model_json_schema(self, model: type[BaseModel]) -> dict[str, Any]:
+        return model.model_json_schema()
+
     @cached_property
     def fields_map(self) -> dict[Any, Any]:
         return get_fields_map_for_v2()
@@ -273,6 +276,9 @@ def get_basic_type(self, type_: Any) -> type[Any]:
 
         return type_
 
+    def get_model_json_schema(self, model: type[BaseModel]) -> dict[str, Any]:
+        return model.schema()
+
     def model_dump(self, model_instance: BaseModel) -> dict[Any, Any]:
         return model_instance.dict()
 

strawberry/experimental/pydantic/fields.py

@@ -46,7 +46,10 @@ def replace_types_recursively(
     origin = get_origin(type_)
 
     if not origin or not hasattr(type_, "__args__"):
-        return replaced_type
+        if hasattr(basic_type, "__pydantic_generic_metadata__") and basic_type.__pydantic_generic_metadata__["args"]:
+            return replaced_type[*basic_type.__pydantic_generic_metadata__["args"]]
+        else:
+            return replaced_type
 
     converted = tuple(
         replace_types_recursively(t, is_input=is_input, compat=compat)

strawberry/experimental/pydantic/object_type.py

@@ -33,6 +33,7 @@
 from strawberry.types.field import StrawberryField
 from strawberry.types.object_type import _process_type, _wrap_dataclass
 from strawberry.types.type_resolver import _get_fields
+from strawberry.utils.str_converters import to_snake_case
 
 if TYPE_CHECKING:
     import builtins
@@ -41,7 +42,9 @@
     from graphql import GraphQLResolveInfo
 
 
-def get_type_for_field(field: CompatModelField, is_input: bool, compat: PydanticCompat):  # noqa: ANN201
+def get_type_for_field(
+    field: CompatModelField, is_input: bool, compat: PydanticCompat
+):  # noqa: ANN201
     outer_type = field.outer_type_
 
     replaced_type = replace_types_recursively(outer_type, is_input, compat=compat)
@@ -62,6 +65,8 @@ def _build_dataclass_creation_fields(
     auto_fields_set: set[str],
     use_pydantic_alias: bool,
     compat: PydanticCompat,
+    json_schema: dict[str, Any],
+    json_schema_directive: Optional[builtins.type] = None,
 ) -> DataclassCreationFields:
     field_type = (
         get_type_for_field(field, is_input, compat=compat)
@@ -84,6 +89,28 @@ def _build_dataclass_creation_fields(
         elif field.has_alias and use_pydantic_alias:
             graphql_name = field.alias
 
+        if json_schema_directive and json_schema:
+            field_names = {
+                field.name for field in dataclasses.fields(json_schema_directive)
+            }
+            applicable_values = {
+                    to_snake_case(key): value
+                    for key, value in json_schema.items()
+                    if to_snake_case(key) in field_names
+                }
+            if applicable_values:
+                json_directive = json_schema_directive(
+                    **applicable_values
+                )
+                directives = (
+                    *(existing_field.directives if existing_field else ()),
+                    json_directive,
+                )
+            else:
+                directives = existing_field.directives if existing_field else ()
+        else:
+            directives = ()
+
         strawberry_field = StrawberryField(
             python_name=field.name,
             graphql_name=graphql_name,
@@ -98,7 +125,7 @@ def _build_dataclass_creation_fields(
             permission_classes=(
                 existing_field.permission_classes if existing_field else []
             ),
-            directives=existing_field.directives if existing_field else (),
+            directives=directives,
             metadata=existing_field.metadata if existing_field else {},
         )
 
@@ -128,6 +155,7 @@ def type(
     all_fields: bool = False,
     include_computed: bool = False,
     use_pydantic_alias: bool = True,
+    json_schema_directive: Optional[Any] = None,
 ) -> Callable[..., builtins.type[StrawberryTypeFromPydantic[PydanticModel]]]:
     def wrap(cls: Any) -> builtins.type[StrawberryTypeFromPydantic[PydanticModel]]:
         compat = PydanticCompat.from_model(model)
@@ -184,6 +212,11 @@ def wrap(cls: Any) -> builtins.type[StrawberryTypeFromPydantic[PydanticModel]]:
         private_fields = get_private_fields(wrapped)
 
         extra_fields_dict = {field.name: field for field in extra_strawberry_fields}
+        fields_json_schema = (
+            compat.get_model_json_schema(model).get("properties", {})
+            if json_schema_directive
+            else {}
+        )
 
         all_model_fields: list[DataclassCreationFields] = [
             _build_dataclass_creation_fields(
@@ -193,6 +226,8 @@ def wrap(cls: Any) -> builtins.type[StrawberryTypeFromPydantic[PydanticModel]]:
                 auto_fields_set,
                 use_pydantic_alias,
                 compat=compat,
+                json_schema_directive=json_schema_directive,
+                json_schema=fields_json_schema.get(field.name, {}),
             )
             for field_name, field in model_fields.items()
             if field_name in fields_set
@@ -250,10 +285,12 @@ def is_type_of(cls: builtins.type, obj: Any, _info: GraphQLResolveInfo) -> bool:
         else:
             kwargs["init"] = False
 
+        bases = cls.__orig_bases__ if hasattr(cls, "__orig_bases__") else cls.__bases__
+
         cls = dataclasses.make_dataclass(
             cls.__name__,
             [field.to_tuple() for field in all_model_fields],
-            bases=cls.__bases__,
+            bases=bases,
             namespace=namespace,
             **kwargs,  # type: ignore
         )
@@ -317,6 +354,7 @@ def input(
     directives: Optional[Sequence[object]] = (),
     all_fields: bool = False,
     use_pydantic_alias: bool = True,
+    json_schema_directive: Optional[builtins.type] = None,
 ) -> Callable[..., builtins.type[StrawberryTypeFromPydantic[PydanticModel]]]:
     """Convenience decorator for creating an input type from a Pydantic model.
 
@@ -334,6 +372,7 @@ def input(
         directives=directives,
         all_fields=all_fields,
         use_pydantic_alias=use_pydantic_alias,
+        json_schema_directive=json_schema_directive,
     )
 
 

tests/experimental/pydantic/schema/test_basic.py

@@ -1,6 +1,6 @@
 import textwrap
 from enum import Enum
-from typing import Optional, Union
+from typing import Annotated, Generic, Optional, TypeAlias, Union, TypeVar
 
 import pydantic
 
@@ -528,6 +528,71 @@ def user(self) -> User:
     assert result.data["user"]["age"] == 1
     assert result.data["user"]["password"] is None
 
+def test_nested_type_with_resolved_generic():
+
+    A = TypeVar("A")
+    class Hobby(pydantic.BaseModel, Generic[A]):
+        name: A
+
+    @strawberry.experimental.pydantic.type(Hobby)
+    class HobbyType(Generic[A]):
+        name: strawberry.auto
+
+    class User(pydantic.BaseModel):
+        hobby: Hobby[str]
+
+    @strawberry.experimental.pydantic.type(User)
+    class UserType:
+        hobby: strawberry.auto
+
+    @strawberry.type
+    class Query:
+        @strawberry.field
+        def user(self) -> UserType:
+            return UserType(hobby=HobbyType(name="Skii"))
+
+    schema = strawberry.Schema(query=Query)
+
+    query = "{ user { hobby { name } } }"
+
+    result = schema.execute_sync(query)
+
+    assert not result.errors
+    assert result.data["user"]["hobby"]["name"] == "Skii"
+
+def test_nested_type_with_resolved_field_generic():
+    Count: TypeAlias = Annotated[float, pydantic.Field(ge = 0)]
+
+    A = TypeVar("A")
+    class Hobby(pydantic.BaseModel, Generic[A]):
+        count: A
+
+    @strawberry.experimental.pydantic.type(Hobby)
+    class HobbyType(Generic[A]):
+        count: strawberry.auto
+
+    class User(pydantic.BaseModel):
+        hobby: Hobby[Count]
+
+    @strawberry.experimental.pydantic.type(User)
+    class UserType:
+        hobby: strawberry.auto
+
+    @strawberry.type
+    class Query:
+        @strawberry.field
+        def user(self) -> UserType:
+            return UserType(hobby=HobbyType(count=2))
+
+    schema = strawberry.Schema(query=Query)
+
+    query = "{ user { hobby { count } } }"
+
+    result = schema.execute_sync(query)
+
+    assert not result.errors
+    assert result.data["user"]["hobby"]["count"] == 2
+
 
 @needs_pydantic_v1
 def test_basic_type_with_constrained_list():