fastapi-basekit 0.3.3__tar.gz → 0.4.0__tar.gz

{fastapi_basekit-0.3.3 → fastapi_basekit-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-basekit
-Version: 0.3.3
+Version: 0.4.0
 Summary: Utilities and base classes for FastAPI async projects (Beanie, SQLAlchemy or SQLModel)
 Author-email: Jerson Moreno <jerson.ml820@hotmail.com>
 License: MIT
@@ -105,13 +105,25 @@ Abre http://localhost:8000/docs. Login con `admin@example.com` / `ChangeMe2026!`
 
 ## Como plugin de Claude Code
 
+Dentro de Claude Code (terminal) corre:
+
 ```bash
-/plugin marketplace add https://github.com/mundobien2025/fastapi-basekit
-/plugin install fastapi-basekit
-/plugin list
+/plugin marketplace add mundobien2025/fastapi-basekit
+/plugin install fastapi-basekit@fastapi-basekit
+/plugin list                                       # verifica instalación
 ```
 
-Luego pide: *"Crea el recurso `Invoice` con CRUD completo"* — Claude usa la skill automáticamente.
+Eso registra el marketplace `fastapi-basekit` desde el repo de GitHub e
+instala el plugin (que incluye la skill `fastapi-basekit-crud`). Luego
+pide: *"Crea el recurso `Invoice` con CRUD completo siguiendo
+fastapi-basekit"* — Claude detecta la skill y aplica el patrón canónico
+(model → repo → service → schema → controller con `@cbv`).
+
+Para actualizar a una versión nueva:
+
+```bash
+/plugin update fastapi-basekit@fastapi-basekit
+```
 
 ## Instalación por ORM
 
@@ -127,8 +139,6 @@ pip install fastapi-basekit[all]          # todo
 
 PRs bienvenidos. Setup local en [docs/contributing](https://mundobien2025.github.io/fastapi-basekit/contributing).
 
-Mantenedores: [`RELEASING.md`](./RELEASING.md) tiene release flow, CI/CD, mike y troubleshooting.
-
 ## Licencia
 
 [MIT](./LICENSE) — © Jerson Moreno

{fastapi_basekit-0.3.3 → fastapi_basekit-0.4.0}/README.md

@@ -59,13 +59,25 @@ Abre http://localhost:8000/docs. Login con `admin@example.com` / `ChangeMe2026!`
 
 ## Como plugin de Claude Code
 
+Dentro de Claude Code (terminal) corre:
+
 ```bash
-/plugin marketplace add https://github.com/mundobien2025/fastapi-basekit
-/plugin install fastapi-basekit
-/plugin list
+/plugin marketplace add mundobien2025/fastapi-basekit
+/plugin install fastapi-basekit@fastapi-basekit
+/plugin list                                       # verifica instalación
 ```
 
-Luego pide: *"Crea el recurso `Invoice` con CRUD completo"* — Claude usa la skill automáticamente.
+Eso registra el marketplace `fastapi-basekit` desde el repo de GitHub e
+instala el plugin (que incluye la skill `fastapi-basekit-crud`). Luego
+pide: *"Crea el recurso `Invoice` con CRUD completo siguiendo
+fastapi-basekit"* — Claude detecta la skill y aplica el patrón canónico
+(model → repo → service → schema → controller con `@cbv`).
+
+Para actualizar a una versión nueva:
+
+```bash
+/plugin update fastapi-basekit@fastapi-basekit
+```
 
 ## Instalación por ORM
 
@@ -81,8 +93,6 @@ pip install fastapi-basekit[all]          # todo
 
 PRs bienvenidos. Setup local en [docs/contributing](https://mundobien2025.github.io/fastapi-basekit/contributing).
 
-Mantenedores: [`RELEASING.md`](./RELEASING.md) tiene release flow, CI/CD, mike y troubleshooting.
-
 ## Licencia
 
 [MIT](./LICENSE) — © Jerson Moreno

{fastapi_basekit-0.3.3 → fastapi_basekit-0.4.0}/fastapi_basekit/aio/controller/base.py

@@ -18,7 +18,11 @@ class BaseController:
     # DRF Style: Permisos globales por defecto
     permission_classes: ClassVar[List[Type[BasePermission]]] = []
 
-    action: Optional[str] = None
+    # ClassVar so cbv (fastapi-restful) does NOT promote it to a query param.
+    # A plain `Optional[str]` annotation here leaks a spurious `action` query
+    # parameter onto every mounted endpoint. `prepare_action` still assigns
+    # `self.action` (instance attr) at runtime, which works fine.
+    action: ClassVar[Optional[str]] = None
     request: Request
     _params_excluded_fields: ClassVar[Set[str]] = {
         "self",
@@ -26,6 +30,7 @@ class BaseController:
         "count",
         "search",
         "order_by",
+        "action",
         "__class__",
         "args",
         "kwargs",
@@ -66,6 +71,17 @@ class BaseController:
             return
         self.action = action_name
         self._basekit_prepared_action = action_name
+        # Propagate the canonical CRUD action ("list"/"retrieve"/...) to the
+        # service so `get_kwargs_query` / `get_filters` can branch on it. The
+        # service's own constructor derives `action` from the endpoint
+        # function name (e.g. "list_users"), which is unreliable for that
+        # purpose; the controller knows the canonical action.
+        service = getattr(self, "service", None)
+        if service is not None:
+            try:
+                service.action = action_name
+            except Exception:
+                pass
         await self.check_permissions()
 
     async def check_permissions(self):
@@ -257,7 +273,10 @@ class BaseController:
                 search = final_value
             elif param_name == "order_by":
                 order_by = final_value
-            elif param_name not in standard_params:
+            elif (
+                param_name not in standard_params
+                and param_name not in self._params_excluded_fields
+            ):
                 # Es un filtro
                 filters[param_name] = final_value
 

{fastapi_basekit-0.3.3 → fastapi_basekit-0.4.0}/fastapi_basekit/aio/sqlalchemy/controller/base.py

@@ -24,6 +24,7 @@ class SQLAlchemyBaseController(BaseController):
         "use_or",
         "joins",
         "order_by",
+        "action",
         "__class__",
         "args",
         "kwargs",

{fastapi_basekit-0.3.3 → fastapi_basekit-0.4.0}/fastapi_basekit/aio/sqlalchemy/repository/base.py

@@ -131,7 +131,13 @@ class BaseRepository:
         joins_to_apply = {}
 
         for filter_path, value in filters.items():
-            attr, field_joins = self._resolve_field_path(filter_path)
+            # Detect an optional trailing operator suffix (e.g.
+            # "age__gte", "created_at__lte", "name__ilike", "id__in").
+            # The remaining path is resolved normally, so relationship
+            # traversal ("user__role__code") keeps working — only a final
+            # token that matches a known operator is treated as one.
+            resolve_path, op = self._split_operator(filter_path)
+            attr, field_joins = self._resolve_field_path(resolve_path)
 
             if attr is None:
                 continue
@@ -156,10 +162,53 @@ class BaseRepository:
             )
 
             if not is_relationship and is_column:
-                resolved_filters[filter_path] = (attr, processed_value)
+                resolved_filters[filter_path] = (attr, processed_value, op)
 
         return resolved_filters, joins_to_apply
 
+    # Operadores de filtro soportados como sufijo "campo__op".
+    FILTER_OPERATORS = frozenset(
+        {"eq", "ne", "gt", "gte", "lt", "lte", "in", "like", "ilike"}
+    )
+
+    def _split_operator(self, filter_path: str) -> Tuple[str, str]:
+        """Separa un sufijo de operador del path de filtro.
+
+        "age__gte" → ("age", "gte"); "user__role__code" → (..., "eq").
+        Solo se interpreta como operador si el último token coincide con
+        ``FILTER_OPERATORS`` y queda al menos un token de campo delante.
+        """
+        if "__" in filter_path:
+            head, _, last = filter_path.rpartition("__")
+            if head and last in self.FILTER_OPERATORS:
+                return head, last
+        return filter_path, "eq"
+
+    @staticmethod
+    def _condition_for(field: Any, value: Any, op: str) -> Any:
+        """Construye la condición SQLAlchemy para un operador dado."""
+        if op == "ne":
+            return field != value
+        if op == "gt":
+            return field > value
+        if op == "gte":
+            return field >= value
+        if op == "lt":
+            return field < value
+        if op == "lte":
+            return field <= value
+        if op == "in":
+            seq = value if isinstance(value, (list, tuple, set)) else [value]
+            return field.in_(list(seq))
+        if op == "like":
+            return field.like(f"%{value}%")
+        if op == "ilike":
+            return field.ilike(f"%{value}%")
+        # op == "eq" (default): conserva la semántica IN para listas.
+        if isinstance(value, (list, tuple)) and not isinstance(value, str):
+            return field.in_(value)
+        return field == value
+
     def _resolve_order_by(
         self,
         order_by: Optional[Any] = None,
@@ -292,14 +341,13 @@ class BaseRepository:
 
         # Modo avanzado: usar resolved_filters si está disponible
         if resolved_filters is not None:
-            for _, (field, processed_value) in resolved_filters.items():
-                # Aplicar la lógica de IN o ==
-                if isinstance(
-                    processed_value, (list, tuple)
-                ) and not isinstance(processed_value, str):
-                    conditions.append(field.in_(processed_value))
-                else:
-                    conditions.append(field == processed_value)
+            for _, resolved in resolved_filters.items():
+                # Tupla (field, value) legacy o (field, value, op) con operador.
+                field, processed_value = resolved[0], resolved[1]
+                op = resolved[2] if len(resolved) > 2 else "eq"
+                conditions.append(
+                    self._condition_for(field, processed_value, op)
+                )
         # Modo legacy: compatibilidad con código existente
         elif filters is not None:
             for fn, value in filters.items():
@@ -442,8 +490,10 @@ class BaseRepository:
             if not resolved_filters:
                 return None
 
-            # Obtener el atributo resuelto
-            _, (field, processed_value) = next(iter(resolved_filters.items()))
+            # Obtener el atributo resuelto (puede traer operador como 3er elem)
+            _, resolved = next(iter(resolved_filters.items()))
+            field, processed_value = resolved[0], resolved[1]
+            op = resolved[2] if len(resolved) > 2 else "eq"
 
             # Construir query con JOINs de filtrado
             query = select(self.model)
@@ -453,7 +503,7 @@ class BaseRepository:
                 query = query.join(relation_attr)
 
             # Aplicar condición
-            query = query.where(field == processed_value)
+            query = query.where(self._condition_for(field, processed_value, op))
 
             # Aplicar joins de carga
             query = self._apply_joins(query, joins)

fastapi_basekit-0.4.0/fastapi_basekit/exceptions/__init__.py

@@ -0,0 +1,4 @@
+from fastapi_basekit.exceptions.domain import DomainError
+from fastapi_basekit.exceptions.handler import register_exception_handlers
+
+__all__ = ["DomainError", "register_exception_handlers"]

{fastapi_basekit-0.3.3 → fastapi_basekit-0.4.0}/fastapi_basekit/exceptions/handler.py

@@ -109,3 +109,89 @@ async def value_exception_handler(
         status_code=status.HTTP_400_BAD_REQUEST,
         content=response.model_dump(mode="json"),
     )
+
+
+async def request_validation_handler(
+    request: Request, exc: RequestValidationError
+):
+    """FastAPI request validation → envelope unificado (no relanza).
+
+    Equivalente a `validation_exception_handler` pero devuelve la respuesta
+    directamente, sin depender de que otro handler capture la excepción
+    relanzada. Cuerpo idéntico al que produciría `ValidationException`.
+    """
+    response = BaseResponse(
+        status="VALIDATION_ERROR",
+        message="Error de validación",
+        data=exc.errors(),
+    )
+    return JSONResponse(
+        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+        content=response.model_dump(mode="json"),
+    )
+
+
+async def integrity_error_handler(request: Request, exc: Exception):
+    """SQLAlchemy IntegrityError → envelope de integridad (HTTP 400)."""
+    detail = getattr(exc, "orig", None)
+    response = BaseResponse(
+        status="DATABASE_INTEGRITY_ERROR",
+        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"),
+    )
+
+
+def register_exception_handlers(
+    app,
+    *,
+    sqlalchemy: bool = True,
+    mongo: bool = True,
+) -> None:
+    """Registra el conjunto completo de handlers sobre una app FastAPI.
+
+    Un solo punto de cableado para que cada proyecto NO copie-pegue el
+    mapeo de excepciones → ``BaseResponse``. Todas las subclases de
+    ``APIException`` (NotFound, Permission, JWT, Validation, Integrity,
+    Global...) las atiende ``api_exception_handler`` vía resolución por MRO.
+
+    Args:
+        app: instancia FastAPI.
+        sqlalchemy: registra el handler de ``IntegrityError`` (requiere
+            SQLAlchemy instalado).
+        mongo: registra handlers de Mongo/Beanie si están disponibles.
+    """
+    app.add_exception_handler(APIException, api_exception_handler)
+    app.add_exception_handler(
+        RequestValidationError, request_validation_handler
+    )
+    app.add_exception_handler(ValidationError, value_exception_handler)
+    app.add_exception_handler(ValueError, value_exception_handler)
+
+    if sqlalchemy:
+        try:  # pragma: no cover - dependencia opcional
+            from sqlalchemy.exc import IntegrityError
+
+            app.add_exception_handler(
+                IntegrityError, integrity_error_handler
+            )
+        except ImportError:
+            pass
+
+    if mongo:
+        # Solo registra si las clases reales (no los fallbacks) existen.
+        if DuplicateKeyError.__module__ != __name__:
+            app.add_exception_handler(
+                DuplicateKeyError, duplicate_key_exception_handler
+            )
+        if DocumentNotFound.__module__ != __name__:
+            app.add_exception_handler(
+                DocumentNotFound, document_not_found_handler
+            )
+
+    # Catch-all al final; las subclases de APIException ya tienen prioridad
+    # por especificidad de tipo.
+    app.add_exception_handler(Exception, global_exception_handler)

fastapi_basekit-0.4.0/fastapi_basekit/openapi.py

@@ -0,0 +1,89 @@
+"""Helpers para limpiar el esquema OpenAPI generado.
+
+Con controllers `@cbv`, FastAPI genera ``operationId`` largos y ruidosos
+(p. ej. ``UserController_list_users_users__get``) y, según la versión de
+fastapi-restful, summaries con prefijo de clase (``UserController.list_users``).
+``simplify_openapi`` normaliza ambos sin acoplarse a nombres de recurso de un
+proyecto concreto: el ``operationId`` pasa a ser el nombre del método de ruta
+(``list_users``) y el ``summary`` se vuelve legible.
+"""
+
+import re
+from typing import Any, Callable, Dict, Optional
+
+from fastapi.openapi.utils import get_openapi
+from fastapi.routing import APIRoute
+
+# Prefijo de clase cbv en summaries con punto: "UserController.list_users".
+_CBV_DOT_PREFIX = re.compile(r"^[A-Za-z0-9_]+\.(.+)$")
+
+_HTTP_METHODS = {"get", "post", "put", "patch", "delete", "options", "head"}
+
+
+def _clean_label(value: str) -> str:
+    """Quita el prefijo de clase cbv (forma con punto) y formatea legible."""
+    match = _CBV_DOT_PREFIX.match(value)
+    tail = match.group(1) if match else value
+    return tail.replace("_", " ").strip().capitalize()
+
+
+def simplify_openapi(
+    app,
+    *,
+    title: Optional[str] = None,
+    version: Optional[str] = None,
+    description: Optional[str] = None,
+    summary_overrides: Optional[Dict[str, str]] = None,
+) -> Callable[[], Dict[str, Any]]:
+    """Instala un ``app.openapi`` con operationIds/summaries limpios.
+
+    El ``operationId`` de cada ruta pasa a ser su ``name`` (el nombre del
+    método, p. ej. ``list_users``), de modo que ``summary_overrides`` se
+    indexa por ese nombre simple.
+
+    Args:
+        app: instancia FastAPI.
+        title/version/description: overrides opcionales de metadatos.
+        summary_overrides: mapa ``operationId -> summary`` (clave = nombre de
+            método de ruta). Lo específico del proyecto vive aquí, no en la
+            librería.
+
+    Returns:
+        La función ``custom_openapi`` instalada.
+    """
+    overrides = summary_overrides or {}
+
+    # operationId = nombre del método de ruta SIN el prefijo de clase cbv
+    # ("UserController.list_users" → "list_users"). Idempotente.
+    for route in app.routes:
+        if isinstance(route, APIRoute):
+            match = _CBV_DOT_PREFIX.match(route.name)
+            route.operation_id = match.group(1) if match else route.name
+
+    def custom_openapi() -> Dict[str, Any]:
+        if app.openapi_schema:
+            return app.openapi_schema
+
+        schema = get_openapi(
+            title=title or app.title,
+            version=version or app.version,
+            description=description or app.description,
+            routes=app.routes,
+            tags=app.openapi_tags,
+        )
+
+        for path_item in schema.get("paths", {}).values():
+            for method, operation in path_item.items():
+                if method not in _HTTP_METHODS:
+                    continue
+                op_id = operation.get("operationId", "")
+                if op_id in overrides:
+                    operation["summary"] = overrides[op_id]
+                elif operation.get("summary"):
+                    operation["summary"] = _clean_label(operation["summary"])
+
+        app.openapi_schema = schema
+        return schema
+
+    app.openapi = custom_openapi
+    return custom_openapi

{fastapi_basekit-0.3.3 → fastapi_basekit-0.4.0}/fastapi_basekit/schema/base.py

@@ -20,6 +20,6 @@ class BasePaginationResponse(BaseModel, Generic[T]):
     data: List[T]
     message: str = "Operación exitosa"
     status: str = "success"
-    pagination: Optional[Dict[str, Any]]
+    pagination: Optional[Dict[str, Any]] = None
 
     model_config = ConfigDict(from_attributes=True)

{fastapi_basekit-0.3.3 → fastapi_basekit-0.4.0}/fastapi_basekit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-basekit
-Version: 0.3.3
+Version: 0.4.0
 Summary: Utilities and base classes for FastAPI async projects (Beanie, SQLAlchemy or SQLModel)
 Author-email: Jerson Moreno <jerson.ml820@hotmail.com>
 License: MIT
@@ -105,13 +105,25 @@ Abre http://localhost:8000/docs. Login con `admin@example.com` / `ChangeMe2026!`
 
 ## Como plugin de Claude Code
 
+Dentro de Claude Code (terminal) corre:
+
 ```bash
-/plugin marketplace add https://github.com/mundobien2025/fastapi-basekit
-/plugin install fastapi-basekit
-/plugin list
+/plugin marketplace add mundobien2025/fastapi-basekit
+/plugin install fastapi-basekit@fastapi-basekit
+/plugin list                                       # verifica instalación
 ```
 
-Luego pide: *"Crea el recurso `Invoice` con CRUD completo"* — Claude usa la skill automáticamente.
+Eso registra el marketplace `fastapi-basekit` desde el repo de GitHub e
+instala el plugin (que incluye la skill `fastapi-basekit-crud`). Luego
+pide: *"Crea el recurso `Invoice` con CRUD completo siguiendo
+fastapi-basekit"* — Claude detecta la skill y aplica el patrón canónico
+(model → repo → service → schema → controller con `@cbv`).
+
+Para actualizar a una versión nueva:
+
+```bash
+/plugin update fastapi-basekit@fastapi-basekit
+```
 
 ## Instalación por ORM
 
@@ -127,8 +139,6 @@ pip install fastapi-basekit[all]          # todo
 
 PRs bienvenidos. Setup local en [docs/contributing](https://mundobien2025.github.io/fastapi-basekit/contributing).
 
-Mantenedores: [`RELEASING.md`](./RELEASING.md) tiene release flow, CI/CD, mike y troubleshooting.
-
 ## Licencia
 
 [MIT](./LICENSE) — © Jerson Moreno

{fastapi_basekit-0.3.3 → fastapi_basekit-0.4.0}/fastapi_basekit.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE
 README.md
 pyproject.toml
 fastapi_basekit/__init__.py
+fastapi_basekit/openapi.py
 fastapi_basekit.egg-info/PKG-INFO
 fastapi_basekit.egg-info/SOURCES.txt
 fastapi_basekit.egg-info/dependency_links.txt
@@ -103,6 +104,7 @@ fastapi_basekit/templates/project/{{cookiecutter.project_slug}}/app/services/use
 fastapi_basekit/templates/project/{{cookiecutter.project_slug}}/app/utils/__init__.py
 fastapi_basekit/templates/project/{{cookiecutter.project_slug}}/app/utils/exception_handlers.py
 fastapi_basekit/templates/project/{{cookiecutter.project_slug}}/app/utils/security.py
+tests/test_action_param_leak.py
 tests/test_api_exceptions.py
 tests/test_base_response.py
 tests/test_base_service.py
@@ -112,6 +114,9 @@ tests/test_controller_auto_permissions.py
 tests/test_crud_beanie_controller.py
 tests/test_crud_controller.py
 tests/test_crud_sqlmodel_repository_service.py
+tests/test_exception_handlers.py
+tests/test_filter_operators.py
 tests/test_jwt_service.py
+tests/test_openapi_simplify.py
 tests/test_sql_queryset_override.py
 tests/test_sqlalchemy_base_service_order.py

{fastapi_basekit-0.3.3 → fastapi_basekit-0.4.0}/pyproject.toml

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

fastapi_basekit-0.4.0/tests/test_action_param_leak.py

@@ -0,0 +1,35 @@
+"""Regresión: cbv NO debe exponer `action` como query param.
+
+`BaseController.action` se declara `ClassVar` precisamente para que
+fastapi-restful (cbv) no lo promueva a parámetro de query en cada ruta
+montada. Antes de 0.4.0 aparecía un `?action=` espurio en toda mutación.
+"""
+
+from fastapi import FastAPI
+
+from tests.example_crud.controller import router
+
+
+def _spec():
+    app = FastAPI()
+    app.include_router(router)
+    return app.openapi()
+
+
+def test_no_spurious_action_query_param_on_any_route():
+    spec = _spec()
+    offending = []
+    for path, item in spec["paths"].items():
+        for method, op in item.items():
+            for param in op.get("parameters", []):
+                if param.get("name") == "action" and param.get("in") == "query":
+                    offending.append(f"{method.upper()} {path}")
+    assert offending == [], f"`action` leaked as query param on: {offending}"
+
+
+def test_declared_query_filters_still_present():
+    # Sanidad: los filtros declarados explícitamente sí deben seguir ahí.
+    spec = _spec()
+    get_list = spec["paths"]["/users/"]["get"]
+    names = {p["name"] for p in get_list.get("parameters", [])}
+    assert {"page", "count", "search", "is_active", "age_min"} <= names

fastapi_basekit-0.4.0/tests/test_exception_handlers.py

@@ -0,0 +1,55 @@
+"""register_exception_handlers: envelope unificado para toda la app."""
+
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+from pydantic import BaseModel
+
+from fastapi_basekit.exceptions import register_exception_handlers
+from fastapi_basekit.exceptions.api_exceptions import NotFoundException
+
+
+@pytest.fixture
+def client():
+    app = FastAPI()
+    register_exception_handlers(app)
+
+    class Body(BaseModel):
+        n: int
+
+    @app.get("/boom-api")
+    async def boom_api():
+        raise NotFoundException(message="no existe")
+
+    @app.get("/boom-value")
+    async def boom_value():
+        raise ValueError("campo malo")
+
+    @app.post("/echo")
+    async def echo(body: Body):
+        return {"n": body.n}
+
+    return TestClient(app, raise_server_exceptions=False)
+
+
+def test_api_exception_maps_to_envelope(client):
+    r = client.get("/boom-api")
+    assert r.status_code == 404
+    body = r.json()
+    assert body["status"] == "NOT_FOUND"
+    assert body["message"] == "no existe"
+    assert set(body) == {"data", "message", "status"}
+
+
+def test_request_validation_maps_to_envelope(client):
+    r = client.post("/echo", json={"n": "not-an-int"})
+    assert r.status_code == 422
+    body = r.json()
+    assert body["status"] == "VALIDATION_ERROR"
+    assert isinstance(body["data"], list)
+
+
+def test_value_error_maps_to_envelope(client):
+    r = client.get("/boom-value")
+    assert r.status_code == 400
+    assert r.json()["status"] == "VALUE_ERROR"

fastapi_basekit-0.4.0/tests/test_filter_operators.py

@@ -0,0 +1,78 @@
+"""Operadores de filtro en BaseRepository (sufijo campo__op)."""
+
+import uuid
+
+from sqlalchemy import String, select
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+from fastapi_basekit.aio.sqlalchemy.repository.base import BaseRepository
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class Widget(Base):
+    __tablename__ = "widgets"
+
+    id: Mapped[str] = mapped_column(
+        String, primary_key=True, default=lambda: str(uuid.uuid4())
+    )
+    name: Mapped[str] = mapped_column(String)
+    qty: Mapped[int] = mapped_column(default=0)
+
+
+class WidgetRepository(BaseRepository):
+    model = Widget
+
+
+def _repo() -> WidgetRepository:
+    return WidgetRepository.__new__(WidgetRepository)
+
+
+def test_split_operator_detects_known_suffix():
+    repo = _repo()
+    assert repo._split_operator("qty__gte") == ("qty", "gte")
+    assert repo._split_operator("name__ilike") == ("name", "ilike")
+    assert repo._split_operator("id__in") == ("id", "in")
+
+
+def test_split_operator_keeps_relationship_paths():
+    repo = _repo()
+    # 'code' no es operador → path se conserva, op por defecto eq.
+    assert repo._split_operator("user__role__code") == (
+        "user__role__code",
+        "eq",
+    )
+    assert repo._split_operator("status") == ("status", "eq")
+
+
+def _sql(condition) -> str:
+    return str(
+        select(Widget).where(condition).compile(
+            compile_kwargs={"literal_binds": True}
+        )
+    )
+
+
+def test_condition_for_each_operator():
+    f = Widget.qty
+    assert ">=" in _sql(BaseRepository._condition_for(f, 5, "gte"))
+    assert ">" in _sql(BaseRepository._condition_for(f, 5, "gt"))
+    assert "<=" in _sql(BaseRepository._condition_for(f, 5, "lte"))
+    assert "<" in _sql(BaseRepository._condition_for(f, 5, "lt"))
+    assert "!=" in _sql(BaseRepository._condition_for(f, 5, "ne"))
+    assert "IN" in _sql(BaseRepository._condition_for(f, [1, 2], "in"))
+    assert "LIKE" in _sql(
+        BaseRepository._condition_for(Widget.name, "ab", "like")
+    )
+    assert "lower(" in _sql(
+        BaseRepository._condition_for(Widget.name, "ab", "ilike")
+    ).lower()
+
+
+def test_condition_for_eq_keeps_list_in_semantics():
+    sql = _sql(BaseRepository._condition_for(Widget.qty, [1, 2], "eq"))
+    assert "IN" in sql
+    sql_scalar = _sql(BaseRepository._condition_for(Widget.qty, 1, "eq"))
+    assert "=" in sql_scalar

fastapi_basekit-0.4.0/tests/test_openapi_simplify.py

@@ -0,0 +1,38 @@
+"""simplify_openapi: quita el prefijo de clase cbv de summaries/operationIds."""
+
+from fastapi import FastAPI
+
+from fastapi_basekit.openapi import simplify_openapi
+from tests.example_crud.controller import router
+
+
+def test_strips_cbv_class_prefix():
+    app = FastAPI()
+    app.include_router(router)
+    simplify_openapi(app)
+    spec = app.openapi()
+
+    for path, item in spec["paths"].items():
+        for method, op in item.items():
+            op_id = op.get("operationId", "")
+            assert "." not in op_id, f"operationId sin limpiar: {op_id}"
+            summary = op.get("summary", "")
+            # El prefijo "UserController." no debe sobrevivir en el summary.
+            assert "Controller." not in summary
+
+
+def test_summary_override_applies():
+    app = FastAPI()
+    app.include_router(router)
+    # operationId base (ya sin prefijo tras limpiar) para list_users.
+    simplify_openapi(app, summary_overrides={"list_users": "Listar usuarios"})
+    spec = app.openapi()
+    summaries = {
+        op.get("operationId"): op.get("summary")
+        for item in spec["paths"].values()
+        for op in item.values()
+    }
+    # El override se aplica por operationId original (con prefijo cbv).
+    assert "Listar usuarios" in summaries.values() or any(
+        s == "Listar usuarios" for s in summaries.values()
+    )

fastapi_basekit-0.3.3/fastapi_basekit/exceptions/__init__.py

@@ -1,3 +0,0 @@
-from fastapi_basekit.exceptions.domain import DomainError
-
-__all__ = ["DomainError"]