tai-api 0.7.2__tar.gz → 0.7.4__tar.gz

{tai_api-0.7.2 → tai_api-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tai-api
-Version: 0.7.2
+Version: 0.7.4
 Summary: FastAPI framework with TAI ecosystem integration
 License-Expression: LicenseRef-Proprietary
 License-File: LICENSE
@@ -29,8 +29,8 @@ Requires-Dist: python-multipart (>=0.0.9,<1.0) ; extra == "run"
 Requires-Dist: sqlalchemy[asyncio] (>=2.0.0,<3.0) ; extra == "run"
 Requires-Dist: tai-alphi (>=2.0.1,<3.0)
 Requires-Dist: tai-keycloak (>=0.3.3,<0.4) ; extra == "rbac"
-Requires-Dist: tai-sql (>=0.8.0,<1.0)
-Requires-Dist: tai-sql[diagrams,hashing] (>=0.8.0,<1.0) ; extra == "database"
+Requires-Dist: tai-sql (>=0.8.4,<1.0)
+Requires-Dist: tai-sql[diagrams,hashing] (>=0.8.4,<1.0) ; extra == "database"
 Requires-Dist: uvicorn[standard] (>=0.30.0,<1.0) ; extra == "run"
 Project-URL: Homepage, https://www.triplealpha.in/es/
 Project-URL: Issues, https://github.com/triplealpha-innovation/tai-api/issues

{tai_api-0.7.2 → tai_api-0.7.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tai-api"
-version = "0.7.2"
+version = "0.7.4"
 description = "FastAPI framework with TAI ecosystem integration"
 license = "LicenseRef-Proprietary"
 license-files = ["LICENSE"]
@@ -27,7 +27,7 @@ classifiers = [
 # sqlalchemy llegan como dependencias obligatorias de tai-sql. tai-alphi no: llegaba de rebote por
 # tai-keycloak 0.2, y con la 0.3 el CLI dejaba de arrancar en una instalación limpia.
 dependencies = [
-    "tai-sql>=0.8.0,<1.0",
+    "tai-sql>=0.8.4,<1.0",
     "tai-alphi>=2.0.1,<3.0",
 ]
 
@@ -54,7 +54,7 @@ rbac = [
 # que lleva tai-api dentro (rbac/providers/database/auth), con contraseñas hasheadas (extra
 # `hashing`). pandas no: ese cliente solo lo importa dentro de los métodos de DataFrame.
 database = [
-    "tai-sql[diagrams,hashing]>=0.8.0,<1.0",
+    "tai-sql[diagrams,hashing]>=0.8.4,<1.0",
 ]
 
 [project.urls]

{tai_api-0.7.2 → tai_api-0.7.4}/tai_api/generators/main_file/templates/app/__init__.py.j2

@@ -39,12 +39,31 @@ from . import docs, health
 TITLE = "{{ project_name }}"
 
 
+class RootPath:
+    """
+    El prefijo bajo el que se sirve la API (`ROOT_PATH` de `config.py`), en cada petición.
+
+    Es lo que hacía `FastAPI(root_path=...)`, que FastAPI desaprueba desde la 0.146 para que lo ponga
+    el servidor (`--root-path`). Aquí no depende de cómo se arranque —`tai-api dev`, `uvicorn` en el
+    contenedor, `__main__.py`—, y `ROOT_PATH` sigue en un solo sitio. De él cuelgan la ruta de la
+    cookie de sesión (`/api/auth`) y los enlaces de la documentación.
+    """
+
+    def __init__(self, app, root_path: str):
+        self.app = app
+        self.root_path = root_path
+
+    async def __call__(self, scope, receive, send):
+        if self.root_path and scope["type"] in ("http", "websocket"):
+            scope["root_path"] = self.root_path
+        await self.app(scope, receive, send)
+
+
 def create_app() -> FastAPI:
     app = FastAPI(
         title=TITLE,
         version=VERSION,
         lifespan=lifespan,
-        root_path=ROOT_PATH,
         # La documentación la sirve `docs.py`, con su propia página y su protección.
         docs_url=None,
         redoc_url=None,
@@ -120,6 +139,9 @@ def create_app() -> FastAPI:
 
     _openapi_with_groups(app)
     _extensions(app)
+    # El último, para que quede por fuera de todo, también de lo que añada `extensions`: el resto
+    # ya ve el `root_path` de la petición
+    app.add_middleware(RootPath, root_path=ROOT_PATH)
     return app
 
 
@@ -163,7 +185,7 @@ def _openapi_with_groups(app: FastAPI) -> None:
             )
             if not secured:
                 docs.without_auth(schema)
-            docs.absolute_token_urls(schema, app.root_path)
+            docs.absolute_token_urls(schema, ROOT_PATH)
             schema["x-tagGroups"] = docs.tag_groups(schema, docs.SCHEMAS)
             schema["tags"] = docs.tag_names(schema, docs.SCHEMAS)
             built[secured] = schema

{tai_api-0.7.2 → tai_api-0.7.4}/tai_api/generators/main_file/templates/app/docs.py.j2

@@ -154,7 +154,7 @@ def absolute_token_urls(openapi: dict, root_path: str) -> dict:
     relativo, y el navegador acaba resolviéndolos contra la página. Desde `/docs/swagger` el login
     iba a `/docs/auth/docslogin`, o a `/api/docs/auth/docslogin` detrás del proxy: un 404 en los
     dos casos. Se completan aquí y no en `dependencies.py` porque es aquí donde se conoce el
-    `root_path` de la app, y `config.py` no se puede importar desde las dependencias.
+    `ROOT_PATH` de `config.py`, que no se puede importar desde las dependencias.
     """
     raíz = root_path.rstrip("/")
     for esquema in openapi.get("components", {}).get("securitySchemes", {}).values():

{tai_api-0.7.2 → tai_api-0.7.4}/tai_api/generators/routers/main.py

@@ -623,10 +623,22 @@ class RoutersGenerator(BaseGenerator):
                     'columnas': uniones[anidada.relation],
                     'inversa': inversas.get(anidada.relation),
                 }
+            # Con qué se puede pedir un lote de filas por cada columna: una lista (`in_`), un rango
+            # (`min_`/`max_`) o nada. Es el `filter_fields` del DAO, sin las columnas que el DAO no
+            # deja filtrar (cifradas y hasheadas).
+            filtros = {}
+            for columna in model_info['columns']:
+                if columna.get('encrypt') or columna.get('hash'):
+                    continue
+                if 'in' in columna['filter_fields']:
+                    filtros[columna['name']] = 'in'
+                elif 'range' in columna['filter_fields']:
+                    filtros[columna['name']] = 'range'
             tablas.append({
                 'name': model_info['name'],
                 'tablename': entity.tablename,
                 'clave': list(recurso.primary_key),
+                'filtros': filtros,
                 'crea': sorted(a.relation for a in crea),
                 'modifica': sorted(a.relation for a in modifica),
                 'relaciones': [relaciones[nombre] for nombre in sorted(relaciones)],

{tai_api-0.7.2 → tai_api-0.7.4}/tai_api/generators/routers/templates/endpoints/post/create_many.py.j2

@@ -6,14 +6,15 @@ from fastapi import Body{% if has_auth %}, Depends{% endif %}
 
 {% if has_auth %}
 {{ shared.auth_imports(has_auth, auth_import, database_import) }}
-from {{ auth_import }} import build_owner_rules, owner_violation
 {% if anidadas.get('create_many') %}
-from {{ anidados_import }} import despues_de_crear, en_create, exigir_permisos, traducir_anidada
+from {{ anidados_import }} import despues_de_crear_varias, en_create, exigir_permisos, traducir_anidada
+{% else %}
+from {{ anidados_import }} import despues_de_crear_varias
 {% endif %}
 {% elif anidadas.get('create_many') %}
 from {{ anidados_import }} import traducir_anidada
 {% endif %}
-from {{ database_import }} import {{ facade }}, {{ model.name }}Read, {{ model.name }}Create{{ ', RLS' if has_auth else '' }}
+from {{ database_import }} import {{ facade }}, {{ model.name }}Read, {{ model.name }}Create
 from {{ resources_import }} import APIResponse
 from .docs import CREATE_MANY_LIMIT, CREATE_MANY_RESPONSES, CREATE_MANY_SUMMARY, CREATE_MANY_DESCRIPTION
 from ... import {{ model.tablename }}_router
@@ -38,10 +39,6 @@ async def {{ model.tablename }}_create_many(
     Crea varios {{ model.name }} en una sola transacción: o todos, o ninguno.
     """
 {% if has_auth %}
-    propias = build_owner_rules(
-        token, "{{ schema_name }}", get_model_by_name, RLS,
-        model=get_model_by_name("{{ schema_name }}.{{ model.tablename }}"),
-    )
 {% if anidadas.get('create_many') %}
     # Lo que cada registro crea en otras tablas pide el permiso de cada una, antes de escribir
     # nada: `field` lleva la posición en la lista (`3.etiquetas.0`).
@@ -67,23 +64,11 @@ async def {{ model.tablename }}_create_many(
                 session=session,
             )
 {% endif %}
-            # Como en `create`: cada fila tiene que ser del usuario, y si una no lo es, la
-            # excepción deshace también las que ya se habían insertado. Va en la misma
-            # transacción que la escritura, con la sesión que abrió el endpoint.
-            if propias:
-                for creado in creados:
-                    if await {{ dao }}.find(
-                        {% for column in model.columns if column.constraints.get('primary_key', False) %}
-                        {{ column.name }}=creado.{{ column.name }},
-                        {% endfor %}
-                        rls=propias,
-                        session=session,
-                    ) is None:
-                        raise owner_violation()
-{% if anidadas.get('create_many') %}
-            for posicion, (registro, creado) in enumerate(zip(registros, creados)):
-                await despues_de_crear(token, "{{ model.tablename }}", creado, registro, session, f"{posicion}.")
-{% endif %}
+            # Como en `create`: cada fila tiene que ser del usuario, y lo que se creó anidado con
+            # ella también; si una no lo es, la excepción deshace todo el lote. Va en la misma
+            # transacción que la escritura, y es una consulta por tabla y nivel para todo el lote,
+            # no una por registro (`field` lleva la posición: `3`, `3.etiquetas`).
+            await despues_de_crear_varias(token, "{{ model.tablename }}", creados, registros, session)
 
             return APIResponse.success(
                 data=creados,

{tai_api-0.7.2 → tai_api-0.7.4}/tai_api/generators/routers/templates/schema/_anidados.py.j2

@@ -97,6 +97,15 @@ CLAVES: Dict[str, Tuple[str, ...]] = {
 {% endfor %}
 }
 
+#: Cómo se pide un lote de filas por cada columna: `in` (`in_<columna>`), `range`
+#: (`min_<columna>`/`max_<columna>`); la que no está no se puede pedir por lote. Es el
+#: `filter_fields` del DAO.
+FILTROS: Dict[str, Dict[str, str]] = {
+{% for t in tablas %}
+    "{{ t.tablename }}": {{ t.filtros | tojson }},
+{% endfor %}
+}
+
 #: El nombre de cada tabla en los mensajes: el de su clase.
 NOMBRES: Dict[str, str] = {
 {% for t in tablas %}
@@ -364,33 +373,126 @@ async def _relacionadas(tabla: str, fila: Any, relación: str, session) -> list:
     return await DAOS[destino].find_many(**filtro, session=session)
 
 
-async def _comprobar_creada(token: Any, tabla: str, fila: Any, forma: Dict[str, dict], campo: str, session, cache) -> None:
-    """Una fila creada y lo que se creó con ella: tienen que ser del usuario (403 `OWNER`)."""
+async def _relacionadas_de(tabla: str, filas: List[Any], relación: str, session) -> List[list]:
+    """
+    `_relacionadas` de varias filas a la vez, en su orden: una consulta con `in_` por cada columna de
+    la unión, repartida después por fila. Si alguna columna no tiene `in_`, una consulta por fila.
+    """
+    destino, _, columnas, _ = RELACIONES[tabla][relación]
+    if len(filas) == 1 or any(FILTROS[destino].get(columna_destino) != "in" for columna_destino, _ in columnas):
+        return [await _relacionadas(tabla, fila, relación, session) for fila in filas]
+    uniones = [tuple(getattr(fila, columna_origen) for _, columna_origen in columnas) for fila in filas]
+    con_valor = [union for union in uniones if None not in union]
+    if not con_valor:
+        return [[] for _ in filas]
+    filtro = {
+        f"in_{columna_destino}": list({union[i] for union in con_valor})
+        for i, (columna_destino, _) in enumerate(columnas)
+    }
+    por_union: Dict[tuple, list] = {}
+    for hija in await DAOS[destino].find_many(**filtro, session=session):
+        por_union.setdefault(tuple(getattr(hija, columna_destino) for columna_destino, _ in columnas), []).append(hija)
+    return [por_union.get(union, []) for union in uniones]
+
+
+def _tupla(tabla: str, fila: Any) -> tuple:
+    return tuple(getattr(fila, columna) for columna in CLAVES[tabla])
+
+
+async def _primera_ajena(tabla: str, filas: List[Any], propias: list, session) -> Optional[int]:
+    """
+    La posición de la primera de `filas` que la regla no alcanza, o `None` si las alcanza todas.
+
+    Una consulta para todas, no una por fila: con una clave simple con `in_`, cuántas de esas claves
+    alcanza la regla; si no, las filas que alcanza entre las que acotan la lista o el rango de cada
+    columna de la clave (puede traer alguna más; lo que cuenta es que estén todas). La que no aparece
+    —ajena, o con un valor que vuelve de la base de datos con otra forma, como una fecha con zona— se
+    busca sola con la regla, que es la comprobación exacta: el lote solo ahorra las que confirma.
+    """
+    if not filas:
+        return None
+    dao, columnas = DAOS[tabla], CLAVES[tabla]
+    if len(columnas) == 1 and FILTROS[tabla].get(columnas[0]) == "in":
+        valores = list({getattr(fila, columnas[0]) for fila in filas})
+        if await dao.count(**{f"in_{columnas[0]}": valores}, rls=propias, session=session) == len(valores):
+            return None
+    acotado: Dict[str, Any] = {}
+    for columna in columnas:
+        valores = [getattr(fila, columna) for fila in filas]
+        if FILTROS[tabla].get(columna) == "in":
+            acotado[f"in_{columna}"] = list(set(valores))
+        elif FILTROS[tabla].get(columna) == "range":
+            try:
+                acotado[f"min_{columna}"], acotado[f"max_{columna}"] = min(valores), max(valores)
+            except TypeError:  # valores que no se comparan entre sí (fechas con y sin zona)
+                pass
+    alcanzadas = set()
+    if acotado:
+        alcanzadas = {_tupla(tabla, fila) for fila in await dao.find_many(**acotado, rls=propias, session=session)}
+    for posición, fila in enumerate(filas):
+        if _tupla(tabla, fila) in alcanzadas:
+            continue
+        if await dao.find(**_clave_fila(tabla, fila), rls=propias, session=session) is None:
+            return posición
+    return None
+
+
+async def _comprobar_filas(token: Any, tabla: str, filas: List[Tuple[Any, Dict[str, dict], str]], session, cache) -> None:
+    """
+    Filas de `tabla` recién creadas, cada una con lo que se creó con ella (`forma`) y su `field`: tienen
+    que ser del usuario (403 `OWNER`), y lo de debajo también. Una consulta por tabla y nivel para
+    todas, no una por fila.
+    """
     propias = _propias(token, tabla, cache)
-    if propias and await DAOS[tabla].find(**_clave_fila(tabla, fila), rls=propias, session=session) is None:
-        raise _en(owner_violation(), campo)
-    for relación, sub in forma.items():
+    if propias:
+        ajena = await _primera_ajena(tabla, [fila for fila, _, _ in filas], propias, session)
+        if ajena is not None:
+            raise _en(owner_violation(), filas[ajena][2])
+    await _bajar(token, tabla, [(fila, forma, f"{campo}.") for fila, forma, campo in filas], session, cache)
+
+
+async def _bajar(token: Any, tabla: str, padres: List[Tuple[Any, Dict[str, dict], str]], session, cache) -> None:
+    """
+    Lo que se creó bajo `padres` —filas de `tabla`, con su `forma` y el prefijo del `field` de lo suyo—,
+    relación a relación: las hijas de todos los padres en una consulta, y comprobadas todas juntas.
+    """
+    for relación in sorted({relación for _, forma, _ in padres for relación in forma}):
         destino = RELACIONES[tabla][relación][0]
-        if not (_propias(token, destino, cache) or _alcanza(token, destino, sub, cache)):
+        con_ella = [(fila, forma[relación], prefijo) for fila, forma, prefijo in padres if relación in forma]
+        if not any(_propias(token, destino, cache) or _alcanza(token, destino, sub, cache) for _, sub, _ in con_ella):
             continue
-        for hija in await _relacionadas(tabla, fila, relación, session):
-            await _comprobar_creada(token, destino, hija, sub, f"{campo}.{relación}", session, cache)
+        hijas = await _relacionadas_de(tabla, [fila for fila, _, _ in con_ella], relación, session)
+        await _comprobar_filas(token, destino, [
+            (hija, sub, f"{prefijo}{relación}")
+            for (_, sub, prefijo), suyas in zip(con_ella, hijas)
+            for hija in suyas
+        ], session, cache)
 
 
 async def despues_de_crear(token: Any, tabla: str, creada: Any, cuerpo: Any, session, prefijo: str = "") -> None:
     """
-    Después de un `create` (`POST`, `/bulk`, el `create` de `_tx`), en su transacción: lo que se creó
-    anidado en `creada` tiene que ser del usuario. La fila de arriba la comprueba el endpoint.
+    Después de un `create` (`POST`, el `create` de `_tx`), en su transacción: lo que se creó anidado en
+    `creada` tiene que ser del usuario. La fila de arriba la comprueba el endpoint.
 
     Solo cuesta consultas si alguna tabla de lo creado tiene reglas de propietario.
     """
-    cache: Dict[str, list] = {}
-    for relación, sub in _forma(tabla, cuerpo).items():
-        destino = RELACIONES[tabla][relación][0]
-        if not (_propias(token, destino, cache) or _alcanza(token, destino, sub, cache)):
-            continue
-        for hija in await _relacionadas(tabla, creada, relación, session):
-            await _comprobar_creada(token, destino, hija, sub, f"{prefijo}{relación}", session, cache)
+    await _bajar(token, tabla, [(creada, _forma(tabla, cuerpo), prefijo)], session, {})
+
+
+async def despues_de_crear_varias(token: Any, tabla: str, creadas: List[Any], cuerpos: List[Any], session) -> None:
+    """
+    Después de `create_many` (`/bulk`), en su transacción: cada fila creada y lo que se creó anidado
+    con ella tiene que ser del usuario. El `field` de un 403 lleva la posición en la lista (`3`, o
+    `3.etiquetas` si es lo anidado).
+
+    Todo el lote a la vez: una consulta por tabla y nivel, no una por registro. Era un `find` por
+    fila, y con mil registros por petición eran mil viajes a la base de datos. Solo cuesta consultas
+    si alguna tabla de lo creado tiene reglas de propietario.
+    """
+    await _comprobar_filas(token, tabla, [
+        (creada, _forma(tabla, cuerpo), str(posición))
+        for posición, (creada, cuerpo) in enumerate(zip(creadas, cuerpos))
+    ], session, {})
 
 
 @dataclass
@@ -479,8 +581,10 @@ async def despues_de_escribir(token: Any, plan: Plan, session) -> None:
         fila = await DAOS[grupo.tabla].find(**ahora, session=session)
         if fila is None:
             continue
-        for hija in await _relacionadas(grupo.tabla, fila, grupo.relacion, session):
-            if _congelada(_clave_fila(destino, hija)) in grupo.antes:
-                continue
-            await _comprobar_creada(token, destino, hija, grupo.forma, grupo.campo, session, plan.cache)
+        nuevas = [
+            (hija, grupo.forma, grupo.campo)
+            for hija in await _relacionadas(grupo.tabla, fila, grupo.relacion, session)
+            if _congelada(_clave_fila(destino, hija)) not in grupo.antes
+        ]
+        await _comprobar_filas(token, destino, nuevas, session, plan.cache)
 {% endif %}

{tai_api-0.7.2 → tai_api-0.7.4}/tai_api/generators/ts_client/tipos.py

@@ -197,7 +197,7 @@ def row(info: dict, t: Traductor) -> Interfaz:
         else:
             tipo = t.tipo(c)
             campos.append(Campo(c['name'], _nulable(tipo) if c['nullable'] else tipo, doc=t.doc(c), formato=formato(c)))
-    if info.get('has_self_reference'):
+    if info.get('has_hierarchy'):
         campos += [
             Campo('tree_level', 'number | null', opcional=True),
             Campo('descendants', f"{info['name']}Row[] | null", opcional=True),

{tai_api-0.7.2 → tai_api-0.7.4}/tai_api/rbac/providers/database/auth/_shared/__init__.py

@@ -43,6 +43,12 @@ from .aggregation import (
     GROUP_BY_DATETIME_TYPES,
 )
 
+from .utils.hierarchy import (
+    HierarchyResolver,
+    HierarchyConfig,
+    TreeMode,
+    TreeNode,
+)
 
 
 __all__ = [
@@ -79,4 +85,8 @@ __all__ = [
     'OPERATION_FUNCTIONS',
     'GROUP_BY_FORBIDDEN_TYPES',
     'GROUP_BY_DATETIME_TYPES',
+    'HierarchyResolver',
+    'HierarchyConfig',
+    'TreeMode',
+    'TreeNode',
 ]