tai-api 0.2.5__py3-none-any.whl

tai_api/__init__.py

@@ -0,0 +1,19 @@
+from .project import ProjectManager as pm
+from .config import (
+    ProjectConfig,
+    AuthConfig,
+    AuthType,
+    DatabaseAuthConfig,
+    KeycloakAuthConfig
+)
+from .generators import MainFileGenerator
+
+__all__ = [
+    'ProjectConfig',
+    'AuthConfig',
+    'AuthType',
+    'DatabaseAuthConfig',
+    'KeycloakAuthConfig',
+    'MainFileGenerator',
+    'pm'
+]

tai_api/cli/commands/__init__.py

@@ -0,0 +1,13 @@
+from .cmd_generate import generate
+from .cmd_init import init
+from .cmd_dev import dev
+from .cmd_auth import set_auth
+from .cmd_mcp import set_mcp
+
+__all__ = [
+    "generate",
+    "init",
+    "dev",
+    "set_auth",
+    "set_mcp",
+]

tai_api/cli/commands/cmd_auth/__init__.py

@@ -0,0 +1 @@
+from .main import set_auth

tai_api/cli/commands/cmd_auth/database.py

@@ -0,0 +1,153 @@
+import sys
+import click
+
+from tai_sql import pm as sqlpm
+from tai_api import DatabaseAuthConfig
+
+def rundbconfig() -> DatabaseAuthConfig:
+    """
+    Configura la autenticación basada en base de datos.
+    """
+    click.echo("\n🗄️  Configurando autenticación de base de datos...")
+    click.echo("-" * 40)
+    
+    if not sqlpm.db.tables:
+        click.echo("❌ No se encontraron tablas en la base de datos.", err=True)
+        sys.exit(1)
+    
+    tables = sqlpm.db.tables
+    
+    # Mostrar tablas disponibles
+    click.echo("\n📊 Tablas disponibles:")
+    for i, table in enumerate(tables, 1):
+        column_count = len(table.columns)
+        click.echo(f"   {i}. {table._name} ({column_count} columnas)")
+    
+    # Seleccionar tabla de usuarios
+    while True:
+        choice: int = click.prompt(
+            f"\n🔢 Selecciona la tabla de usuarios (1-{len(tables)})", 
+            type=int,
+            show_default=False
+        )
+        
+        if 1 <= choice <= len(tables):
+            selected_table = tables[choice - 1]
+            break
+        else:
+            click.echo(f"❌ Opción no válida. Selecciona un número entre 1 y {len(tables)}.")
+
+    click.echo(f"✅ Tabla seleccionada: {selected_table._name}")
+
+    columns = list(selected_table.columns.values())
+    
+    # Seleccionar campo de username
+    click.echo(f"\n🏷️  Selecciona el campo para 'username':")
+    for i, column in enumerate(columns, 1):
+        click.echo(f"   {i}. {column.name} ({column.type})")
+    
+    while True:
+        choice: int = click.prompt(
+            f"🔢 Selecciona el campo de 'username' (1-{len(columns)})", 
+            type=int,
+            show_default=False
+        )
+        
+        if 1 <= choice <= len(columns):
+            username_field = columns[choice - 1]
+            if not username_field.args.primary_key:
+                click.echo("❌ El campo de 'username' debe ser una clave primaria.", err=True)
+                continue
+            break
+        else:
+            click.echo(f"❌ Opción no válida. Selecciona un número entre 1 y {len(columns)}.")
+
+    click.echo(f"✅ Campo de username: {username_field.name}")
+    
+    # Seleccionar campo de password
+    click.echo(f"\n🏷️  Selecciona el campo para 'password':")
+    for i, column in enumerate(columns, 1):
+        click.echo(f"   {i}. {column.name} ({column.type})")
+    
+    while True:
+        choice: int = click.prompt(
+            f"🔢 Selecciona el campo de 'password' (1-{len(columns)})", 
+            type=int,
+            show_default=False
+        )
+        
+        if 1 <= choice <= len(columns):
+            password_field = columns[choice - 1]
+            break
+        else:
+            click.echo(f"❌ Opción no válida. Selecciona un número entre 1 y {len(columns)}.")
+
+    click.echo(f"✅ Campo de password: {password_field.name}")
+    
+    # Seleccionar campo de session_id (opcional)
+    click.echo(f"\n🔐 ¿Deseas configurar manejo de sesiones concurrentes?")
+    click.echo("   Esto permite invalidar sesiones cuando un usuario se loguea desde otro lugar.")
+    click.echo("   Si seleccionas 'Sí', debes elegir un campo para almacenar el session_id.")
+    
+    session_management = click.confirm("\n🔄 ¿Habilitar manejo de sesiones?", default=True)
+    session_id_field = None
+    
+    if session_management:
+        click.echo(f"\n🏷️  Selecciona el campo para 'session_id':")
+        click.echo("   (Este campo debe poder almacenar texto, como VARCHAR, TEXT, etc.)")
+        for i, column in enumerate(columns, 1):
+            click.echo(f"   {i}. {column.name} ({column.type})")
+        
+        while True:
+            choice: int = click.prompt(
+                f"🔢 Selecciona el campo de 'session_id' (1-{len(columns)})", 
+                type=int,
+                show_default=False
+            )
+            
+            if 1 <= choice <= len(columns):
+                session_id_field = columns[choice - 1]
+                break
+            else:
+                click.echo(f"❌ Opción no válida. Selecciona un número entre 1 y {len(columns)}.")
+
+        click.echo(f"✅ Campo de session_id: {session_id_field.name}")
+    
+    # Seleccionar campo de password_expiration (opcional)
+    click.echo(f"\n🔐 ¿Deseas configurar renovación de contraseñas?")
+    click.echo("   Esto obliga al usuario a renovar su contraseña cada cierto tiempo.")
+    
+    pwd_renewal = click.confirm("\n🔄 ¿Habilitar renovación de contraseñas?", default=True)
+    pwd_expiration_field = None
+    
+    if pwd_renewal:
+        click.echo(f"\n🏷️  Selecciona el campo para 'password_expiration':")
+        click.echo("   (Este campo debe ser DATE o DATETIME.)")
+        for i, column in enumerate(columns, 1):
+            click.echo(f"   {i}. {column.name} ({column.type})")
+        
+        while True:
+            choice: int = click.prompt(
+                f"🔢 Selecciona el campo de 'session_id' (1-{len(columns)})", 
+                type=int,
+                show_default=False
+            )
+            
+            if 1 <= choice <= len(columns):
+                pwd_expiration_field = columns[choice - 1]
+                break
+            else:
+                click.echo(f"❌ Opción no válida. Selecciona un número entre 1 y {len(columns)}.")
+
+        click.echo(f"✅ Campo de password_expiration: {pwd_expiration_field.name}")
+        click.echo("💡 El sistema generará un UUID único para cada sesión y lo almacenará en este campo.")
+    else:
+        click.echo("✅ Manejo de sesiones deshabilitado (se permitirán múltiples sesiones concurrentes)")
+
+    return DatabaseAuthConfig(
+        table_name=selected_table._name,
+        username_field=username_field.name,
+        password_field=password_field.name,
+        session_id_field=session_id_field.name,
+        password_expiration_field=pwd_expiration_field.name if pwd_renewal else None,
+    )

tai_api/cli/commands/cmd_auth/keycloak.py

@@ -0,0 +1,24 @@
+import click
+from tai_api import KeycloakAuthConfig
+
+def runkeycloakconfig() -> KeycloakAuthConfig:
+    click.echo(click.style("🚀 Running Keycloak configuration...", fg='cyan', bold=True))
+    click.echo("")
+    click.echo(click.style("📋 Para que la API funcione correctamente con Keycloak, necesitas provisionar las siguientes variables de entorno:", fg='yellow', bold=True))
+    click.echo("")
+    click.echo(click.style("1️⃣  MAIN_KEYCLOAK_URL", fg='blue', bold=True))
+    click.echo(click.style("   Formato: ", fg='white') + click.style("MAIN_KEYCLOAK_URL=<protocol>://<user>:<pwd>@<host>:<port>", fg='magenta'))
+    click.echo(click.style("   Ejemplo: ", fg='white') + click.style("MAIN_KEYCLOAK_URL=http://admin:admin@localhost:8090", fg='green'))
+    click.echo("")
+    click.echo(click.style("2️⃣  KEYCLOAK_API_CLIENT_SECRET", fg='blue', bold=True))
+    click.echo(click.style("   Formato: ", fg='white') + click.style("KEYCLOAK_API_CLIENT_SECRET='secreto_del_cliente_api'", fg='magenta'))
+    click.echo("")
+    click.echo(click.style("🔍 Para encontrar el KEYCLOAK_API_CLIENT_SECRET:", fg='yellow', bold=True))
+    click.echo(click.style("   1. Accede a ", fg='white') + click.style("<host>:<port>", fg='cyan') + click.style(" (ej: ", fg='white') + click.style("localhost:8090", fg='green') + click.style(")", fg='white'))
+    click.echo(click.style("   2. Ve a ", fg='white') + click.style("Main Realm > Clients > \"api\" > Credentials", fg='cyan'))
+    click.echo(click.style("   3. Copia el Client Secret que aparece ahí", fg='white'))
+    click.echo("")
+    click.echo(click.style("✅ Una vez configuradas estas variables, la API podrá autenticarse con Keycloak", fg='green', bold=True))
+    click.echo("")
+    
+    return KeycloakAuthConfig(realm_name="main-realm", client_name="api", audience="api")

tai_api/cli/commands/cmd_auth/main.py

@@ -0,0 +1,179 @@
+import sys
+import click
+
+from tai_sql import pm as sqlpm
+from tai_sql.generators import BaseGenerator
+from tai_api import pm, AuthConfig, AuthType
+from tai_api.generators import AuthDatabaseGenerator, AuthKeycloakGenerator, MainFileGenerator, RoutersGenerator
+
+from .database import rundbconfig
+from .keycloak import runkeycloakconfig
+
+@click.command()
+def set_auth():
+    """Genera recursos para la seguridad de la API"""
+    
+    click.echo("🔐 Configuración de Autenticación - tai-api")
+    click.echo("=" * 50)
+    
+    # Verificar configuración de tai-api
+    config = pm.get_project_config()
+    if not config:
+        click.echo("❌ No se encontró la configuración del proyecto tai-api.", err=True)
+        click.echo("   Asegúrate de haber inicializado el proyecto con tai-api init.", err=True)
+        sys.exit(1)
+    
+    # Seleccionar tipo de autenticación
+    click.echo("\n📋 Selecciona el tipo de autenticación:")
+    click.echo("   1. Database - Autenticación basada en base de datos")
+    click.echo("   2. Keycloak - Autenticación con Keycloak")
+    
+    while True:
+        choice = click.prompt(
+            "\n🔢 Selecciona una opción (1 o 2)", 
+            type=int,
+            show_default=False
+        )
+        
+        if choice == 1:
+            click.echo("✅ Has seleccionado: Database")
+            click.echo()
+            auth_type = "database"
+            break
+        elif choice == 2:
+            click.echo("✅ Has seleccionado: Keycloak")
+            click.echo()
+            auth_type = "keycloak"
+            break
+        else:
+            click.echo("❌ Opción no válida. Por favor selecciona 1 o 2.")
+    
+    if auth_type == "database":
+
+        # Verificar configuración de tai-sql
+        sqlconfig = sqlpm.get_project_config()
+        if not sqlconfig:
+            click.echo("❌ No se encontró la configuración de tai-sql.", err=True)
+            click.echo("   Asegúrate de haber inicializado el proyecto con tai-sql init.", err=True)
+            sys.exit(1)
+        
+        # Establecer esquema por defecto si existe
+        if sqlpm.config.default_schema:
+            sqlpm.set_current_schema(sqlconfig.default_schema)
+        
+        # Verificar que existe información de la base de datos
+        if not sqlpm.db or not sqlpm.db.tables:
+            click.echo("❌ No se encontró información de tablas en la base de datos.", err=True)
+            sys.exit(1)
+
+        # Obtener configuración de la base de datos
+        db_auth_config = rundbconfig()
+        
+        # Crear configuración de autenticación
+        auth_config = AuthConfig(
+            type=AuthType.DATABASE,
+            config=db_auth_config
+        )
+        
+        # Guardar en la configuración del proyecto
+        try:
+            pm.update_auth_config(auth_config)
+        except ValueError as e:
+            click.echo(f"❌ Error al guardar la configuración: {e}", err=True)
+            sys.exit(1)
+        
+        # Mostrar mensaje de configuración
+        click.echo("\n⚙️  Configuración de autenticación...")
+        click.echo("-" * 40)
+        click.echo(f"📝 Configuración seleccionada: database")
+        click.echo(f"   • Tabla: {db_auth_config.table_name}")
+        click.echo(f"   • Campo username: {db_auth_config.username_field}")
+        click.echo(f"   • Campo password: {db_auth_config.password_field}")
+        
+        if db_auth_config.has_session_management:
+            click.echo(f"   • Campo session_id: {db_auth_config.session_id_field}")
+            click.echo("   • ✅ Manejo de sesiones concurrentes habilitado")
+        else:
+            click.echo("   • ❌ Manejo de sesiones concurrentes deshabilitado")
+            click.echo("")
+        
+        auth_generator = AuthDatabaseGenerator(output_dir=pm.config.auth_namespace.as_posix())
+        main_file_generator = MainFileGenerator(
+            output_dir=pm.config.main_namespace.as_posix()
+        )
+
+        generators: list[BaseGenerator] = [auth_generator, main_file_generator]
+
+        for generator in generators:
+
+            generator_name = generator.__class__.__name__
+            click.echo(f"Ejecutando: {click.style(generator_name, bold=True)}")
+                
+            # El generador se encargará de descubrir los modelos internamente
+            result = generator.generate()
+            
+            click.echo(f"✅ Generador {generator_name} completado con éxito.")
+            if result:
+                click.echo(f"   Recursos en: {result}")
+            click.echo("")
+            
+    elif auth_type == "keycloak":
+        # Obtener configuración de Keycloak
+        kc_auth_config = runkeycloakconfig()
+        
+        # Crear configuración de autenticación
+        auth_config = AuthConfig(
+            type=AuthType.KEYCLOAK,
+            config=kc_auth_config
+        )
+        
+        # Guardar en la configuración del proyecto
+        try:
+            pm.update_auth_config(auth_config)
+        except ValueError as e:
+            click.echo(f"❌ Error al guardar la configuración: {e}", err=True)
+            sys.exit(1)
+
+        if pm.config.has_routers:
+
+            # Verificar configuración de tai-sql
+            sqlconfig = sqlpm.get_project_config()
+            if not sqlconfig:
+                click.echo("❌ No se encontró la configuración de tai-sql.", err=True)
+                click.echo("   Asegúrate de haber inicializado el proyecto con tai-sql init.", err=True)
+                sys.exit(1)
+
+            for schema_name in sqlpm.discover_schemas():
+                sqlpm.set_current_schema(schema_name)
+                click.echo(f"Ejecutando: {click.style(RoutersGenerator.__name__, bold=True)}")
+                click.echo(f"   • Esquema: {schema_name}")
+                result = RoutersGenerator(
+                    output_dir=(pm.config.routers_namespace / schema_name).as_posix()
+                ).generate()
+                click.echo(f"✅ Generador {RoutersGenerator.__name__} completado con éxito.")
+                if result:
+                    click.echo(f"   Recursos en: {result}")
+                click.echo("")
+
+        auth_generator = AuthKeycloakGenerator(output_dir=pm.config.auth_namespace.as_posix())
+        main_file_generator = MainFileGenerator(
+            output_dir=pm.config.main_namespace.as_posix()
+        )
+
+        base_generators: list[BaseGenerator] = [auth_generator, main_file_generator]
+
+        for generator in base_generators:
+
+            generator_name = generator.__class__.__name__
+            click.echo(f"Ejecutando: {click.style(generator_name, bold=True)}")
+                
+            # El generador se encargará de descubrir los modelos internamente
+            result = generator.generate()
+            
+            click.echo(f"✅ Generador {generator_name} completado con éxito.")
+            if result:
+                click.echo(f"   Recursos en: {result}")
+            click.echo("")
+    else:
+        click.echo("❌ Opción no válida.", err=True)
+        sys.exit(1)

tai_api/cli/commands/cmd_dev/__init__.py

@@ -0,0 +1 @@
+from .main import dev

tai_api/cli/commands/cmd_dev/main.py

@@ -0,0 +1,27 @@
+import sys
+import click
+import subprocess
+
+from tai_api import pm
+
+@click.command()
+@click.option('--auth', '-w', is_flag=True, help='Activar autenticación')
+def dev(auth: bool = False):
+    """Inicia el servidor en modo desarrollo."""
+
+    config = pm.get_project_config()
+
+    if not config:
+        click.echo("❌ No se encontró la configuración del proyecto. Asegúrate de haber inicializado el proyecto con tai-api init.", err=True)
+        sys.exit(1)
+    
+    if auth:
+        if pm.config.auth is None:
+            click.echo("⚠️  Advertencia: Se ejecutará sin autenticación porque no ha sido configurada.", err=True)
+        file_name = '__main__.py'
+    else:
+        file_name = '__dev__.py'
+    
+    main_file = pm.config.main_namespace / file_name
+
+    sys.exit(subprocess.call(["fastapi", "dev", main_file.as_posix()]))

tai_api/cli/commands/cmd_generate/__init__.py

@@ -0,0 +1,5 @@
+from .main import generate
+
+__all__ = [
+    "generate",
+]

tai_api/cli/commands/cmd_generate/funcs.py

@@ -0,0 +1,61 @@
+import click
+import sys
+from tai_sql.generators import (
+    BaseGenerator,
+    ModelsGenerator,
+    CRUDGenerator,
+    ERDiagramGenerator
+)
+from tai_api.generators import RoutersGenerator, MainFileGenerator
+
+from tai_api import pm
+from tai_sql import pm as sqlpm
+
+
+def run_generate():
+    """Run the configured generators."""
+    # Ejecutar cada generador
+    click.echo("🚀 Ejecutando generadores...")
+    click.echo()
+
+    models_generator = ModelsGenerator(pm.config.database_namespace.as_posix())
+    crud_generator = CRUDGenerator(
+        output_dir=pm.config.database_namespace.as_posix(),
+        models_import_path=pm.config.models_import_path,
+        mode='async'
+    )
+    er_generator = ERDiagramGenerator(pm.config.diagrams_namespace.as_posix())
+    
+    endpoints_generator = RoutersGenerator(
+        output_dir=(pm.config.routers_namespace / sqlpm.db.schema_name).as_posix()
+    )
+
+    main_file_generator = MainFileGenerator(
+        output_dir=pm.config.main_namespace.as_posix()
+    )
+
+    generators: list[BaseGenerator] = [
+        models_generator,
+        crud_generator,
+        er_generator,
+        endpoints_generator,
+        main_file_generator
+    ]
+
+    for generator in generators:
+        try:
+            generator_name = generator.__class__.__name__
+            click.echo(f"Ejecutando: {click.style(generator_name, bold=True)}")
+            
+            # El generador se encargará de descubrir los modelos internamente
+            result = generator.generate()
+            
+            click.echo(f"✅ Generador {generator_name} completado con éxito.")
+            if result:
+                click.echo(f"   Recursos en: {result}")
+        except Exception as e:
+            click.echo(f"❌ Error al ejecutar el generador {generator_name}: {str(e)}", err=True)
+            sys.exit(1)
+        
+        finally:
+            click.echo()

tai_api/cli/commands/cmd_generate/main.py

@@ -0,0 +1,44 @@
+import sys
+import click
+
+from tai_sql import pm as sqlpm
+from tai_api import pm
+from .funcs import run_generate
+
+@click.command()
+@click.option('--schema', '-s', help='Nombre del esquema')
+@click.option('--all', is_flag=True, help='Generar para todos los esquemas')
+def generate(schema: str=None, all: bool=False):
+    """Genera recursos para la API."""
+
+    if not pm.get_project_config():
+        click.echo("❌ No se encontró la configuración del proyecto. Asegúrate de haber inicializado el proyecto con tai-api init.", err=True)
+        sys.exit(1)
+
+    if schema and all:
+        click.echo("❌ Las opciones --schema y --all no pueden usarse juntas.", err=True)
+        sys.exit(1)
+
+    if schema:
+        sqlpm.set_current_schema(schema)
+        run_generate()
+
+    elif all:
+        for schema_name in sqlpm.discover_schemas():
+            click.echo(f"\n🔄 Generando para esquema: {schema_name}\n")
+            sqlpm.set_current_schema(schema_name)
+            run_generate()
+
+    else:
+        sqlconfig = sqlpm.get_project_config()
+        if sqlconfig:
+            sqlpm.set_current_schema(sqlconfig.default_schema)
+            
+
+        if not schema and not sqlpm.db:
+            click.echo(f"❌ No existe ningún esquema por defecto", err=True)
+            click.echo(f"   Puedes definir uno con: tai-sql set-default-schema <nombre>", err=True)
+            click.echo(f"   O usar la opción: --schema <nombre_esquema>", err=True)
+            sys.exit(1)
+
+        run_generate()

tai_api/cli/commands/cmd_init/__init__.py

@@ -0,0 +1 @@
+from .main import init

tai_api/cli/commands/cmd_init/main.py

@@ -0,0 +1,22 @@
+import sys
+import click
+from .model import InitCommand
+
+@click.command()
+@click.argument('project', type=str)
+@click.option('--namespace', '-n', default='api', help='Nombre del proyecto a crear')
+def init(project: str, namespace: str):
+    """Inicializa un nuevo proyecto tai-api"""
+    command = InitCommand(project=project, namespace=namespace)
+    try:
+        command.check_poetry()
+        command.check_directory_is_avaliable()
+        command.check_virtualenv()
+        command.create_project()
+        command.create_project_config()
+        command.add_dependencies()
+        command.add_folders()
+        command.msg()
+    except Exception as e:
+        click.echo(f"❌ Error al inicializar el proyecto: {str(e)}", err=True)
+        sys.exit(1)