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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-basekit
-Version: 0.5.3
+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.3 → 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.3 → 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.3 → 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.3 → 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.3 → fastapi_basekit-0.5.4}/fastapi_basekit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-basekit
-Version: 0.5.3
+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.3 → fastapi_basekit-0.5.4}/fastapi_basekit.egg-info/SOURCES.txt

@@ -127,6 +127,7 @@ tests/test_generics_wiring.py
 tests/test_jwt_config_robustness.py
 tests/test_jwt_service.py
 tests/test_openapi_simplify.py
+tests/test_owner_filter_helper.py
 tests/test_params_classification.py
 tests/test_params_coercion_matrix.py
 tests/test_params_coercion_unit.py

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

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

{fastapi_basekit-0.5.3 → fastapi_basekit-0.5.4}/tests/test_beanie_service_regression.py

@@ -242,3 +242,76 @@ async def test_scoped_filter_merges_with_user_filter(seeded):
     svc_t1 = ScopedItemService(repository=ItemRepo(), tenant="t1")
     items, total = await svc_t1.list(filters={"active": True}, count=50)
     assert {i.name for i in items} == {"Alpha"}  # t1 + active
+
+
+# ---------------------------------------------------------------------------
+# get_filters scoping en retrieve/update/delete (IDOR — CLAUDE.md prometía
+# esto ["Si necesitas un objeto por id con scope, usa `service.retrieve(id)`"]
+# pero `retrieve`/`update`/`delete` llamaban `repository.get_by_id(id)`
+# directo, bypasseando `get_filters()` igual que un `get_by_id` crudo. Un
+# `ScopedItemService` (tenant t2) podía leer/editar/borrar un Item de t1
+# solo con adivinar/enumerar su id. Fix: `retrieve`/`update`/`delete` ahora
+# pasan `filters=self.get_filters()` a `repository.get_by_id`.
+# ---------------------------------------------------------------------------
+
+@pytest.mark.asyncio
+async def test_retrieve_respects_scope_own_tenant_ok(seeded):
+    svc_t1 = ScopedItemService(repository=ItemRepo(), tenant="t1")
+    got = await svc_t1.retrieve(str(seeded[0].id))  # Alpha, tenant t1
+    assert got.name == "Alpha"
+
+
+@pytest.mark.asyncio
+async def test_retrieve_cross_tenant_id_is_not_found(seeded):
+    """El id de Gamma (t2) existe de verdad — pedido desde un service
+    scopeado a t1 debe comportarse como si no existiera (404), no leakear
+    el registro de otro tenant."""
+    svc_t1 = ScopedItemService(repository=ItemRepo(), tenant="t1")
+    with pytest.raises(NotFoundException):
+        await svc_t1.retrieve(str(seeded[2].id))  # Gamma, tenant t2
+
+    # El mismo id SÍ resuelve para el tenant dueño.
+    svc_t2 = ScopedItemService(repository=ItemRepo(), tenant="t2")
+    got = await svc_t2.retrieve(str(seeded[2].id))
+    assert got.name == "Gamma"
+
+
+@pytest.mark.asyncio
+async def test_update_cross_tenant_id_is_not_found_and_not_modified(seeded):
+    svc_t1 = ScopedItemService(repository=ItemRepo(), tenant="t1")
+    with pytest.raises(NotFoundException):
+        await svc_t1.update(str(seeded[2].id), ItemUpdate(qty=999))
+
+    # No se modificó — lo confirma el dueño real (t2).
+    svc_t2 = ScopedItemService(repository=ItemRepo(), tenant="t2")
+    unchanged = await svc_t2.retrieve(str(seeded[2].id))
+    assert unchanged.qty == 9
+
+
+@pytest.mark.asyncio
+async def test_delete_cross_tenant_id_is_not_found_and_not_deleted(seeded):
+    svc_t1 = ScopedItemService(repository=ItemRepo(), tenant="t1")
+    with pytest.raises(NotFoundException):
+        await svc_t1.delete(str(seeded[2].id))
+
+    # Sigue existiendo — lo confirma el dueño real (t2).
+    svc_t2 = ScopedItemService(repository=ItemRepo(), tenant="t2")
+    still_there = await svc_t2.retrieve(str(seeded[2].id))
+    assert still_there.name == "Gamma"
+
+
+@pytest.mark.asyncio
+async def test_unscoped_service_retrieve_update_delete_unaffected(seeded):
+    """Retrocompatibilidad: un service SIN override de `get_filters` (el
+    caso común, `get_filters` devuelve `{}`) sigue viendo/editando/borrando
+    cualquier id — cero cambio de comportamiento para el 99% de los
+    services existentes que no scopean por owner."""
+    svc = ItemService(repository=ItemRepo())
+    got = await svc.retrieve(str(seeded[2].id))  # Gamma, sin scoping
+    assert got.name == "Gamma"
+
+    updated = await svc.update(str(seeded[2].id), ItemUpdate(qty=42))
+    assert updated.qty == 42
+
+    res = await svc.delete(str(seeded[2].id))
+    assert res == "deleted"

fastapi_basekit-0.5.4/tests/test_owner_filter_helper.py

@@ -0,0 +1,65 @@
+"""`BaseService.owner_filter()` (Beanie) — helper que decide la clave Mongo
+correcta para un filtro de ownership sobre un campo `Link`, según si la
+query va a correr agregada (`list()`, con `fetch_links=True` → Beanie la
+reescribe a `$lookup`, clave post-lookup `"<field>._id"`) o plana
+(`retrieve`/`update`/`delete` vía `get_by_id`, que SIEMPRE escopea con
+`fetch_links=False` → DBRef intacto, clave `"<field>.$id"`).
+
+Caso real que motivó el helper (pulbot-backend, `ToolService`, 2026-08-11):
+un service con `Link[User]` usaba la clave equivocada en `retrieve`/
+`update`/`delete` (la misma que `list()`) — no tiraba error, devolvía 0
+resultados en silencio → 404 en el delete de un recurso propio. Verificado
+contra Mongo real (pulbot-backend, docker) tras el fix: 72/72 tests de
+`app/tests/e2e/tool*` en verde.
+
+Nota: este test es de LÓGICA PURA (sin DB) a propósito — `mongomock_motor`
+(el mock que usa el resto de esta suite) no soporta queries dot-notation
+sobre `DBRef` (`{"owner.$id": ...}` da 0 matches incluso contra el mismo
+documento que lo tiene), así que un test contra mongomock de la mitad
+`.$id` de este helper daría un falso negativo. La corrección de esa mitad
+ya está verificada contra Mongo real en pulbot-backend; acá solo
+caracterizamos que `owner_filter()` arma la clave correcta por `action`.
+"""
+
+from types import SimpleNamespace
+
+from fastapi_basekit.aio.beanie.service.base import BaseService
+
+
+class _FakeRepo:
+    pass
+
+
+def _service(action: str) -> BaseService:
+    svc = BaseService(repository=_FakeRepo(), request=None)
+    svc.action = action
+    return svc
+
+
+def test_owner_filter_uses_post_lookup_key_for_list():
+    svc = _service("list")
+    assert svc.owner_filter("user", "u1") == {"user._id": "u1"}
+
+
+def test_owner_filter_uses_dbref_key_for_retrieve():
+    svc = _service("retrieve")
+    assert svc.owner_filter("user", "u1") == {"user.$id": "u1"}
+
+
+def test_owner_filter_uses_dbref_key_for_update():
+    svc = _service("update")
+    assert svc.owner_filter("user", "u1") == {"user.$id": "u1"}
+
+
+def test_owner_filter_uses_dbref_key_for_delete():
+    svc = _service("delete")
+    assert svc.owner_filter("user", "u1") == {"user.$id": "u1"}
+
+
+def test_owner_filter_defaults_to_dbref_key_for_custom_actions():
+    """Cualquier action que no sea "list" (ej. un endpoint custom que llama
+    `get_filters()` a mano) asume el camino no-agregado — es el lado
+    seguro: si algún día un action custom SÍ corre agregado, hay que optar
+    explícitamente pasando `"list"` o extendiendo el criterio, no al revés."""
+    svc = _service("approve")
+    assert svc.owner_filter("customer", "c1") == {"customer.$id": "c1"}

{fastapi_basekit-0.5.3 → fastapi_basekit-0.5.4}/tests/test_sqlalchemy_service_regression.py

@@ -131,6 +131,79 @@ async def test_get_filters_scoping(seeded, session):
     assert {u.name for u in items} == {"Ana"}
 
 
+# ---------------------------------------------------------------------------
+# get_filters scoping en retrieve/update/delete (IDOR — mismo fix que en
+# Beanie: `retrieve`/`update`/`delete` llamaban al repo por PK cruda,
+# bypasseando `get_filters()`. Un service scopeado por `name="Ana"` podía
+# leer/editar/borrar el registro de "Beto" solo con adivinar su id.)
+# ---------------------------------------------------------------------------
+
+def _ana_scoped_service(session):
+    class AnaScopedService(UserService):
+        def get_filters(self, filters=None):
+            filters = super().get_filters(filters)
+            filters["name"] = "Ana"
+            return filters
+
+    return AnaScopedService(repository=UserRepository(db=session), request=None)
+
+
+@pytest.mark.asyncio
+async def test_retrieve_respects_scope_own_record_ok(seeded, session):
+    svc = _ana_scoped_service(session)
+    got = await svc.retrieve(str(seeded[0].id))  # Ana
+    assert got.name == "Ana"
+
+
+@pytest.mark.asyncio
+async def test_retrieve_out_of_scope_id_is_not_found(seeded, session, service):
+    svc = _ana_scoped_service(session)
+    with pytest.raises(NotFoundException):
+        await svc.retrieve(str(seeded[1].id))  # Beto, existe pero no matchea el scope
+
+    # El mismo id sí resuelve para un service sin ese scope.
+    got = await service.retrieve(str(seeded[1].id))
+    assert got.name == "Beto"
+
+
+@pytest.mark.asyncio
+async def test_update_out_of_scope_id_is_not_found_and_not_modified(
+    seeded, session, service
+):
+    svc = _ana_scoped_service(session)
+    with pytest.raises(NotFoundException):
+        await svc.update(str(seeded[1].id), UserUpdateSchema(name="Hijacked"))
+
+    unchanged = await service.retrieve(str(seeded[1].id))
+    assert unchanged.name == "Beto"
+
+
+@pytest.mark.asyncio
+async def test_delete_out_of_scope_id_is_not_found_and_not_deleted(
+    seeded, session, service
+):
+    svc = _ana_scoped_service(session)
+    with pytest.raises(NotFoundException):
+        await svc.delete(str(seeded[1].id))
+
+    still_there = await service.retrieve(str(seeded[1].id))
+    assert still_there.name == "Beto"
+
+
+@pytest.mark.asyncio
+async def test_unscoped_service_retrieve_update_delete_unaffected(seeded, service):
+    """Retrocompatibilidad: sin override de `get_filters` (el caso común),
+    cero cambio de comportamiento."""
+    got = await service.retrieve(str(seeded[1].id))
+    assert got.name == "Beto"
+
+    updated = await service.update(str(seeded[1].id), UserUpdateSchema(name="Beto2"))
+    assert updated.name == "Beto2"
+
+    ok = await service.delete(str(seeded[1].id))
+    assert ok is True
+
+
 # ---------------------------------------------------------------------------
 # Fix issue #7: aislamiento de mutable-defaults por instancia
 # ---------------------------------------------------------------------------