added origin validators to attributes schema

Author: CosmoV

fastapi_jsonapi/schema_builder.py

@@ -1,6 +1,7 @@
 """JSON API schemas builder class."""
 from dataclasses import dataclass
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
     Dict,
@@ -14,9 +15,9 @@
 )
 
 import pydantic
-from pydantic import BaseConfig
+from pydantic import BaseConfig, validator
 from pydantic import BaseModel as PydanticBaseModel
-from pydantic.fields import FieldInfo, ModelField
+from pydantic.fields import FieldInfo, ModelField, Validator
 
 from fastapi_jsonapi.data_typing import TypeSchema
 from fastapi_jsonapi.schema import (
@@ -34,6 +35,9 @@
 from fastapi_jsonapi.schema_base import BaseModel, Field, RelationshipInfo, registry
 from fastapi_jsonapi.splitter import SPLIT_REL
 
+if TYPE_CHECKING:
+    pass
+
 JSON_API_RESPONSE_TYPE = Dict[Union[int, str], Dict[str, Any]]
 
 JSONAPIObjectSchemaType = TypeVar("JSONAPIObjectSchemaType", bound=PydanticBaseModel)
@@ -279,6 +283,7 @@ class ConfigOrmMode(BaseConfig):
             f"{base_name}AttributesJSONAPI",
             **attributes_schema_fields,
             __config__=ConfigOrmMode,
+            __validators__=self._extract_validators(schema),
         )
 
         relationships_schema = pydantic.create_model(
@@ -346,6 +351,29 @@ def create_relationship_data_schema(
         self.relationship_schema_cache[cache_key] = relationship_data_schema
         return relationship_data_schema
 
+    def _extract_validators(self, model: Type[BaseModel]) -> Dict[str, Callable]:
+        validators = {}
+        validator_origin_param_keys = ["pre", "each_item", "always", "check_fields"]
+
+        for field_name, model_field in model.__fields__.items():
+            model_field: ModelField
+
+            for validator_name, field_validator in model_field.class_validators.items():
+                validator_name: str
+                field_validator: Validator
+
+                validators[validator_name] = validator(
+                    field_name,
+                    allow_reuse=True,
+                    **{
+                        # copy origin params
+                        param_name: getattr(field_validator, param_name)
+                        for param_name in validator_origin_param_keys
+                    },
+                )(field_validator.func)
+
+        return validators
+
     def _build_jsonapi_object(
         self,
         base_name: str,

tests/test_api/test_api_sqla_with_includes.py

@@ -6,10 +6,12 @@
 
 from fastapi import APIRouter, FastAPI, status
 from httpx import AsyncClient
+from pydantic import BaseModel, validator
 from pytest import mark, param  # noqa PT013
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from fastapi_jsonapi import RoutersJSONAPI
+from fastapi_jsonapi.exceptions import BadRequest
 from fastapi_jsonapi.views.view_base import ViewBase
 from tests.fixtures.app import build_app_plain
 from tests.fixtures.entities import build_workplace, create_user
@@ -2040,4 +2042,49 @@ async def test_sort(
         }
 
 
+class TestValidators:
+    async def test_field_validator(self):
+        class UserSchemaWithValidator(BaseModel):
+            name: str
+
+            @validator("name")
+            def validate_name(cls, v):
+                # checks that cls arg is not bound to the origin class
+                assert cls is not UserSchemaWithValidator
+
+                raise BadRequest(detail="Check validator")
+
+            class Config:
+                orm_mode = True
+
+        resource_type = "user"
+        app = build_app_custom(
+            model=User,
+            schema=UserSchemaWithValidator,
+            schema_in_post=UserSchemaWithValidator,
+            schema_in_patch=UserSchemaWithValidator,
+            resource_type=resource_type,
+        )
+
+        attrs = {"name": fake.name()}
+        create_user_body = {"data": {"attributes": attrs}}
+
+        async with AsyncClient(app=app, base_url="http://test") as client:
+            url = app.url_path_for(f"get_{resource_type}_list")
+            res = await client.post(url, json=create_user_body)
+            assert res.status_code == status.HTTP_400_BAD_REQUEST, res.text
+            assert res.json() == {
+                "detail": {
+                    "errors": [
+                        {
+                            "detail": "Check validator",
+                            "source": {"pointer": ""},
+                            "status_code": 400,
+                            "title": "Bad Request",
+                        },
+                    ],
+                },
+            }
+
+
 # todo: test errors