fastapi-basekit 0.5.2__tar.gz → 0.5.3__tar.gz

{fastapi_basekit-0.5.2 → fastapi_basekit-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-basekit
-Version: 0.5.2
+Version: 0.5.3
 Summary: Utilities and base classes for FastAPI async projects (Beanie, SQLAlchemy or SQLModel)
 Author-email: Jerson Moreno <jerson.ml820@hotmail.com>
 License: MIT

{fastapi_basekit-0.5.2 → fastapi_basekit-0.5.3}/fastapi_basekit/aio/controller/base.py

@@ -264,13 +264,33 @@ class BaseController:
         # raw value when the schema doesn't fit (custom-action endpoints
         # often return ad-hoc dicts that don't match the controller's
         # default schema_class — those should pass through untouched).
-        if isinstance(data, list):
-            data_dicts = [self.to_dict(item) for item in data]
-            try:
-                adapter = TypeAdapter(List[schema])
-                data_parsed = adapter.validate_python(data_dicts)
-            except Exception:
-                data_parsed = data_dicts
+        #
+        # Cuando un endpoint custom ya devuelve un modelo Pydantic específico
+        # (distinto a ``schema``), no lo re-casteeamos al schema por defecto:
+        # eso rompe el ``response_model`` declarado en la ruta y provoca
+        # ResponseValidationError. Se convierte a dict limpio y FastAPI se
+        # encarga de validar/serializar contra el response_model del endpoint.
+        if isinstance(data, BaseModel):
+            if isinstance(data, schema):
+                data_parsed = data
+            else:
+                data_parsed = self.to_dict(data)
+
+        elif isinstance(data, list):
+            # Si la lista contiene modelos Pydantic distintos al schema por
+            # defecto, respetarlos; de lo contrario validar normalmente.
+            if data and all(
+                isinstance(item, BaseModel) and not isinstance(item, schema)
+                for item in data
+            ):
+                data_parsed = [self.to_dict(item) for item in data]
+            else:
+                data_dicts = [self.to_dict(item) for item in data]
+                try:
+                    adapter = TypeAdapter(List[schema])
+                    data_parsed = adapter.validate_python(data_dicts)
+                except Exception:
+                    data_parsed = data_dicts
 
         elif isinstance(data, dict):
             try:

{fastapi_basekit-0.5.2 → fastapi_basekit-0.5.3}/fastapi_basekit/exceptions/handler.py

@@ -5,6 +5,34 @@ from fastapi.exceptions import RequestValidationError
 from fastapi.responses import JSONResponse
 from pydantic import ValidationError
 
+
+def _get_cors_headers(request: Request) -> Dict[str, str]:
+    """Extrae headers CORS del ``Origin`` del request para respuestas de error.
+
+    Cuando una respuesta se genera desde un handler que corre debajo del
+    CORSMiddleware los headers CORS se agregan automáticamente.  Pero si la
+    respuesta se genera desde ServerErrorMiddleware (por encima de CORS) o
+    desde cualquier otro camino que no pase por el middleware, los headers
+    faltan y el browser reporta un falso error CORS.  Esta función permite
+    agregarlos defensivamente desde cualquier handler.
+    """
+    origin = request.headers.get("origin")
+    if not origin:
+        return {}
+    return {
+        "Access-Control-Allow-Origin": origin,
+        "Access-Control-Allow-Credentials": "true",
+        "Vary": "Origin",
+    }
+
+
+def _apply_cors(request: Request, response: JSONResponse) -> JSONResponse:
+    """Agrega headers CORS defensivos a una ``JSONResponse``."""
+    headers = _get_cors_headers(request)
+    if headers:
+        response.headers.update(headers)
+    return response
+
 try:  # pragma: no cover - dependencia opcional
     from pymongo.errors import DuplicateKeyError  # type: ignore
 except ImportError:  # pragma: no cover
@@ -35,7 +63,10 @@ async def api_exception_handler(request: Request, exc: APIException):
     response = BaseResponse(
         status=exc.status_code, message=exc.message, data=exc.data
     )
-    return JSONResponse(status_code=exc.status, content=response.model_dump())
+    return _apply_cors(
+        request,
+        JSONResponse(status_code=exc.status, content=response.model_dump()),
+    )
 
 
 async def domain_error_handler(request: Request, exc: DomainError):
@@ -46,8 +77,11 @@ async def domain_error_handler(request: Request, exc: DomainError):
     a `exc.http_status()` con el mismo envelope `BaseResponse` que el resto.
     """
     response = BaseResponse(status=exc.code, message=exc.message, data=None)
-    return JSONResponse(
-        status_code=exc.http_status(), content=response.model_dump()
+    return _apply_cors(
+        request,
+        JSONResponse(
+            status_code=exc.http_status(), content=response.model_dump()
+        ),
     )
 
 
@@ -81,9 +115,12 @@ async def document_not_found_handler(request: Request, exc: DocumentNotFound):
         message="Documento no encontrado",
         data={"detail": str(exc)},
     )
-    return JSONResponse(
-        status_code=status.HTTP_404_NOT_FOUND,
-        content=response.model_dump(),
+    return _apply_cors(
+        request,
+        JSONResponse(
+            status_code=status.HTTP_404_NOT_FOUND,
+            content=response.model_dump(),
+        ),
     )
 
 
@@ -96,9 +133,12 @@ async def global_exception_handler(request: Request, exc: Exception):
         message="Ocurrió un error desconocido",
         data={"detail": str(exc)},
     )
-    return JSONResponse(
-        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-        content=response.model_dump(),
+    return _apply_cors(
+        request,
+        JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content=response.model_dump(),
+        ),
     )
 
 
@@ -119,9 +159,12 @@ async def value_exception_handler(
         data=str(error_details),
     )
 
-    return JSONResponse(
-        status_code=status.HTTP_400_BAD_REQUEST,
-        content=response.model_dump(mode="json"),
+    return _apply_cors(
+        request,
+        JSONResponse(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            content=response.model_dump(mode="json"),
+        ),
     )
 
 
@@ -139,9 +182,12 @@ async def request_validation_handler(
         message="Error de validación",
         data=exc.errors(),
     )
-    return JSONResponse(
-        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-        content=response.model_dump(mode="json"),
+    return _apply_cors(
+        request,
+        JSONResponse(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            content=response.model_dump(mode="json"),
+        ),
     )
 
 
@@ -153,9 +199,12 @@ async def integrity_error_handler(request: Request, exc: Exception):
         message="Registro ya existe o viola una restricción de integridad",
         data={"detail": str(detail) if detail is not None else str(exc)},
     )
-    return JSONResponse(
-        status_code=status.HTTP_400_BAD_REQUEST,
-        content=response.model_dump(mode="json"),
+    return _apply_cors(
+        request,
+        JSONResponse(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            content=response.model_dump(mode="json"),
+        ),
     )
 
 

{fastapi_basekit-0.5.2 → fastapi_basekit-0.5.3}/fastapi_basekit/templates/project/{{cookiecutter.project_slug}}/app/utils/exception_handlers.py

@@ -10,6 +10,7 @@ from fastapi_basekit.exceptions.api_exceptions import (
     DatabaseIntegrityException,
     ValidationException,
 )
+from fastapi_basekit.exceptions.handler import _apply_cors  # noqa: F401
 from fastapi_basekit.schema.base import BaseResponse
 from pydantic import ValidationError
 {% if cookiecutter.orm == "sqlalchemy" -%}
@@ -19,7 +20,10 @@ from sqlalchemy.exc import IntegrityError
 
 async def api_exception_handler(request: Request, exc: APIException):
     response = BaseResponse(status=exc.status_code, message=exc.message, data=exc.data)
-    return JSONResponse(status_code=exc.status, content=response.model_dump())
+    return _apply_cors(
+        request,
+        JSONResponse(status_code=exc.status, content=response.model_dump()),
+    )
 
 
 async def validation_exception_handler(request: Request, exc: RequestValidationError):
@@ -28,7 +32,10 @@ async def validation_exception_handler(request: Request, exc: RequestValidationE
 
 async def database_exception_handler(request: Request, exc: DatabaseIntegrityException):
     response = BaseResponse(status=exc.status_code, message=exc.message, data=exc.data)
-    return JSONResponse(status_code=exc.status, content=response.model_dump())
+    return _apply_cors(
+        request,
+        JSONResponse(status_code=exc.status, content=response.model_dump()),
+    )
 
 
 async def value_exception_handler(request: Request, exc: Union[ValidationError, ValueError]):
@@ -42,9 +49,12 @@ async def value_exception_handler(request: Request, exc: Union[ValidationError,
         message="Field validation error",
         data=str(error_details),
     )
-    return JSONResponse(
-        status_code=status.HTTP_400_BAD_REQUEST,
-        content=response.model_dump(mode="json"),
+    return _apply_cors(
+        request,
+        JSONResponse(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            content=response.model_dump(mode="json"),
+        ),
     )
 
 
@@ -65,9 +75,12 @@ async def integrity_error_handler(request: Request, exc: IntegrityError):
         message = "Database integrity error"
 
     response = BaseResponse(status="DATABASE_INTEGRITY_ERROR", message=message, data=None)
-    return JSONResponse(
-        status_code=status.HTTP_400_BAD_REQUEST,
-        content=response.model_dump(),
+    return _apply_cors(
+        request,
+        JSONResponse(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            content=response.model_dump(),
+        ),
     )
 {% endif %}
 
@@ -78,7 +91,10 @@ async def global_exception_handler(request: Request, exc: Exception):
         message="Unknown error",
         data={"detail": str(exc)},
     )
-    return JSONResponse(
-        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-        content=response.model_dump(),
+    return _apply_cors(
+        request,
+        JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content=response.model_dump(),
+        ),
     )

{fastapi_basekit-0.5.2 → fastapi_basekit-0.5.3}/fastapi_basekit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-basekit
-Version: 0.5.2
+Version: 0.5.3
 Summary: Utilities and base classes for FastAPI async projects (Beanie, SQLAlchemy or SQLModel)
 Author-email: Jerson Moreno <jerson.ml820@hotmail.com>
 License: MIT

{fastapi_basekit-0.5.2 → fastapi_basekit-0.5.3}/fastapi_basekit.egg-info/SOURCES.txt

@@ -121,6 +121,7 @@ tests/test_crud_controller.py
 tests/test_crud_sqlmodel_repository_service.py
 tests/test_exception_handlers.py
 tests/test_filter_operators.py
+tests/test_format_response_schema_override.py
 tests/test_generics_optional_and_cache.py
 tests/test_generics_wiring.py
 tests/test_jwt_config_robustness.py

{fastapi_basekit-0.5.2 → fastapi_basekit-0.5.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fastapi-basekit"
-version = "0.5.2"
+version = "0.5.3"
 description = "Utilities and base classes for FastAPI async projects (Beanie, SQLAlchemy or SQLModel)"
 readme = "README.md"
 requires-python = ">=3.11"

{fastapi_basekit-0.5.2 → fastapi_basekit-0.5.3}/tests/test_exception_handlers.py

@@ -39,6 +39,10 @@ def client():
         # code sin mapeo → DEFAULT_STATUS (400)
         raise DomainError("SOMETHING", "algo pasó")
 
+    @app.get("/boom-generic")
+    async def boom_generic():
+        raise RuntimeError("error inesperado")
+
     @app.post("/echo")
     async def echo(body: Body):
         return {"n": body.n}
@@ -83,3 +87,16 @@ def test_domain_error_default_status(client):
     r = client.get("/boom-domain-default")
     assert r.status_code == 400  # DEFAULT_STATUS
     assert r.json()["status"] == "SOMETHING"
+
+
+def test_cors_headers_injected_on_error(client):
+    """Todas las respuestas de error incluyen headers CORS cuando el request
+    tiene un header ``Origin`` (defensa en profundidad)."""
+    r = client.get(
+        "/boom-generic",
+        headers={"Origin": "https://app.example.com"},
+    )
+    assert r.status_code == 500
+    assert r.headers.get("Access-Control-Allow-Origin") == "https://app.example.com"
+    assert r.headers.get("Access-Control-Allow-Credentials") == "true"
+    assert r.headers.get("Vary") == "Origin"

fastapi_basekit-0.5.3/tests/test_format_response_schema_override.py

@@ -0,0 +1,79 @@
+"""Regresión: format_response no debe re-castear modelos Pydantic específicos
+a ``schema_class`` cuando un endpoint custom devuelve otro schema."""
+
+import pytest
+from pydantic import BaseModel
+
+from fastapi_basekit.aio.controller.base import BaseController
+
+
+class _DefaultSchema(BaseModel):
+    id: int
+    name: str
+
+
+class _OtherSchema(BaseModel):
+    ok: bool
+    status: str
+
+
+class _Controller(BaseController):
+    schema_class = _DefaultSchema
+
+
+@pytest.fixture
+def controller():
+    return _Controller()
+
+
+def test_format_response_respects_other_pydantic_model(controller):
+    """Un endpoint custom que devuelve otro schema no debe romperse al forzar
+    ``schema_class`` (GatewayCheckoutResponseSchema vs GatewayChargeResponseSchema)."""
+    other = _OtherSchema(ok=True, status="paid")
+    resp = controller.format_response(other, message="OK")
+
+    # Se convierte a dict limpio y se deja pasar; FastAPI validará contra
+    # el response_model declarado en la ruta.
+    assert resp.data == {"ok": True, "status": "paid"}
+    assert isinstance(resp.data, dict)
+    assert resp.message == "OK"
+
+
+def test_format_response_keeps_default_model_instance(controller):
+    """Si ``data`` ya es instancia de ``schema_class``, se usa tal cual."""
+    item = _DefaultSchema(id=1, name="foo")
+    resp = controller.format_response(item)
+
+    assert resp.data is item
+
+
+def test_format_response_validates_plain_dict(controller):
+    """Los dicts planos siguen validándose contra ``schema_class``."""
+    resp = controller.format_response({"id": 2, "name": "bar"})
+
+    assert isinstance(resp.data, _DefaultSchema)
+    assert resp.data.id == 2
+    assert resp.data.name == "bar"
+
+
+def test_format_response_list_of_other_models(controller):
+    """Una lista de modelos Pydantic distintos a ``schema_class`` se respeta."""
+    items = [
+        _OtherSchema(ok=True, status="paid"),
+        _OtherSchema(ok=False, status="failed"),
+    ]
+    resp = controller.format_response(items)
+
+    assert resp.data == [
+        {"ok": True, "status": "paid"},
+        {"ok": False, "status": "failed"},
+    ]
+
+
+def test_format_response_list_of_dicts_still_validates(controller):
+    """Una lista de dicts sigue validándose contra ``List[schema_class]``."""
+    resp = controller.format_response([{"id": 3, "name": "baz"}])
+
+    assert isinstance(resp.data, list)
+    assert isinstance(resp.data[0], _DefaultSchema)
+    assert resp.data[0].id == 3