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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tai-sql
-Version: 0.7.2
+Version: 0.7.9
 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.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tai-sql"
-version = "0.7.2"
+version = "0.7.9"
 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.9}/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.9/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.9/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.9}/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.9}/tai_sql/cli/commands/cmd_schema/schemas/auth.py

@@ -35,7 +35,7 @@ class AuthSchema(SchemaTemplate):
                 provider=env('MAIN_DATABASE_URL'),
                 schema='auth',
                 syntax='v2',
-                operative_fields=False,
+                operative_fields=True, # Añade created_at, updated_at, created_by, updated_by a todas las tablas
             )
 
             # Configurar los generadores
@@ -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")