updated validators and fixed ci bug

* fixed validators compatibility problems between python versions
* removed duplicated key in pyproject.toml

Author: CosmoV

fastapi_jsonapi/schema_builder.py

@@ -3,12 +3,11 @@
 import logging
 from typing import Annotated, Any, Callable, Literal, Optional, Type, TypeVar, Union
 
-from pydantic import AfterValidator, BeforeValidator, ConfigDict, create_model
+from pydantic import AfterValidator, BeforeValidator, ConfigDict, PlainValidator, WrapValidator, create_model
 from pydantic import BaseModel as PydanticBaseModel
 
 # noinspection PyProtectedMember
 from pydantic.fields import FieldInfo
-from typing_extensions import Unpack
 
 from fastapi_jsonapi.common import get_relationship_info_from_field_metadata, search_client_can_set_id
 from fastapi_jsonapi.schema import (
@@ -190,11 +189,13 @@ def _annotation_with_validators(cls, field: FieldInfo) -> type:
         annotation = field.annotation
         validators = []
         for val in field.metadata:
-            if isinstance(val, (AfterValidator, BeforeValidator)):
+            if isinstance(val, (AfterValidator, BeforeValidator, WrapValidator, PlainValidator)):
                 validators.append(val)
 
         if validators:
-            annotation = Annotated[annotation, Unpack[validators]]
+            # TODO: change to Annotation[annotation, *validators] when drop support of python 3.10
+            annotation_validators = ",".join(f"validators[{i}]" for i in range(len(validators)))
+            annotation = eval(f"Annotated[annotation, {annotation_validators}]")
 
         return annotation
 

fastapi_jsonapi/validation_utils.py

@@ -35,11 +35,17 @@ def extract_validators(
             if include_for_field_names and field_name not in include_for_field_names:
                 continue
             validator_config = field_validator(field_name, mode=validator.info.mode)
-            field_validators[name] = validator_config(validator.func)
+
+            func = validator.func.__func__ if hasattr(validator.func, "__func__") else validator.func
+
+            field_validators[name] = validator_config(func)
 
     # model validators
     for name, validator in validators.model_validators.items():
         validator_config = model_validator(mode=validator.info.mode)
-        model_validators[name] = validator_config(validator.func)
+
+        func = validator.func.__func__ if hasattr(validator.func, "__func__") else validator.func
+
+        model_validators[name] = validator_config(func)
 
     return field_validators, model_validators

fastapi_jsonapi/views/view_base.py

@@ -261,8 +261,10 @@ def _prepare_item_data(
         resource_type: str,
         include_fields: Optional[dict[str, dict[str, Type[TypeSchema]]]] = None,
     ) -> dict:
+        attrs_schema = schemas_storage.get_attrs_schema(resource_type, operation_type="get")
+
         if include_fields is None or not (field_schemas := include_fields.get(resource_type)):
-            attrs_schema = schemas_storage.get_attrs_schema(resource_type, operation_type="get")
+
             data_schema = schemas_storage.get_data_schema(resource_type, operation_type="get")
             return data_schema(
                 id=f"{db_item.id}",
@@ -282,13 +284,21 @@ def _prepare_item_data(
             )
             if before_validators:
                 for validator_name, validator in before_validators.items():
+                    if hasattr(validator.wrapped, "__func__"):
+                        pre_values = validator.wrapped.__func__(attrs_schema, pre_values)
+                        continue
+
                     pre_values = validator.wrapped(pre_values)
 
             for field_name, field_schema in field_schemas.items():
                 validated_model = field_schema(**{field_name: pre_values[field_name]})
 
                 if after_validators:
                     for validator_name, validator in after_validators.items():
+                        if hasattr(validator.wrapped, "__func__"):
+                            validated_model = validator.wrapped.__func__(attrs_schema, validated_model)
+                            continue
+
                         validated_model = validator.wrapped(validated_model)
 
                 result_attributes[field_name] = getattr(validated_model, field_name)

pyproject.toml

@@ -101,7 +101,6 @@ mypy = "^1.14.1"
 pre-commit = "^4.1.0"
 ruff = "^0.9.4"
 sqlalchemy-stubs = "^0.4"
-pre-commit = "^3.3.3"
 
 [tool.poetry.group.docs.dependencies]
 sphinx = "^7.0.1"

tests/test_api/test_validators.py

@@ -5,7 +5,17 @@
 from fastapi import FastAPI, status
 from fastapi.datastructures import QueryParams
 from httpx import AsyncClient
-from pydantic import BaseModel, ConfigDict, field_validator, model_validator
+from pydantic import (
+    AfterValidator,
+    BaseModel,
+    BeforeValidator,
+    ConfigDict,
+    PlainValidator,
+    ValidatorFunctionWrapHandler,
+    WrapValidator,
+    field_validator,
+    model_validator,
+)
 from pytest_asyncio import fixture
 from sqlalchemy.ext.asyncio import AsyncSession
 
@@ -723,12 +733,23 @@ def validator_post_2(cls, values):
         )
 
     async def test_validator_calls_for_field_requests(self, user_1: User):
+        def annotation_pre_validator(value: str) -> str:
+            return f"{value} (annotation_pre_field)"
+
+        def annotation_post_validator(value: str) -> str:
+            return f"{value} (annotation_post_field)"
+
         class UserSchemaWithValidator(BaseModel):
             model_config = ConfigDict(
                 from_attributes=True,
             )
 
-            name: str
+            name: Annotated[
+                str,
+                BeforeValidator(annotation_pre_validator),
+                AfterValidator(annotation_post_validator),
+                # WrapValidator(wrapp_validator),
+            ]
 
             @field_validator("name", mode="before")
             @classmethod
@@ -749,7 +770,7 @@ def pre_model_validator(cls, data: dict):
 
             @model_validator(mode="after")
             @classmethod
-            def post_model_validator(self, value):
+            def post_model_validator(cls, value):
                 value.name = f"{value.name} (post_model)"
                 return value
 
@@ -773,14 +794,89 @@ def post_model_validator(self, value):
             "data": {
                 "attributes": {
                     # check validators call order
-                    "name": f"{user_1.name} (pre_model) (pre_field) (post_field) (post_model)",
+                    "name": (
+                        f"{user_1.name} (pre_model) (pre_field) (annotation_pre_field) "
+                        "(annotation_post_field) (post_field) (post_model)"
+                    ),
                 },
                 "type": self.resource_type,
             },
             "jsonapi": {"version": "1.0"},
             "meta": None,
         }
 
+    async def test_wrapp_validator_for_field_requests(self, user_1: User):
+        def wrapp_validator(value: str, handler: ValidatorFunctionWrapHandler) -> str:
+            return f"{value} (wrapp_field)"
+
+        class UserSchemaWithValidator(BaseModel):
+            model_config = ConfigDict(
+                from_attributes=True,
+            )
+
+            name: Annotated[str, WrapValidator(wrapp_validator)]
+
+        params = QueryParams(
+            [
+                (f"fields[{self.resource_type}]", "name"),
+            ],
+        )
+
+        app = self.build_app(UserSchemaWithValidator)
+
+        async with AsyncClient(app=app, base_url="http://test") as client:
+            url = app.url_path_for(f"get_{self.resource_type}_detail", obj_id=user_1.id)
+            res = await client.get(url, params=params)
+            assert res.status_code == status.HTTP_200_OK, res.text
+            res_json = res.json()
+
+        assert res_json["data"]
+        assert res_json["data"].pop("id")
+        assert res_json == {
+            "data": {
+                "attributes": {"name": (f"{user_1.name} (wrapp_field)")},
+                "type": self.resource_type,
+            },
+            "jsonapi": {"version": "1.0"},
+            "meta": None,
+        }
+
+    async def test_plain_validator_for_field_requests(self, user_1: User):
+        def plain_validator(value: str, handler: ValidatorFunctionWrapHandler) -> str:
+            return f"{value} (plain_field)"
+
+        class UserSchemaWithValidator(BaseModel):
+            model_config = ConfigDict(
+                from_attributes=True,
+            )
+
+            name: Annotated[int, PlainValidator(plain_validator)]
+
+        params = QueryParams(
+            [
+                (f"fields[{self.resource_type}]", "name"),
+            ],
+        )
+
+        app = self.build_app(UserSchemaWithValidator)
+
+        async with AsyncClient(app=app, base_url="http://test") as client:
+            url = app.url_path_for(f"get_{self.resource_type}_detail", obj_id=user_1.id)
+            res = await client.get(url, params=params)
+            assert res.status_code == status.HTTP_200_OK, res.text
+            res_json = res.json()
+
+        assert res_json["data"]
+        assert res_json["data"].pop("id")
+        assert res_json == {
+            "data": {
+                "attributes": {"name": (f"{user_1.name} (plain_field)")},
+                "type": self.resource_type,
+            },
+            "jsonapi": {"version": "1.0"},
+            "meta": None,
+        }
+
 
 class TestValidationUtils:
     @pytest.mark.parametrize(