tai-sql 0.7.2__tar.gz → 0.7.8__tar.gz

{tai_sql-0.7.2 → tai_sql-0.7.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tai-sql
-Version: 0.7.2
+Version: 0.7.8
 Summary: SQL database management and code generation tool
 License-Expression: MIT
 License-File: LICENSE
@@ -22,9 +22,12 @@ Provides-Extra: bigquery
 Provides-Extra: deploy
 Provides-Extra: diagrams
 Provides-Extra: encryption
+Provides-Extra: hashing
 Provides-Extra: mysql
 Provides-Extra: sqlserver
 Provides-Extra: vectors
+Requires-Dist: bcrypt (>=4.0.0,<6.0) ; extra == "all"
+Requires-Dist: bcrypt (>=4.0.0,<6.0) ; extra == "hashing"
 Requires-Dist: click (>=8.2.1,<9.0)
 Requires-Dist: cryptography (>=45.0.4,<46.0) ; extra == "all"
 Requires-Dist: cryptography (>=45.0.4,<46.0) ; extra == "encryption"

{tai_sql-0.7.2 → tai_sql-0.7.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tai-sql"
-version = "0.7.2"
+version = "0.7.8"
 description = "SQL database management and code generation tool"
 license = "MIT"
 license-files = ["LICENSE"]
@@ -89,6 +89,9 @@ bigquery = ["sqlalchemy-bigquery>=1.11.0,<2.0"]
 #     Graphviz en el sistema (`apt install graphviz`), que pip no instala.
 vectors = ["pgvector>=0.3.0,<1.0"]
 encryption = ["cryptography>=45.0.4,<46.0"]
+# `hashing`: alguna `column(hash=True)`. Lo necesitan `feed` —hashea lo que inserta— y
+#     `hash-migrate`, que reescribe una columna ya existente.
+hashing = ["bcrypt>=4.0.0,<6.0"]
 diagrams = ["graphviz>=0.20.3,<1.0"]
 
 # ── Comandos concretos del CLI ────────────────────────────────────────────────
@@ -110,6 +113,7 @@ all = [
     "sqlalchemy-bigquery>=1.11.0,<2.0",
     "pgvector>=0.3.0,<1.0",
     "cryptography>=45.0.4,<46.0",
+    "bcrypt>=4.0.0,<6.0",
     "graphviz>=0.20.3,<1.0",
     "tai-storage>=0.1.0",
     "tai-alphi>=2.0.1,<3.0",

{tai_sql-0.7.2 → tai_sql-0.7.8}/tai_sql/cli/commands/__init__.py

@@ -2,6 +2,7 @@ from .cmd_deploy import push
 from .cmd_schema import new_schema, set_default_schema
 from .cmd_init import init
 from .cmd_generate import generate, run_generate
+from .cmd_hash_migrate import hash_migrate
 from .cmd_ping import ping
 from .cmd_info import info
 from .cmd_feed import feed
@@ -17,6 +18,7 @@ __all__ = [
     'init',
     'generate',
     'run_generate',
+    'hash_migrate',
     'ping',
     'info',
     'push',

tai_sql-0.7.8/tai_sql/cli/commands/cmd_hash_migrate/__init__.py

@@ -0,0 +1,3 @@
+from .main import hash_migrate
+
+__all__ = ['hash_migrate']

tai_sql-0.7.8/tai_sql/cli/commands/cmd_hash_migrate/main.py

@@ -0,0 +1,164 @@
+# -*- coding: utf-8 -*-
+"""
+`tai-sql hash-migrate`: pasa a hash una columna que hoy está cifrada o en claro.
+
+Existe por una ventana que se cierra sola. Mientras lo almacenado siga siendo reversible
+—`column(encrypt=True)` cifra con Fernet— se puede leer el valor original y volver a
+escribirlo hasheado **sin que nadie tenga que volver a entrar**. En cuanto alguien cambie
+la declaración a `hash=True` y empiece a escribir hashes encima, esa posibilidad
+desaparece y solo queda el reseteo masivo de contraseñas.
+"""
+from __future__ import annotations
+
+import click
+import sqlalchemy as sa
+
+from tai_sql import pm
+from tai_sql.crypto import build_cipher
+from tai_sql.errors import ErrorCode, SchemaDefinitionError
+
+from ...preamble import available_schemas, load_schema
+from ..prompts import select_one
+
+#: Prefijos con los que empieza un hash de bcrypt. Lo que ya los lleva está migrado.
+PREFIJOS_BCRYPT = ('$2a$', '$2b$', '$2x$', '$2y$')
+
+
+def ya_esta_hasheado(valor: str) -> bool:
+    return isinstance(valor, str) and valor.startswith(PREFIJOS_BCRYPT)
+
+
+@click.command('hash-migrate')
+@click.option('--schema', '-s', help='Nombre del esquema')
+@click.option('--table', '-t', required=True, help='Tabla que contiene la columna')
+@click.option('--column', '-c', 'columna', required=True, help='Columna a migrar')
+@click.option('--dry-run', '-d', is_flag=True, help='Cuenta lo que cambiaría, sin escribir')
+def hash_migrate(schema: str, table: str, columna: str, dry_run: bool):
+    """Convierte a hash los valores de una columna declarada con hash=True."""
+    if not schema:
+        schema = select_one('Selecciona el esquema', available_schemas())
+    load_schema(schema)
+
+    modelo = pm.db.schema_model
+    entidad = next(
+        (e for e in modelo.entities if e.tablename == table), None
+    )
+    if entidad is None:
+        raise SchemaDefinitionError(
+            message=f"La tabla '{table}' no existe en el schema '{schema}'",
+            solution=(
+                'Usa el nombre de tabla tal y como lo declara `__tablename__`: '
+                + ', '.join(sorted(e.tablename for e in modelo.entities))
+            ),
+            code=ErrorCode.MISSING_TABLE,
+        )
+
+    col = entidad.columns.get(columna)
+    if col is None:
+        raise SchemaDefinitionError(
+            message=f"La columna '{columna}' no existe en '{table}'",
+            solution='Columnas disponibles: ' + ', '.join(sorted(entidad.columns)),
+            code=ErrorCode.INVALID_COLUMN,
+        )
+
+    if not col.hash:
+        raise SchemaDefinitionError(
+            message=f"La columna '{table}.{columna}' no está declarada con hash=True",
+            solution=(
+                'Migrar una columna a hash es de ida: primero se declara '
+                f'`{columna}: col[str] = column(hash=True)` en el schema y se ejecuta '
+                '`tai-sql push`, y solo después se migran los valores'
+            ),
+            code=ErrorCode.INVALID_COLUMN,
+        )
+
+    claves = [c.name for c in entidad.columns.values() if c.is_primary_key]
+    if not claves:
+        raise SchemaDefinitionError(
+            message=f"La tabla '{table}' no tiene clave primaria",
+            solution='Sin ella no hay forma de reescribir cada fila por separado',
+            code=ErrorCode.INVALID_CONSTRAINT,
+        )
+
+    _migrar(schema, entidad.tablename, columna, claves, dry_run)
+
+
+def _migrar(schema: str, tabla: str, columna: str, claves: list[str], dry_run: bool) -> None:
+    import bcrypt
+
+    cipher = build_cipher(pm.db.secret_key_name)
+    if cipher is None:
+        # Sin cifrador no se puede revertir nada: lo que haya se tratará como valor en
+        # claro. Es correcto si la columna nunca estuvo cifrada, y una pérdida silenciosa
+        # si lo estuvo, así que se dice antes de tocar nada.
+        click.echo(click.style(
+            f"⚠️  No hay cifrador: falta cryptography o la variable "
+            f"'{pm.db.secret_key_name}'. Si la columna estaba cifrada, aborta y "
+            f"configúrala; si estaba en claro, puedes continuar.",
+            fg='yellow',
+        ))
+        if not dry_run and not click.confirm('¿Continuar?', default=False):
+            raise click.Abort()
+
+    metadata = sa.MetaData()
+    tabla_sa = sa.Table(
+        tabla, metadata,
+        *[sa.Column(nombre, sa.String, primary_key=True) for nombre in claves],
+        sa.Column(columna, sa.String),
+        schema=pm.db.schema_name,
+    )
+
+    engine = pm.db.provider.engine
+    cifrados = planos = ya_hechos = nulos = 0
+
+    click.echo(f"🔐 Migrando {tabla}.{columna} a hash" + (' (dry-run)' if dry_run else ''))
+
+    with engine.begin() as conexion:
+        filas = conexion.execute(
+            sa.select(*[tabla_sa.c[n] for n in claves], tabla_sa.c[columna])
+        ).all()
+
+        for fila in filas:
+            valor = fila[-1]
+            identidad = dict(zip(claves, fila[:-1]))
+
+            if valor is None:
+                nulos += 1
+                continue
+            if ya_esta_hasheado(valor):
+                ya_hechos += 1
+                continue
+
+            try:
+                if cipher is None:
+                    raise ValueError('sin cifrador')
+                original = cipher.decrypt(valor.encode()).decode()
+                cifrados += 1
+            except Exception:
+                # Ni hash ni cifrado: es el valor en claro, y hashearlo es justo lo que
+                # esta migración viene a hacer.
+                original = valor
+                planos += 1
+
+            if not dry_run:
+                nuevo = bcrypt.hashpw(original.encode(), bcrypt.gensalt()).decode()
+                conexion.execute(
+                    sa.update(tabla_sa)
+                    .where(sa.and_(*[tabla_sa.c[n] == v for n, v in identidad.items()]))
+                    .values(**{columna: nuevo})
+                )
+
+    click.echo()
+    click.echo(f"   Descifradas y hasheadas : {cifrados}")
+    click.echo(f"   En claro, hasheadas     : {planos}")
+    click.echo(f"   Ya estaban hasheadas    : {ya_hechos}")
+    click.echo(f"   Nulas, sin tocar        : {nulos}")
+    click.echo()
+
+    if dry_run:
+        click.echo(click.style('Nada escrito: era una simulación.', fg='yellow'))
+    else:
+        click.echo(click.style(
+            f'✅ {cifrados + planos} filas migradas. Volver a ejecutarlo no cambia nada.',
+            fg='green',
+        ))

{tai_sql-0.7.2 → tai_sql-0.7.8}/tai_sql/cli/commands/cmd_init/model.py

@@ -52,6 +52,8 @@ PYPROJECT_TEMPLATE = dedent('''\
 
     # Funcionalidades opcionales
     encryption = ["cryptography (>=45.0.4,<46.0)"]
+    # column(hash=True): el cliente hashea al escribir y verifica al comprobar.
+    hashing = ["bcrypt (>=4.0.0,<6.0)"]
     vectors = ["pgvector (>=0.4.0,<1.0)"]
     # Encoders de columnas vectoriales. El cliente generado los implementa sobre
     # langchain, así que estas son las librerías que importa de verdad; deja solo la

{tai_sql-0.7.2 → tai_sql-0.7.8}/tai_sql/cli/commands/cmd_schema/schemas/auth.py

@@ -96,7 +96,7 @@ class AuthSchema(SchemaTemplate):
                       
                 first_name: col[str | None] = column(description="Nombre del usuario")
                 last_name: col[str | None] = column(description="Apellido del usuario")
-                password: col[str] = column(encrypt=True, description="Contraseña encriptada")
+                password: col[str] = column(hash=True, description="Contraseña hasheada: solo se puede verificar, no leer")
                 email: col[str | None] = column(description="Correo electrónico")
                 is_active: col[bool] = column(default=True, description="Usuario activo")
                 session_id: col[str | None] = column(description="ID de sesión actual (para control de concurrencia)")
@@ -120,8 +120,11 @@ class AuthSchema(SchemaTemplate):
                         )
                     ]
                 
+                # Opcional: nombre y apellidos lo son, y sin ninguno de los dos no hay nombre
+                # completo que calcular. Declarada `-> str`, la columna era NOT NULL y crear un
+                # usuario sin nombre fallaba con una violación de integridad.
                 @calculated_column
-                def full_name(self) -> str:
+                def full_name(self) -> Optional[str]:
                     return f"{self.first_name or ''} {self.last_name or ''}".strip() if self.first_name or self.last_name else None
 
 
@@ -187,6 +190,10 @@ class AuthSchema(SchemaTemplate):
             class UserRole(Table):
                 """Relación M2M entre User y Role"""
                 __tablename__ = "user_role"
+                # Un usuario tiene un rol una vez. Es además la clave natural por la que
+                # `tai-sql feed` reconoce la fila: sin ella se negaba a alimentar la tabla,
+                # y un proyecto nuevo se quedaba sin el usuario admin.
+                __constraints__ = unique_constraint("user_name", "role_name", "realm_name")
 
                 id: col[bigint] = column(primary_key=True, autoincrement=True)
                 user_name: col[str] = column(description="ID del usuario")
@@ -206,6 +213,8 @@ class AuthSchema(SchemaTemplate):
             class RolePermission(Table):
                 """Relación M2M entre Role y Permission"""
                 __tablename__ = "role_permission"
+                # Un rol tiene un permiso una vez; y es la clave natural del feed, como en UserRole.
+                __constraints__ = unique_constraint("role_name", "permission_name", "realm_name")
 
                 id: col[bigint] = column(primary_key=True, autoincrement=True)
                 role_name: col[str] = column(description="ID del rol")

{tai_sql-0.7.2 → tai_sql-0.7.8}/tai_sql/cli/main.py

@@ -15,6 +15,7 @@ hacer.
 import click
 
 from .commands import (
+    hash_migrate,
     # deploy_config,
     new_schema,
     set_default_schema,
@@ -50,6 +51,7 @@ cli.add_command(new_schema)
 cli.add_command(set_default_schema)
 cli.add_command(init)
 cli.add_command(generate)
+cli.add_command(hash_migrate)
 cli.add_command(ping)
 cli.add_command(info)
 cli.add_command(push)

{tai_sql-0.7.2 → tai_sql-0.7.8}/tai_sql/feed/README.md

@@ -11,7 +11,7 @@ collect.py    ¿qué filas declara el schema?      invoca feed(), sin BD
 resolve       — no existe: la resolución de referencias es del ejecutor,
                 que es quien conoce las claves que acaba de generar la BD
 plan.py       ¿en qué orden, con qué clave?      compone; no implementa ni una ni otra
-transform.py  cifrado, enums, defaults, vectores
+transform.py  cifrado, hash, enums, defaults, vectores
 executor.py   aplicarlo, en una transacción
 presenter.py  todo el click.echo
 feeder.py     la fachada
@@ -42,6 +42,22 @@ result = feeder.execute(plan)     # 4. aplicarlas
 
 Sin presentador no dice nada, que es como lo usan los tests.
 
+## Las columnas protegidas
+
+Una columna `encrypt=True` se cifra con la clave de `tai_sql/crypto.py`, y una `hash=True` se
+hashea con el mismo bcrypt que usa el cliente generado. Sin la clave, o sin bcrypt, el feed **se
+niega a empezar** (`_check_encryption`, `_check_hashing`): insertar en claro no es una opción.
+
+**Una columna hasheada se escribe al crear la fila y no se reescribe en un upsert.** Lo que
+declara un `feed()` es su valor inicial —la contraseña con la que nace el usuario admin del
+schema `auth`—, no el vigente. Si el upsert la reescribiera, volver a lanzar `tai-sql feed`
+devolvería a su valor de fábrica la contraseña que alguien ya había cambiado; y como cada hash
+lleva su salt, además cambiaría la fila en cada ejecución. Un valor que ya es un hash bcrypt se
+inserta tal cual, así que un `feed()` puede declarar uno precalculado.
+
+Hasta la 0.7.7 el feed cifraba pero **no hasheaba**: toda columna `hash=True` se insertaba en
+claro, incluida la contraseña del admin de cualquier proyecto con autenticación Database.
+
 ## Las cuatro decisiones que lo ordenan
 
 ### 1. No estrena ninguna pieza cuyo propósito ya tuviera dueño

{tai_sql-0.7.2 → tai_sql-0.7.8}/tai_sql/feed/executor.py

@@ -371,11 +371,20 @@ class FeedExecutor:
         return valor
 
     def _update_columns(self, plan: FeedPlan, rows) -> list[str]:
-        """Qué columnas se actualizan si la fila ya existía: todas menos la clave."""
+        """
+        Qué columnas se actualizan si la fila ya existía: todas menos la clave y las hasheadas.
+
+        Una columna hasheada se escribe al crear la fila y no se reescribe después. Lo que
+        declara un `feed()` es su valor **inicial** —la contraseña con la que nace el usuario
+        admin—, no el vigente: reescribirla en cada `tai-sql feed` devolvería a su valor de
+        fábrica la contraseña que alguien ya había cambiado. Y como cada hash lleva su propio
+        salt, además cambiaría la fila en cada ejecución aunque nada hubiera cambiado.
+        """
         if not plan.conflict_columns:
             return []
+        hasheadas = {c.name for c in plan.table.hashed_columns}
         columnas = {name for row in rows for name in row}
-        return [c for c in columnas if c not in plan.conflict_columns]
+        return [c for c in columnas if c not in plan.conflict_columns and c not in hasheadas]
 
     def _table_of(self, plan: FeedPlan) -> SQLAlchemyTable:
         """La `Table` de SQLAlchemy de una tabla del plan."""

{tai_sql-0.7.2 → tai_sql-0.7.8}/tai_sql/feed/feeder.py

@@ -80,6 +80,7 @@ class Feeder:
                 reconocerse. Sin esto es un error: ver `_check_conflict_keys`.
         """
         self._check_encryption()
+        self._check_hashing()
 
         rows = collect(self.schema, table_filter, on_warning=self.presenter.warning)
         plan = build_plan(self.schema, rows)
@@ -157,6 +158,29 @@ class Feeder:
             code=ErrorCode.MISSING_ENV_VAR,
         )
 
+    def _check_hashing(self) -> None:
+        """
+        Sin bcrypt, una columna hasheada no se puede escribir. Se corta antes de empezar.
+
+        Si se dejara llegar al primer insert, las tablas anteriores ya estarían
+        alimentadas; y guardarla en claro, que es lo que hacía el feed, no es una opción.
+        """
+        hasheadas = transform.hashed_columns_by_table(self.schema.tables.values())
+        if not hasheadas:
+            return
+        try:
+            import bcrypt  # noqa: F401
+        except ImportError:
+            detalle = '\n'.join(
+                f"      • {tabla}: {', '.join(columnas)}"
+                for tabla, columnas in sorted(hasheadas.items())
+            )
+            raise TaiSqlEnvironmentError(
+                message=f"El schema declara columnas hasheadas y bcrypt no está instalado:\n{detalle}",
+                solution="Instala el extra que las hashea: pip install 'tai-sql[hashing]'",
+                code=ErrorCode.OPERATION_FAILED,
+            )
+
     def _check_conflict_keys(self, plan: Sequence[FeedPlan]) -> None:
         """
         Una tabla sin clave de conflicto no se puede alimentar dos veces.

{tai_sql-0.7.2 → tai_sql-0.7.8}/tai_sql/feed/transform.py

@@ -4,10 +4,11 @@ Lo que le pasa a una fila entre que se declara y se inserta.
 
 CAPA 3 — transformación (`tai_sql/feed/`).
 
-Cuatro pasos, y **ninguno inventa una regla nueva**: los defaults salen del modelo, la
-clave de cifrado de `tai_sql/crypto.py` y la forma de un valor enumerado es la de siempre.
-Están juntos aquí porque los cuatro son lo mismo —una fila entra y sale—, y porque así el
-ejecutor no sabe nada de cifrado ni de enums: solo manda la fila a la base de datos.
+Cinco pasos, y **ninguno inventa una regla nueva**: los defaults salen del modelo, la
+clave de cifrado de `tai_sql/crypto.py`, el hash es el mismo bcrypt que usa el cliente
+generado y la forma de un valor enumerado es la de siempre. Están juntos aquí porque los
+cinco son lo mismo —una fila entra y sale—, y porque así el ejecutor no sabe nada de
+cifrado, hashes ni enums: solo manda la fila a la base de datos.
 """
 from __future__ import annotations
 
@@ -19,7 +20,7 @@ from ..errors import ErrorCode, SchemaDefinitionError
 if TYPE_CHECKING:
     from ..orm.model import TableModel
 
-__all__ = ['prepare', 'check_vectors', 'encrypted_columns_by_table']
+__all__ = ['prepare', 'check_vectors', 'encrypted_columns_by_table', 'hashed_columns_by_table']
 
 
 def prepare(
@@ -37,7 +38,8 @@ def prepare(
     row = _fill_defaults(table, row)
     row = _drop_generated(table, row)
     row = _normalize_enums(row)
-    return _encrypt(table, row, cipher)
+    row = _encrypt(table, row, cipher)
+    return _hash(table, row)
 
 
 def check_vectors(table: TableModel, values: Mapping[str, Any]) -> None:
@@ -89,8 +91,17 @@ def encrypted_columns_by_table(tables) -> dict[str, list[str]]:
     }
 
 
+def hashed_columns_by_table(tables) -> dict[str, list[str]]:
+    """Las columnas hasheadas de cada tabla, para comprobar de antemano que se puede hashear."""
+    return {
+        table.tablename: [c.name for c in table.hashed_columns]
+        for table in tables
+        if table.hashed_columns
+    }
+
+
 # ─────────────────────────────────────────────────────────────────────────
-#  Los cuatro pasos
+#  Los cinco pasos
 # ─────────────────────────────────────────────────────────────────────────
 
 def _fill_defaults(table: TableModel, row: dict[str, Any]) -> dict[str, Any]:
@@ -160,3 +171,34 @@ def _encrypt(
         )
         for name, value in row.items()
     }
+
+
+#: Con esto empieza un hash bcrypt. Un valor que ya lo es se inserta tal cual, así que un
+#: `feed()` puede declarar un hash precalculado en vez de la contraseña.
+PREFIJOS_BCRYPT = ('$2a$', '$2b$', '$2x$', '$2y$')
+
+
+def _hash(table: TableModel, row: dict[str, Any]) -> dict[str, Any]:
+    """
+    Hashea las columnas marcadas con `hash=True`, con el mismo bcrypt que el cliente generado.
+
+    No lo hacía: el feed cifraba las columnas `encrypt=True` y dejaba las hasheadas **en
+    claro**. El usuario `admin` que el schema `auth` crea con su `feed()` quedaba con la
+    contraseña legible en la base de datos, y `verify_password` no podía comprobarla porque
+    lo guardado no era un hash.
+    """
+    hasheadas = {c.name for c in table.hashed_columns}
+    if not hasheadas:
+        return row
+
+    import bcrypt  # comprobado de antemano por el feeder: ver `_check_hashing`
+
+    def _hashear(valor):
+        if valor is None or (isinstance(valor, str) and valor.startswith(PREFIJOS_BCRYPT)):
+            return valor
+        return bcrypt.hashpw(str(valor).encode(), bcrypt.gensalt()).decode()
+
+    return {
+        name: _hashear(value) if name in hasheadas else value
+        for name, value in row.items()
+    }

{tai_sql-0.7.2 → tai_sql-0.7.8}/tai_sql/generators/python_client/__init__.py

@@ -259,6 +259,10 @@ class PythonClientGenerator(BaseGenerator):
     def has_encrypted_columns(self) -> bool:
         return any(entity.encrypted_columns for entity in self.schema.entities)
 
+    @property
+    def has_hashed_columns(self) -> bool:
+        return any(entity.hashed_columns for entity in self.schema.entities)
+
     def validate_encryption_setup(self):
         if not self.has_encrypted_columns:
             return
@@ -294,6 +298,9 @@ class PythonClientGenerator(BaseGenerator):
     def _model_has_encrypt(self, entity: EntityModel) -> bool:
         return bool(entity.encrypted_columns)
 
+    def _model_has_hash(self, entity: EntityModel) -> bool:
+        return bool(entity.hashed_columns)
+
     def _model_has_calculated(self, entity: EntityModel) -> bool:
         return any(col.is_calculated for col in entity.columns.values())
 
@@ -371,6 +378,7 @@ class PythonClientGenerator(BaseGenerator):
         code = template.render(
             has_dict=has_dict,
             has_encrypted_columns=self.has_encrypted_columns,
+            has_hashed_columns=self.has_hashed_columns,
             secret_key_name=self.schema.secret_key_name,
         )
         (schema_dir / '_base.py').write_text(code, encoding='utf-8')
@@ -480,6 +488,7 @@ class PythonClientGenerator(BaseGenerator):
             is_postgres=getattr(self.provider, 'drivername', None) == 'postgresql',
             schema_name=self.schema.name,
             encrypt=self._model_has_encrypt(entity),
+            hash=self._model_has_hash(entity),
             has_calculated=self._model_has_calculated(entity),
             import_prefix=self.import_layout.domain_prefix,
             cross_domain_infix=self.import_layout.cross_domain_infix,

{tai_sql-0.7.2 → tai_sql-0.7.8}/tai_sql/generators/python_client/context.py

@@ -215,6 +215,7 @@ class TemplateContextBuilder:
             'is_foreign_key': column.is_foreign_key,
             'default': constraints['default'],
             'encrypt': column.encrypt,
+            'hash': column.hash,
             'constraints': constraints,
             'description': (
                 column.description or f"Campo {column.name} de la tabla {tablename}"

tai_sql-0.7.8/tai_sql/generators/python_client/templates/base.py.jinja2

@@ -0,0 +1,90 @@
+# Este archivo ha sido generado automáticamente por tai-sql
+# No modifiques este archivo directamente
+
+from __future__ import annotations
+from typing import List, Optional{% if has_dict %}, Dict, Any{% endif %}
+
+from sqlalchemy.orm import DeclarativeBase
+{% if has_encrypted_columns %}
+import os
+from cryptography.fernet import Fernet
+import base64
+{% endif %}
+{% if has_hashed_columns %}
+import bcrypt
+{% endif %}
+
+
+class Base(DeclarativeBase):
+    pass
+
+{% if has_encrypted_columns %}
+
+# Configuración de encriptación
+_secret_key = os.getenv('{{ secret_key_name }}')
+if not _secret_key:
+    raise ValueError(
+        f"Variable de entorno '{{ secret_key_name }}' no encontrada para encriptación. "
+        f"Por favor, configure la variable de entorno '{{ secret_key_name }}' en su sistema "
+        f"con una clave secreta segura antes de ejecutar la aplicación. "
+        f"Ejemplo: export {{ secret_key_name }}='su-clave-secreta-de-32-caracteres-aqui'"
+    )
+
+# Generar clave Fernet desde la clave secreta
+_fernet_key = base64.urlsafe_b64encode(_secret_key.encode()[:32].ljust(32, b'\0'))
+_cipher = Fernet(_fernet_key)
+
+def encrypt_value(value: str) -> str:
+    """Encripta un valor string"""
+    if value is None:
+        return None
+    return _cipher.encrypt(value.encode()).decode()
+
+def decrypt_value(value: str) -> str:
+    """Desencripta un valor string"""
+    if value is None:
+        return None
+    return _cipher.decrypt(value.encode()).decode()
+
+{% endif %}
+{% if has_hashed_columns %}
+
+# ── Hashing ──────────────────────────────────────────────────────────────────
+#
+# Distinto del cifrado de arriba y no intercambiable: esto es de ida. El valor original
+# no queda en ninguna parte, así que no se puede leer — solo comprobar si un candidato
+# coincide. No lleva clave: el salt va dentro del propio hash, y por eso dos filas con
+# el mismo valor guardan textos distintos.
+
+def hash_value(value: str) -> str:
+    """Hashea un valor. Devuelve None si el valor es None."""
+    if value is None:
+        return None
+    return bcrypt.hashpw(value.encode(), bcrypt.gensalt()).decode()
+
+
+#: Un hash bcrypt válido, del mismo coste que `gensalt()` por defecto (12), que no
+#: corresponde a nada. Sirve para comprobar un candidato cuando la fila no existe: sin
+#: él, «no existe» respondía al instante y «no coincide» tras el bcrypt (~200 ms), y esa
+#: diferencia basta para averiguar desde fuera qué usuarios hay. Si algún día se sube el
+#: coste de `gensalt()`, hay que regenerarlo con el mismo.
+HASH_DE_RELLENO = "$2b$12$diGTNtGT.nEOuDdpfJHsD.4nO.d3Pk41jUWW9/OizA//1Aa3So30S"
+
+
+def verify_hash(value: str, hashed: str) -> bool:
+    """
+    Comprueba si un valor corresponde a un hash.
+
+    Devuelve False ante cualquier entrada que no sea comparable —None, o un hash con un
+    formato que bcrypt no reconoce, como el de una fila que aún no se ha migrado— en vez
+    de propagar la excepción: quien pregunta esto está autenticando, y un error ahí es un
+    «no» y no una caída.
+    """
+    if value is None or hashed is None:
+        return False
+    try:
+        return bcrypt.checkpw(value.encode(), hashed.encode())
+    except (ValueError, TypeError):
+        return False
+
+{% endif %}

{tai_sql-0.7.2 → tai_sql-0.7.8}/tai_sql/generators/python_client/templates/domain/dao.py.jinja2

@@ -85,6 +85,9 @@ from {{ import_prefix }}_shared import (
 )
 {% endif %}
 from {{ import_prefix }}_session import {{ session_manager_var }}
+{% if model.columns | selectattr('hash') | list %}
+from {{ import_prefix }}_base import verify_hash, HASH_DE_RELLENO
+{% endif %}
 {# ── Collect cross-DAO targets (relations + trigger cross-table ops) ── #}
 {% set _cross_dao_targets = [] %}
 {% for rel in model.relations | default([]) %}
@@ -112,6 +115,28 @@ if TYPE_CHECKING:
 
 # Logger
 logger = Alphi.get_logger_by_name("{{ logger_name }}")
+{# Las columnas cifradas o hasheadas. Su valor no puede escribirse en un log —el de una
+    cifrada es justo lo que se protege, el de una hasheada es una contraseña en claro— ni
+    llegar a la base de datos sin pasar por su setter, que es quien cifra o hashea. Se
+    calcula aquí, a nivel de plantilla, porque lo usan los macros incluidos de escritura. -#}
+{% set columnas_protegidas = (model.columns | selectattr('encrypt') | map(attribute='name') | list)
+                            + (model.columns | selectattr('hash') | map(attribute='name') | list) %}
+{% if columnas_protegidas %}
+
+#: Columnas cuyo valor no se escribe en los logs y no se actualiza con un UPDATE directo:
+#: las cifradas y las hasheadas. Ver `_para_log` y `update_many`.
+_COLUMNAS_PROTEGIDAS = frozenset({{ columnas_protegidas | tojson }})
+
+
+def _para_log(valores: dict) -> dict:
+    """
+    Los valores de una escritura, listos para un log: los protegidos, enmascarados.
+
+    Los logs de `update` y `update_many` volcaban los valores tal cual, así que cambiar
+    una contraseña la dejaba en claro en el log de la aplicación.
+    """
+    return {clave: ('***' if clave in _COLUMNAS_PROTEGIDAS else valor) for clave, valor in valores.items()}
+{% endif %}
 
 {% set vector_cols_with_encoder = model.columns | selectattr('type', 'equalto', 'vector') | selectattr('has_encoder') | list %}
 {% if vector_cols_with_encoder %}