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

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

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

@@ -2,6 +2,8 @@ import logging
 from typing import Any, Dict, Generic, List, Optional, Type, TypeVar, Union
 from typing import get_args, get_origin
 import re
+import unicodedata
+from functools import lru_cache
 
 from bson import ObjectId
 from pydantic import BaseModel
@@ -11,6 +13,35 @@ from beanie.operators import Or, RegEx
 
 logger = logging.getLogger(__name__)
 
+
+@lru_cache(maxsize=None)
+def _accent_class(letter: str) -> str:
+    """Clase regex que matchea `letter` con y sin tilde/diéresis, y en mayúscula."""
+    variants = {letter, letter.upper()}
+    for cp in range(0x00C0, 0x0100):  # Latin-1: á é í ó ú ü ñ… (mantiene el patrón corto)
+        ch = chr(cp)
+        if unicodedata.normalize("NFD", ch)[0].lower() == letter:
+            variants.add(ch)
+    return "[" + "".join(sorted(variants)) + "]"
+
+
+def build_search_regex(term: str) -> str:
+    """Patrón regex para búsqueda de texto (usar con `options="i"`).
+
+    - Todo lo que escribe el usuario se escapa: `(`, `[`, `*`… son literales y
+      no rompen la query ni cambian el significado del patrón.
+    - Cada letra ASCII matchea también sus variantes acentuadas: `a` ↔ `á`,
+      `n` ↔ `ñ`, `o` ↔ `Ó`. Así "descripcion" encuentra "descripción".
+    """
+    parts = []
+    for ch in term:
+        base = unicodedata.normalize("NFD", ch)[0]
+        if base.isascii() and base.isalpha():
+            parts.append(_accent_class(base.lower()))
+        else:
+            parts.append(re.escape(ch))
+    return ".*" + "".join(parts) + ".*"
+
 #: 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
@@ -119,75 +150,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 +214,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 +226,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),
+                            build_search_regex(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(
@@ -340,7 +383,7 @@ class BaseRepository(Generic[ModelT]):
 
         if search and search_fields:
             search_conditions = [
-                {field: {"$regex": f".*{search}.*", "$options": "i"}}
+                {field: {"$regex": build_search_regex(search), "$options": "i"}}
                 for field in search_fields
             ]
             if search_conditions:
@@ -521,10 +564,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.5}/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.5}/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.5}/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.5}/fastapi_basekit.egg-info/PKG-INFO

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

@@ -113,6 +113,7 @@ tests/test_beanie_aggregation_hooks.py
 tests/test_beanie_aggregation_integration.py
 tests/test_beanie_keyset_pagination.py
 tests/test_beanie_repository_regression.py
+tests/test_beanie_search_regex.py
 tests/test_beanie_service_mutable_defaults.py
 tests/test_beanie_service_regression.py
 tests/test_controller_auto_permissions.py
@@ -127,6 +128,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.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fastapi-basekit"
-version = "0.5.3"
+version = "0.5.5"
 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.5}/tests/test_beanie_aggregation_hooks.py

@@ -13,6 +13,8 @@ Covers:
 from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
+
+from fastapi_basekit.aio.beanie.repository.base import build_search_regex
 from beanie import Document
 from pydantic import Field
 
@@ -97,8 +99,8 @@ class TestBuildListPipeline:
         assert len(pipeline) == 1
         match = pipeline[0]["$match"]
         assert "$or" in match
-        assert {"name": {"$regex": ".*ana.*", "$options": "i"}} in match["$or"]
-        assert {"email": {"$regex": ".*ana.*", "$options": "i"}} in match["$or"]
+        assert {"name": {"$regex": build_search_regex("ana"), "$options": "i"}} in match["$or"]
+        assert {"email": {"$regex": build_search_regex("ana"), "$options": "i"}} in match["$or"]
 
     def test_filters_plus_search_combined_with_and(self):
         repo = FakeRepo()
@@ -110,7 +112,7 @@ class TestBuildListPipeline:
         match = pipeline[0]["$match"]
         assert "$and" in match
         assert {"is_active": True} in match["$and"]
-        assert {"$or": [{"name": {"$regex": ".*ana.*", "$options": "i"}}]} in match["$and"]
+        assert {"$or": [{"name": {"$regex": build_search_regex("ana"), "$options": "i"}}]} in match["$and"]
 
     def test_simple_order_by_appends_sort_stage(self):
         repo = FakeRepo()

fastapi_basekit-0.5.5/tests/test_beanie_search_regex.py

@@ -0,0 +1,53 @@
+"""build_search_regex: escape del término y búsqueda sin acentos (Beanie)."""
+
+import re
+
+import pytest
+
+from fastapi_basekit.aio.beanie.repository.base import build_search_regex
+
+
+def _matches(term: str, text: str) -> bool:
+    # Mismo significado que Mongo `$regex` con `$options: "i"`.
+    return re.search(build_search_regex(term), text, re.IGNORECASE) is not None
+
+
+@pytest.mark.parametrize(
+    "text",
+    ["Descripción", "descripcion", "DESCRIPCIÓN", "Descripcíon"],
+)
+def test_sin_tilde_encuentra_con_tilde_y_viceversa(text):
+    assert _matches("descripcion", text)
+    assert _matches("descripción", text)
+
+
+def test_enie_y_n_son_equivalentes():
+    assert _matches("ano", "Año nuevo")
+    assert _matches("año", "ANO")
+
+
+def test_mayusculas_acentuadas_del_termino():
+    assert _matches("ÑANDÚ", "el ñandu corre")
+    assert _matches("ñandú", "NANDU")
+
+
+@pytest.mark.parametrize("term", ["(", "[", "*", "+", "?", "\\", "a.*", "$", "^"])
+def test_caracteres_especiales_son_literales(term):
+    # No deben romper la regex ni comportarse como metacaracteres.
+    assert re.compile(build_search_regex(term))  # compila
+    assert not _matches(term, "xyz")
+
+
+def test_punto_asterisco_no_es_comodin():
+    assert not _matches("a.*", "abc")
+    assert _matches("a.*", "zza.*zz")
+
+
+def test_parentesis_se_busca_literal():
+    assert _matches("(beta)", "versión (beta) 2")
+    assert not _matches("(beta)", "versión beta 2")
+
+
+def test_termino_sin_acentos_no_cambia_el_resto_del_texto():
+    assert _matches("whats", "WhatsApp")
+    assert not _matches("telegram", "WhatsApp")

{fastapi_basekit-0.5.3 → fastapi_basekit-0.5.5}/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"