fastapi-basekit 0.4.3__tar.gz → 0.5.0__tar.gz

{fastapi_basekit-0.4.3 → fastapi_basekit-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-basekit
-Version: 0.4.3
+Version: 0.5.0
 Summary: Utilities and base classes for FastAPI async projects (Beanie, SQLAlchemy or SQLModel)
 Author-email: Jerson Moreno <jerson.ml820@hotmail.com>
 License: MIT
@@ -23,7 +23,7 @@ Provides-Extra: beanie
 Requires-Dist: beanie<3,>=2.0; extra == "beanie"
 Provides-Extra: sqlalchemy
 Requires-Dist: SQLAlchemy[asyncio]<3,>=2.0.30; extra == "sqlalchemy"
-Requires-Dist: psycopg2>=2.9.0; extra == "sqlalchemy"
+Requires-Dist: psycopg2-binary>=2.9.0; extra == "sqlalchemy"
 Provides-Extra: sqlmodel
 Requires-Dist: sqlmodel>=0.0.37; extra == "sqlmodel"
 Provides-Extra: init
@@ -37,7 +37,7 @@ Requires-Dist: mike>=2.1.0; extra == "docs"
 Provides-Extra: all
 Requires-Dist: beanie<3,>=2.0; extra == "all"
 Requires-Dist: SQLAlchemy[asyncio]<3,>=2.0.30; extra == "all"
-Requires-Dist: psycopg2>=2.9.0; extra == "all"
+Requires-Dist: psycopg2-binary>=2.9.0; extra == "all"
 Requires-Dist: sqlmodel>=0.0.37; extra == "all"
 Requires-Dist: cookiecutter>=2.5.0; extra == "all"
 Requires-Dist: mkdocs>=1.6.0; extra == "all"

{fastapi_basekit-0.4.3 → fastapi_basekit-0.5.0}/fastapi_basekit/aio/beanie/controller/base.py

@@ -19,7 +19,7 @@ class BeanieBaseController(BaseController):
     async def list(self):
         """Lista documentos con paginación usando Beanie."""
         await self.prepare_action("list")
-        params = self._params(skip_frames=2)
+        params = self._params()
         items, total = await self.service.list(**params)
         count = params.get("count") or 0
         page = params.get("page") or 1

{fastapi_basekit-0.4.3 → fastapi_basekit-0.5.0}/fastapi_basekit/aio/beanie/repository/base.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Dict, List, Optional, Type, Union
+from typing import Any, Dict, Generic, List, Optional, Type, TypeVar, Union
 from typing import get_args, get_origin
 import re
 
@@ -11,10 +11,31 @@ from beanie.operators import Or, RegEx
 
 logger = logging.getLogger(__name__)
 
+#: Tipo del Document Beanie que gestiona el repositorio. Parametrízalo al
+#: declarar la subclase — ``class UserRepository(BaseRepository[User])`` — para
+#: que ``get_by_id``/``create``/``update``/``list_all`` devuelvan el Document
+#: tipado (autocompletado + mypy para consumidores e IAs).
+ModelT = TypeVar("ModelT", bound=Document)
+
+
+class BaseRepository(Generic[ModelT]):
+    """Repositorio base para Beanie ODM (MongoDB), parametrizado por el modelo.
+
+    OJO — las firmas difieren del repo SQLAlchemy (misma clase, distinto ORM):
+      - get por id:  `get_by_id(id)`   (SQL usa `get(id)`)
+      - update:      `update(obj, data)` — el 1er arg es el **Document**, no el
+                     id (SQL usa `update(id, dict)`). Fetch primero con
+                     `get_by_id`, luego `update(obj, data)`.
+      - delete:      `delete(obj)` — recibe el Document (SQL usa `delete(id)`).
+      - create:      `create(obj | dict)`.
+    Listado: `build_list_queryset(...)`→FindMany + `paginate(...)`, o
+    `build_list_pipeline(...)` + `paginate_pipeline(...)` para joins (`$lookup`).
+    Preferí llamar el SERVICE (API unificada) en vez del repo directo; llamar
+    `get_by_id` directo bypassea el scoping de `get_filters()`.
+    """
+
+    model: Type[ModelT]
 
-class BaseRepository:
-    model: Type[Document]
-    
     def _parse_order_field(self, order_by: str) -> tuple[str, int, bool]:
         """Parse order_by string into components.
         
@@ -207,6 +228,17 @@ class BaseRepository:
     async def paginate(
         self, query: FindMany[Document], page: int, count: int, order_by: Optional[List[tuple]] = None
     ) -> tuple[List[Document], int]:
+        """MOTOR DE PAGINACIÓN (FindMany) — NO LO REIMPLEMENTES.
+
+        Único loop de paginación offset (count + skip/limit). Para personalizar
+        el listado, override el HOOK correcto, no copies skip/limit/count:
+        - query/filtros/scoping/orden → `build_list_queryset` (o `build_filter_query`)
+        - join `$lookup` / shape plano → `use_aggregation=True` + `build_list_pipeline`
+        - filtros por usuario/acción   → `Service.get_filters`
+        - orden por defecto            → `Service.get_order`
+        - enriquecer items de la página→ `Service.post_process_list`
+        - scroll infinito / cursor     → `paginate_keyset` (método+endpoint aparte)
+        """
         # Apply ordering if provided and not already applied
         if order_by:
             query = query.sort(order_by)
@@ -379,7 +411,13 @@ class BaseRepository:
         count: int,
         validate: bool = True,
     ) -> tuple[List[Any], int]:
-        """Run an aggregation pipeline with `$facet` pagination.
+        """MOTOR DE PAGINACIÓN (aggregation `$facet`) — NO LO REIMPLEMENTES.
+
+        Ejecuta el pipeline con paginación `$facet`. Para un listado agregado
+        NO copies este `$facet`/skip/limit: override `Service.build_list_pipeline`
+        (agrega `$lookup`/`$project`/`$group`) y activa `use_aggregation=True`;
+        este método le pone la paginación. Si la proyección no es el modelo,
+        `aggregation_validate=False`.
 
         Args:
             pipeline: Pipeline stages (without the final `$facet`).
@@ -471,7 +509,7 @@ class BaseRepository:
         self,
         obj_id: Union[str, ObjectId],
         **kwargs,
-    ) -> Optional[Document]:
+    ) -> Optional[ModelT]:
         if not isinstance(obj_id, ObjectId):
             obj_id = ObjectId(obj_id)
         return await self.model.find_one(
@@ -479,12 +517,19 @@ class BaseRepository:
             **self._get_query_kwargs(**kwargs),
         )
 
+    async def get(
+        self, obj_id: Union[str, ObjectId], **kwargs
+    ) -> Optional[ModelT]:
+        """Alias de `get_by_id(id)` — nombre unificado con los repos SQL
+        (`get`) para que las lecturas por id sean portables entre ORMs."""
+        return await self.get_by_id(obj_id, **kwargs)
+
     async def get_by_field(
         self,
         field_name: str,
         value: Any,
         **kwargs,
-    ) -> Optional[Document]:
+    ) -> Optional[ModelT]:
         if not hasattr(self.model, field_name):
             raise AttributeError(
                 f"{self.model.__name__} no tiene el campo '{field_name}'"
@@ -498,7 +543,7 @@ class BaseRepository:
         self,
         filters: Dict[str, Any],
         **kwargs,
-    ) -> Optional[Document]:
+    ) -> Optional[ModelT]:
         exprs = [
             getattr(self.model, f) == v
             for f, v in filters.items()
@@ -513,21 +558,27 @@ class BaseRepository:
     async def list_all(
         self,
         **kwargs,
-    ) -> List[Document]:
+    ) -> List[ModelT]:
         query = self.model.find_all(**self._get_query_kwargs(**kwargs))
         return await query.to_list()
 
-    async def create(self, obj: Union[Document, Dict[str, Any]]) -> Document:
+    async def create(self, obj: Union[ModelT, Dict[str, Any]]) -> ModelT:
         if isinstance(obj, dict):
             obj = self.model(**obj)
         await obj.insert()
         return obj
 
-    async def update(self, obj: Document, data: Dict[str, Any]) -> Document:
+    async def update(self, obj: ModelT, data: Dict[str, Any]) -> ModelT:
+        """Actualiza un Document Beanie ya cargado.
+
+        Divergencia con SQL: acá el 1er arg es el **Document** (no el id) y SÍ
+        setea ``None``. El repo SQLAlchemy usa ``update(id, dict)`` y omite
+        ``None``. Ver la tabla en el CLAUDE.md de la lib.
+        """
         for key, value in data.items():
             setattr(obj, key, value)
         await obj.save()
         return obj
 
-    async def delete(self, obj: Document) -> None:
+    async def delete(self, obj: ModelT) -> None:
         await obj.delete()

{fastapi_basekit-0.4.3 → fastapi_basekit-0.5.0}/fastapi_basekit/aio/beanie/service/base.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, Generic, List, Optional, Tuple, Union
 
 from beanie import Document
 from beanie.odm.queries.find import FindMany
@@ -6,17 +6,25 @@ from fastapi import Request
 from pydantic import BaseModel
 
 
-from ...beanie.repository.base import BaseRepository
+from ...beanie.repository.base import BaseRepository, ModelT
 from ....exceptions.api_exceptions import (
     NotFoundException,
     DatabaseIntegrityException,
 )
 
 
-class BaseService:
-    """Servicio base específico para Beanie ODM (async)."""
+class BaseService(Generic[ModelT]):
+    """Servicio base específico para Beanie ODM (async), parametrizado.
 
-    repository: BaseRepository
+    Declara el modelo vía el genérico para tipar el CRUD::
+
+        class UserService(BaseService[User]):
+            repository: UserRepository
+
+    Así ``retrieve``/``create``/``update`` devuelven ``User``.
+    """
+
+    repository: BaseRepository[ModelT]
     search_fields: List[str] = []
     duplicate_check_fields: List[str] = []
     kwargs_query: Dict[str, Union[str, int]] = {}
@@ -74,7 +82,7 @@ class BaseService:
         filters = filters or {}
         return filters
 
-    async def retrieve(self, id: str):
+    async def retrieve(self, id: str) -> ModelT:
         kwargs = self.get_kwargs_query()
         obj = await self.repository.get_by_id(id, **kwargs)
         if not obj:
@@ -133,7 +141,7 @@ class BaseService:
         count: int = 25,
         filters: Optional[Dict[str, Any]] = None,
         order_by: Optional[str] = None,  # Dynamic ordering (e.g., "-created_at" or "tool__name")
-    ):
+    ) -> Tuple[List[ModelT], int]:
         kwargs = self.get_kwargs_query()
         applied_filters = self.get_filters(filters)
 
@@ -159,34 +167,60 @@ class BaseService:
                 order_by=order_str,
                 **kwargs,
             )
-            return await self.repository.paginate_pipeline(
+            items, total = await self.repository.paginate_pipeline(
                 pipeline,
                 page=page,
                 count=count,
                 validate=self.aggregation_validate,
             )
+        else:
+            # FindMany path
+            order_list = None
+            if order_str:
+                direction = -1 if order_str.startswith("-") else 1
+                field = order_str.lstrip("-")
+                order_list = [(field, direction)]
 
-        # FindMany path
-        order_list = None
-        if order_str:
-            direction = -1 if order_str.startswith("-") else 1
-            field = order_str.lstrip("-")
-            order_list = [(field, direction)]
+            query = self.build_list_queryset(
+                search=search,
+                search_fields=self.search_fields,
+                filters=applied_filters,
+                order_by=order_list,
+                **kwargs,
+            )
+            items, total = await self.repository.paginate(
+                query, page, count, order_by=order_list
+            )
 
-        query = self.build_list_queryset(
-            search=search,
-            search_fields=self.search_fields,
-            filters=applied_filters,
-            order_by=order_list,
-            **kwargs,
-        )
-        return await self.repository.paginate(
-            query, page, count, order_by=order_list
-        )
+        items = await self.post_process_list(items)
+        return items, total
+
+    async def post_process_list(self, items: List[ModelT]) -> List[ModelT]:
+        """Hook: transforma/enriquece los items DE UNA PÁGINA ya paginada.
+
+        Este es el método para "hacer algo custom con los resultados" SIN
+        reescribir la paginación ni overridear `list()`. Corre después de
+        `paginate`/`paginate_pipeline`, sobre los items de la página actual
+        (no toda la colección), así que es seguro para un enrich con un `await`
+        extra por página (agrega un contador, resuelve un campo derivado, etc.).
+
+        Default: devuelve los items sin cambios. Ejemplo::
+
+            async def post_process_list(self, items):
+                ids = [c.id for c in items]
+                counts = await self.conv_repo.count_by_customer_ids(ids)
+                for c in items:
+                    c.conversation_count = counts.get(c.id, 0)
+                return items
+
+        NO cambies el `total` acá (es el de la query completa). NO filtres items
+        (eso va en `get_filters`/`build_list_*`, o el total quedaría mal).
+        """
+        return items
 
     async def create(
         self, payload: BaseModel, check_fields: Optional[List[str]] = None
-    ) -> Any:
+    ) -> ModelT:
         data = (
             payload.model_dump() if not isinstance(payload, dict) else payload
         )
@@ -205,7 +239,7 @@ class BaseService:
             else created
         )
 
-    async def update(self, id: str, data: BaseModel) -> Any:
+    async def update(self, id: str, data: BaseModel) -> ModelT:
         kwargs = self.get_kwargs_query()
         obj = await self.repository.get_by_id(id, **kwargs)
         if not obj:

{fastapi_basekit-0.4.3 → fastapi_basekit-0.5.0}/fastapi_basekit/aio/controller/base.py

@@ -1,8 +1,69 @@
+import functools
 import inspect
-from typing import Any, ClassVar, Dict, List, Optional, Type, Set
+import types
+from typing import (
+    Any,
+    ClassVar,
+    Dict,
+    List,
+    Optional,
+    Type,
+    Set,
+    Union,
+    get_args,
+    get_origin,
+)
 from fastapi import Depends, Request
 from pydantic import BaseModel, TypeAdapter
 
+
+@functools.lru_cache(maxsize=512)
+def _type_adapter_for(target: Any) -> Any:
+    """Devuelve un ``TypeAdapter`` cacheado para coaccionar un valor de query a
+    ``target`` con el MISMO motor que usa FastAPI (pydantic). Cubre date,
+    datetime, UUID, Decimal, Enum, etc. — todo lo que no sea bool/int/float/str.
+    ``None`` si el tipo no es adaptable."""
+    try:
+        return TypeAdapter(target)
+    except Exception:
+        return None
+
+
+@functools.lru_cache(maxsize=1024)
+def _endpoint_param_types_cached(endpoint: Any) -> Dict[str, Any]:
+    """Mapea {nombre_param: anotación} desde la firma del endpoint, CACHEADO.
+
+    El endpoint (`request.scope["endpoint"]`) es el MISMO objeto callable en cada
+    request (se crea una vez al montar la ruta), así que su firma se computa una
+    sola vez por endpoint — no en cada request de listado. Antes cada listado
+    pagaba un `inspect.signature`; ahora es O(1) tras el primer hit.
+
+    El dict devuelto es compartido (cacheado): tratar como SOLO-LECTURA.
+    """
+    try:
+        parameters = inspect.signature(endpoint).parameters
+    except (TypeError, ValueError):
+        return {}
+    return {
+        name: param.annotation
+        for name, param in parameters.items()
+        if param.annotation is not inspect.Parameter.empty
+    }
+
+
+def _unwrap_optional(annotation: Any) -> Any:
+    """Strip ``Optional[X]`` / ``Union[X, None]`` / ``X | None`` → ``X``.
+
+    Returns the annotation unchanged when it is not an optional/union, or when
+    the union has no single non-``None`` member.
+    """
+    origin = get_origin(annotation)
+    if origin is Union or origin is getattr(types, "UnionType", ()):  # X | None
+        non_none = [a for a in get_args(annotation) if a is not type(None)]
+        if len(non_none) == 1:
+            return non_none[0]
+    return annotation
+
 from ..permissions.base import BasePermission
 
 from ...schema.base import BasePaginationResponse, BaseResponse
@@ -58,13 +119,19 @@ class BaseController:
     async def prepare_action(self, action_name: str) -> None:
         """Set the current action and run permission checks.
 
-        Auto-called by ``ControllerMeta`` for every public async method on
-        the controller. Idempotent within one invocation: if the same
-        ``action_name`` has already been prepared on this instance,
-        subsequent calls are no-ops. This lets custom methods opt into
-        calling ``await self.prepare_action(...)`` explicitly without
-        double-firing permission checks (when the metaclass already ran
-        before entering the method body).
+        NO metaclass or auto-wrapping exists. This is called EXPLICITLY:
+
+        - The base CRUD methods (``list``/``retrieve``/``create``/``update``/
+          ``delete``) call it for you — if your endpoint just does
+          ``return await super().list()`` you are covered.
+        - A CUSTOM endpoint (any method you write yourself, e.g.
+          ``async def approve(self, id: str)``) runs with NO permission check
+          unless you add ``await self.prepare_action("approve")`` as its first
+          line. Forgetting this silently skips ``permission_classes``.
+
+        Idempotent within one instance: if the same ``action_name`` is already
+        prepared, subsequent calls are no-ops, so calling it in a custom method
+        that also delegates to ``super().<crud>()`` won't double-fire.
         """
         if getattr(self, "_basekit_prepared_action", None) == action_name:
             return
@@ -102,9 +169,10 @@ class BaseController:
         """Backward-compat alias for ``check_permissions``.
 
         Pre-0.3.2 controllers called this manually inside endpoint methods.
-        Keep working for users who haven't migrated to ``permission_classes``
-        + auto-wrapping yet. New code should declare ``permission_classes``
-        on the controller and let the metaclass run permissions.
+        Kept working for code that hasn't migrated. New code should declare
+        ``permission_classes`` on the controller and call
+        ``await self.prepare_action("<action>")`` at the top of each custom
+        endpoint (there is no metaclass that does this automatically).
         """
         await self.check_permissions()
 
@@ -205,79 +273,53 @@ class BaseController:
         return response_cls(**kwargs)
 
     def _params(self, skip_frames: int = 1) -> Dict[str, Any]:
+        """Extrae page/count/search/order_by/filters de ``request.query_params``.
+
+        Los valores llegan como strings; se coaccionan a los tipos DECLARADOS
+        en la firma del endpoint (leída de ``request.scope["endpoint"]``), de
+        forma DETERMINISTA — sin introspección de stack-frames. Un query param
+        que no está declarado en la firma se deja como string (idéntico a lo
+        que haría FastAPI si no lo tipara), evitando coacciones-adivinanza que
+        romperían columnas string con valores numéricos.
+
+        Reemplaza el viejo mecanismo basado en ``inspect.currentframe()`` +
+        ``skip_frames`` (un número mágico distinto por capa de herencia, fuente
+        de listados vacíos difíciles de diagnosticar).
+
+        ``skip_frames``: DEPRECADO e IGNORADO. Se conserva solo por
+        retro-compatibilidad — algunos consumidores overridean ``_params`` y
+        llaman ``super()._params(skip_frames + 1)`` (p.ej. mixins de path
+        params). Ya no se usa: la coerción no depende de frames. No lo pases en
+        código nuevo.
         """
-        Extrae parámetros automáticamente usando introspección.
-
-        Usa query_params como fuente de verdad para determinar QUÉ parámetros
-        existen, y luego intenta obtener sus VALORES validados desde el frame
-        del método llamador (con tipos ya convertidos por FastAPI).
-
-        Args:
-            skip_frames: Número de frames a saltar (1 por defecto para
-                llamadas directas, 2 para controllers heredados)
-        """
-        # Obtener query_params como fuente de verdad
-        query_params = self.request.query_params if self.request else {}
+        query_params = (
+            dict(self.request.query_params) if self.request else {}
+        )
+        declared = self._endpoint_param_types()
 
-        # Parámetros especiales de paginación y búsqueda
         standard_params = {"page", "count", "search", "order_by"}
-
-        # Valores por defecto
         page = 1
         count = 10
         search = None
         order_by = None
-        filters = {}
-
-        # Intentar obtener valores validados del frame local
-        frame = inspect.currentframe()
-        caller_locals = {}
-
-        if frame:
-            # Navegar hacia atrás en la pila según skip_frames
-            caller_frame = frame
-            for _ in range(skip_frames):
-                if caller_frame and caller_frame.f_back:
-                    caller_frame = caller_frame.f_back
-                else:
-                    break
-
-            if caller_frame:
-                caller_locals = caller_frame.f_locals
-
-        # Procesar cada parámetro de query_params
-        for param_name, param_value in query_params.items():
-            # Intentar obtener valor validado del frame local
-            validated_value = caller_locals.get(param_name)
-
-            # Si no existe en locals, usar el valor del query_param
-            final_value = (
-                validated_value if validated_value is not None else param_value
-            )
-
-            # Clasificar el parámetro
+        filters: Dict[str, Any] = {}
+
+        for param_name, raw_value in query_params.items():
+            value = self._coerce_param(raw_value, declared.get(param_name))
+
             if param_name == "page":
-                page = (
-                    int(final_value)
-                    if not isinstance(final_value, int)
-                    else final_value
-                )
+                page = self._as_int(value, 1)
             elif param_name == "count":
-                count = (
-                    int(final_value)
-                    if not isinstance(final_value, int)
-                    else final_value
-                )
+                count = self._as_int(value, 10)
             elif param_name == "search":
-                search = final_value
+                search = value
             elif param_name == "order_by":
-                order_by = final_value
+                order_by = value
             elif (
                 param_name not in standard_params
                 and param_name not in self._params_excluded_fields
             ):
-                # Es un filtro
-                filters[param_name] = final_value
+                filters[param_name] = value
 
         return {
             "page": page,
@@ -287,6 +329,70 @@ class BaseController:
             "filters": filters,
         }
 
+    def _endpoint_param_types(self) -> Dict[str, Any]:
+        """Mapea {nombre_param: anotación} desde la firma del endpoint activo.
+
+        Lee ``request.scope["endpoint"]`` (la función de ruta que FastAPI está
+        ejecutando) y delega en el cache por-endpoint. Devuelve ``{}`` si no hay
+        endpoint o su firma no es introspectable (los valores quedan como string).
+        """
+        request = getattr(self, "request", None)
+        scope = getattr(request, "scope", None) if request is not None else None
+        endpoint = scope.get("endpoint") if isinstance(scope, dict) else None
+        if endpoint is None:
+            return {}
+        try:
+            return _endpoint_param_types_cached(endpoint)
+        except TypeError:
+            # endpoint no hasheable (raro) → sin coerción, valores string.
+            return {}
+
+    @staticmethod
+    def _coerce_param(raw: Any, annotation: Any) -> Any:
+        """Coacciona un valor de query (string) al tipo declarado en la firma.
+
+        bool/int/float a mano; el RESTO (date, datetime, UUID, Decimal, Enum…)
+        vía pydantic ``TypeAdapter`` — el MISMO motor que usa FastAPI, para que
+        el filtro reciba el objeto tipado (ej. un `date` real que compara contra
+        una columna DATE) y no el string. Sin anotación, str, o si la coacción
+        falla → se devuelve el valor original sin romper.
+
+        Nota: FastAPI ya rechaza (422) un query param tipado con valor inválido
+        antes de llegar acá, así que en la práctica la coacción siempre aplica.
+        """
+        if annotation is None or not isinstance(raw, str):
+            return raw
+        target = _unwrap_optional(annotation)
+        if target is bool:
+            return raw.strip().lower() in {"1", "true", "t", "yes", "on"}
+        if target is int:
+            try:
+                return int(raw)
+            except (TypeError, ValueError):
+                return raw
+        if target is float:
+            try:
+                return float(raw)
+            except (TypeError, ValueError):
+                return raw
+        if target is str or target is Any:
+            return raw
+        # date / datetime / UUID / Decimal / Enum / etc. → pydantic (FastAPI-parity)
+        adapter = _type_adapter_for(target)
+        if adapter is None:
+            return raw
+        try:
+            return adapter.validate_python(raw)
+        except Exception:
+            return raw
+
+    @staticmethod
+    def _as_int(value: Any, default: int) -> int:
+        try:
+            return int(value)
+        except (TypeError, ValueError):
+            return default
+
     def to_dict(self, obj: Any):
         """Helper para convertir modelos ORM/Pydantic a dict."""
         if hasattr(obj, "model_dump"):  # Pydantic v2

{fastapi_basekit-0.4.3 → fastapi_basekit-0.5.0}/fastapi_basekit/aio/sqlalchemy/controller/base.py

@@ -49,7 +49,7 @@ class SQLAlchemyBaseController(BaseController):
             order_by: Expresión de ordenamiento (ej: User.created_at.desc())
         """
         await self.prepare_action("list")
-        params = self._params(skip_frames=2)
+        params = self._params()
         service_params = {
             **params,
             "use_or": use_or,