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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-basekit
-Version: 0.5.2
+Version: 0.5.4
 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.4}/fastapi_basekit/aio/beanie/repository/base.py

@@ -119,75 +119,60 @@ class BaseRepository(Generic[ModelT]):
             kwargs["projection"] = projection
         return kwargs
 
-    def build_filter_query(
-        self,
-        search: Optional[str],
-        search_fields: List[str],
-        filters: dict = None,
-        order_by: Optional[List[tuple]] = None,
-        **kwargs,
-    ) -> FindMany[Document]:
-        """Versión personalizada que soporta campos Link."""
-        exprs = []
-
-        if search and search_fields:
-            exprs.append(
-                Or(
-                    *[
-                        RegEx(
-                            getattr(self.model, f),
-                            f".*{search}.*",
-                            options="i",
-                        )
-                        for f in search_fields
-                    ]
-                )
-            )
-
-        # Obtener campos del modelo
+    def _is_link_field(self, field_name: str) -> bool:
+        """Verifica si un campo del modelo es de tipo Link (o Optional[Link])."""
         model_fields = (
             self.model.model_fields
             if hasattr(self.model, "model_fields")
             else {}
         )
+        field_info = model_fields.get(field_name)
+        if not field_info:
+            return False
 
-        def _is_link_field(field_name: str) -> bool:
-            """Verifica si un campo es de tipo Link."""
-            field_info = model_fields.get(field_name)
-            if not field_info:
-                return False
-
-            field_type = field_info.annotation
-            origin = get_origin(field_type)
-
-            # Caso directo: Link[Model]
-            if origin is Link:
-                return True
-
-            # Caso Optional[Link[Model]] = Union[Link[Model], None]
-            # O cualquier Union que contenga Link
-            if origin is not None:
-                args = get_args(field_type)
-                for arg in args:
-                    # Verificar si el argumento es Link
-                    arg_origin = get_origin(arg)
-                    if arg_origin is Link:
-                        return True
+        field_type = field_info.annotation
+        origin = get_origin(field_type)
 
-            return False
+        # Caso directo: Link[Model]
+        if origin is Link:
+            return True
 
-        raw_filters: Dict[str, Any] = {}
+        # Caso Optional[Link[Model]] = Union[Link[Model], None]
+        # O cualquier Union que contenga Link
+        if origin is not None:
+            args = get_args(field_type)
+            for arg in args:
+                arg_origin = get_origin(arg)
+                if arg_origin is Link:
+                    return True
 
-        def _coerce_objectid(value: Any) -> Any:
-            """str/UUID → ObjectId para queries Mongo sobre Link.id."""
-            if isinstance(value, ObjectId):
-                return value
-            if isinstance(value, str):
-                try:
-                    return ObjectId(value)
-                except Exception:
-                    return value
+        return False
+
+    @staticmethod
+    def _coerce_objectid(value: Any) -> Any:
+        """str/UUID → ObjectId para queries Mongo sobre Link.id."""
+        if isinstance(value, ObjectId):
             return value
+        if isinstance(value, str):
+            try:
+                return ObjectId(value)
+            except Exception:
+                return value
+        return value
+
+    def _resolve_filter_query_args(self, filters: dict = None) -> list:
+        """Traduce un dict de `get_filters()` a los args posicionales que
+        acepta `Model.find()`/`Model.find_one()` — resuelve campos Link
+        (directos y el alias `<field>_id`), pasa claves Mongo crudas
+        (`"user.$id"`, `"$or"`, ...) como dict, y avisa (no falla en
+        silencio) si una clave no resuelve a nada del modelo.
+
+        Compartido por `build_filter_query` (listados) y `get_by_id`
+        (retrieve/update/delete escopeados) — mismo motor de resolución de
+        filtros para las dos rutas, así un `get_filters()` de seguridad
+        protege ambas por igual."""
+        exprs: list = []
+        raw_filters: Dict[str, Any] = {}
 
         for k, v in (filters or {}).items():
             # MongoDB-style keys (dot-notation like "user.$id" or operators like "$or")
@@ -198,8 +183,8 @@ class BaseRepository(Generic[ModelT]):
 
             if hasattr(self.model, k):
                 field_attr = getattr(self.model, k)
-                if _is_link_field(k):
-                    exprs.append(field_attr.id == _coerce_objectid(v))
+                if self._is_link_field(k):
+                    exprs.append(field_attr.id == self._coerce_objectid(v))
                 else:
                     exprs.append(field_attr == v)
                 continue
@@ -210,32 +195,59 @@ class BaseRepository(Generic[ModelT]):
             # el modelo y es un Link[X].
             if k.endswith("_id"):
                 base = k[:-3]
-                if hasattr(self.model, base) and _is_link_field(base):
+                if hasattr(self.model, base) and self._is_link_field(base):
                     field_attr = getattr(self.model, base)
-                    exprs.append(field_attr.id == _coerce_objectid(v))
+                    exprs.append(field_attr.id == self._coerce_objectid(v))
                     continue
 
             # Clave no resoluble (typo, campo inexistente, nesting mal escrito).
             # Se descarta — pero se AVISA: si la clave venía de `get_filters`
             # (scoping por tenant/owner), su desaparición silenciosa deja el
-            # listado sin filtrar → fuga cross-tenant (IDOR). El warning hace
-            # visible la pérdida en logs/Sentry en vez de fallar en silencio.
+            # listado/retrieve SIN ese filtro. El warning hace visible la
+            # pérdida en logs/Sentry en vez de fallar en silencio.
             logger.warning(
-                "build_filter_query: filtro '%s' descartado (no resuelve a "
-                "ningún campo de %s). Si era un filtro de scoping, el listado "
-                "queda SIN ese filtro.",
+                "_resolve_filter_query_args: filtro '%s' descartado (no "
+                "resuelve a ningún campo de %s). Si era un filtro de "
+                "scoping, la query queda SIN ese filtro.",
                 k,
                 getattr(self.model, "__name__", self.model),
             )
 
         # Raw MongoDB filters go first so Beanie processes them as a dict condition
-        query_args: list = ([raw_filters] if raw_filters else []) + exprs
+        return ([raw_filters] if raw_filters else []) + exprs
+
+    def build_filter_query(
+        self,
+        search: Optional[str],
+        search_fields: List[str],
+        filters: dict = None,
+        order_by: Optional[List[tuple]] = None,
+        **kwargs,
+    ) -> FindMany[Document]:
+        """Versión personalizada que soporta campos Link."""
+        exprs = []
+
+        if search and search_fields:
+            exprs.append(
+                Or(
+                    *[
+                        RegEx(
+                            getattr(self.model, f),
+                            f".*{search}.*",
+                            options="i",
+                        )
+                        for f in search_fields
+                    ]
+                )
+            )
+
+        query_args: list = exprs + self._resolve_filter_query_args(filters)
         query = self.model.find(*query_args, **self._get_query_kwargs(**kwargs))
-        
+
         # Apply ordering if provided
         if order_by:
             query = query.sort(order_by)
-        
+
         return query
 
     async def paginate(
@@ -521,10 +533,40 @@ class BaseRepository(Generic[ModelT]):
     async def get_by_id(
         self,
         obj_id: Union[str, ObjectId],
+        filters: Optional[Dict[str, Any]] = None,
         **kwargs,
     ) -> Optional[ModelT]:
+        """`filters` (opcional) — scoping de seguridad (típicamente
+        `Service.get_filters()`, ej. `{"user.$id": request.state.user.id}`).
+        Sin `filters`, comportamiento idéntico a antes (busca por id, sin
+        scope) — 100% retrocompatible. Con `filters`, un id que existe pero
+        no matchea el scope devuelve `None` (mismo resultado que "no
+        encontrado"), cerrando la clase de IDOR de "conozco el id de otro
+        tenant y lo pido directo".
+
+        El chequeo de scope corre SIEMPRE con `fetch_links=False` (find_one
+        plano, sobre el documento crudo — DBRef sin resolver), sea cual sea
+        el `fetch_links` que pida el caller para el fetch final. Motivo:
+        Beanie reescribe `find(..., fetch_links=True)` a una aggregation con
+        `$lookup`, y un filtro con notación de punto (`"user.$id"`,
+        `"user._id"`, etc.) puede matchear distinto — o no matchear nada —
+        según si corre ANTES o DESPUÉS del `$lookup` (mismo bug ya
+        documentado en `find_all_production_for_user` de pulbot-backend:
+        "fetch_links=True puede descartar resultados silenciosamente al
+        filtrar por campos dict anidados"). Combinar scope-filter +
+        fetch_links en una sola query es frágil; separarlos lo hace
+        determinístico sin importar qué `get_filters()` use cada service."""
         if not isinstance(obj_id, ObjectId):
             obj_id = ObjectId(obj_id)
+
+        if filters:
+            scope_exprs = self._resolve_filter_query_args(filters)
+            scoped = await self.model.find_one(
+                self.model.id == obj_id, *scope_exprs, fetch_links=False
+            )
+            if not scoped:
+                return None
+
         return await self.model.find_one(
             self.model.id == obj_id,
             **self._get_query_kwargs(**kwargs),

{fastapi_basekit-0.5.2 → fastapi_basekit-0.5.4}/fastapi_basekit/aio/beanie/service/base.py

@@ -82,9 +82,43 @@ class BaseService(Generic[ModelT]):
         filters = filters or {}
         return filters
 
+    def owner_filter(self, field: str, value: Any) -> Dict[str, Any]:
+        """Filtro de scoping por un campo `Link` (ej. ownership por
+        `user`), correcto tanto en `list()` como en `retrieve`/`update`/
+        `delete` — sin que el service tenga que conocer por qué la clave
+        Mongo cambia entre esos dos caminos.
+
+        Por qué existen dos claves para "lo mismo": un campo `Link[User]`
+        se guarda como DBRef (`{"$ref": "users", "$id": ObjectId(...)}`).
+        - `retrieve`/`update`/`delete` van por `get_by_id`, que SIEMPRE
+          resuelve el scope con `fetch_links=False` (`find_one` plano sobre
+          el documento crudo) — ahí el DBRef está intacto, la clave correcta
+          es `"<field>.$id"`.
+        - `list()` (y cualquier action cuyo `get_kwargs_query()` pida
+          `fetch_links=True`) corre `Model.find(..., fetch_links=True)`,
+          que Beanie reescribe a una aggregation con `$lookup` — ahí el
+          `$lookup` REEMPLAZA el DBRef por el subdocumento resuelto, así
+          que la clave correcta pasa a ser `"<field>._id"`.
+        Usar la clave equivocada no tira error — devuelve 0 resultados en
+        silencio (bug real ya encontrado usando esto a mano en
+        `ToolService` de pulbot-backend, 2026-08-11). Este helper decide
+        por vos: usalo en vez de escribir `"<field>.$id"`/`"<field>._id"`
+        directo en tu `get_filters()`.
+
+        ⚠️ Asume que tu action de lectura-por-id (`retrieve`/`update`/
+        `delete`) no fuerza `fetch_links=True` en el PROPIO chequeo de
+        scope — así es como quedó `get_by_id` del repo (siempre
+        `fetch_links=False` para el scope-check, independientemente del
+        `fetch_links` que pidas para el fetch final). Si tu repo está
+        parcheado para saltarse eso, este helper no aplica."""
+        suffix = "._id" if self.action == "list" else ".$id"
+        return {f"{field}{suffix}": value}
+
     async def retrieve(self, id: str) -> ModelT:
         kwargs = self.get_kwargs_query()
-        obj = await self.repository.get_by_id(id, **kwargs)
+        obj = await self.repository.get_by_id(
+            id, filters=self.get_filters(), **kwargs
+        )
         if not obj:
             raise NotFoundException(f"id={id} no encontrado")
         return obj
@@ -241,7 +275,9 @@ class BaseService(Generic[ModelT]):
 
     async def update(self, id: str, data: BaseModel) -> ModelT:
         kwargs = self.get_kwargs_query()
-        obj = await self.repository.get_by_id(id, **kwargs)
+        obj = await self.repository.get_by_id(
+            id, filters=self.get_filters(), **kwargs
+        )
         if not obj:
             raise NotFoundException(f"id={id} no encontrado")
         if isinstance(data, BaseModel):
@@ -250,7 +286,7 @@ class BaseService(Generic[ModelT]):
         return updated
 
     async def delete(self, id: str) -> str:
-        obj = await self.repository.get_by_id(id)
+        obj = await self.repository.get_by_id(id, filters=self.get_filters())
         if not obj:
             raise NotFoundException(f"id={id} no encontrado")
         await self.repository.delete(obj)

{fastapi_basekit-0.5.2 → fastapi_basekit-0.5.4}/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.4}/fastapi_basekit/aio/sqlalchemy/repository/base.py

@@ -487,16 +487,37 @@ class BaseRepository(Generic[ModelT]):
 
         return record
 
-    async def get(self, record_id: Union[str, UUID]) -> Optional[ModelT]:
-        """Obtiene un registro por su ID."""
+    async def get(
+        self,
+        record_id: Union[str, UUID],
+        filters: Optional[Dict[str, Any]] = None,
+    ) -> Optional[ModelT]:
+        """Obtiene un registro por su ID.
+
+        `filters` (opcional) — scoping de seguridad (típicamente
+        `Service.get_filters()`). Sin `filters`, usa `session.get()` (fast
+        path por PK) — comportamiento idéntico a antes, 100% retrocompatible.
+        Con `filters`, cae a un `SELECT ... WHERE id = :id AND <filtros>` —
+        un id que existe pero no matchea el scope devuelve `None` (mismo
+        resultado que "no encontrado"), cerrando la clase de IDOR de "conozco
+        el id de otro tenant y lo pido directo"."""
         if not self.model:
             raise ValueError("El modelo no está definido en el repositorio")
-        return await self.session.get(self.model, record_id)
+        if not filters:
+            return await self.session.get(self.model, record_id)
+        conditions = [self.model.id == record_id] + self._build_conditions(
+            filters=filters
+        )
+        return await self._get_one(conditions=conditions)
 
-    async def get_by_id(self, record_id: Union[str, UUID]) -> Optional[ModelT]:
+    async def get_by_id(
+        self,
+        record_id: Union[str, UUID],
+        filters: Optional[Dict[str, Any]] = None,
+    ) -> Optional[ModelT]:
         """Alias de `get(id)` — nombre unificado con el repo Beanie
         (`get_by_id`) para que las lecturas por id sean portables entre ORMs."""
-        return await self.get(record_id)
+        return await self.get(record_id, filters=filters)
 
     async def get_by_field(
         self, field_name: str, value: Any
@@ -509,11 +530,15 @@ class BaseRepository(Generic[ModelT]):
         self,
         record_id: Union[str, UUID],
         joins: Optional[List[str]] = None,
+        filters: Optional[Dict[str, Any]] = None,
     ) -> Optional[ModelT]:
-        """Obtiene un registro por ID y carga relaciones dinámicamente."""
-        return await self._get_one(
-            conditions=[self.model.id == record_id], joins=joins
-        )
+        """Obtiene un registro por ID y carga relaciones dinámicamente.
+
+        `filters` (opcional) — mismo scoping de seguridad que `get()`."""
+        conditions = [self.model.id == record_id]
+        if filters:
+            conditions.extend(self._build_conditions(filters=filters))
+        return await self._get_one(conditions=conditions, joins=joins)
 
     async def get_by_field_with_joins(
         self,

{fastapi_basekit-0.5.2 → fastapi_basekit-0.5.4}/fastapi_basekit/aio/sqlalchemy/service/base.py

@@ -122,9 +122,10 @@ class BaseService(Generic[ModelT]):
         if joins is None:
             joins = kwargs.get("joins")
 
-        obj = await self.repository.get_with_joins(id, joins=joins)
+        filters = self.get_filters()
+        obj = await self.repository.get_with_joins(id, joins=joins, filters=filters)
         if not obj:
-            obj = await self.repository.get(id)
+            obj = await self.repository.get(id, filters=filters)
         if not obj:
             raise NotFoundException(f"id={id} no encontrado")
         return obj
@@ -227,6 +228,12 @@ class BaseService(Generic[ModelT]):
         return created
 
     async def update(self, id: str, data: BaseModel | Dict[str, Any]) -> ModelT:
+        # Scoping de seguridad ANTES de tocar nada — `repository.update`
+        # fetchea por PK cruda internamente (sin `get_filters()`), así que
+        # sin este check un id de otro tenant se podía editar directo.
+        scoped = await self.repository.get(id, filters=self.get_filters())
+        if not scoped:
+            raise NotFoundException(f"id={id} no encontrado")
         update_data = (
             data.model_dump(exclude_unset=True)
             if isinstance(data, BaseModel)
@@ -277,7 +284,7 @@ class BaseService(Generic[ModelT]):
         return True
 
     async def delete(self, id: str) -> bool:
-        obj = await self.repository.get(id)
+        obj = await self.repository.get(id, filters=self.get_filters())
         if not obj:
             raise NotFoundException(message=f"id={id} no encontrado")
         return await self.apply_delete(obj)

{fastapi_basekit-0.5.2 → fastapi_basekit-0.5.4}/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.4}/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(),
+        ),
     )