tai-api 0.1.1__py3-none-any.whl

tai_api/cli/commands/__init__.py

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

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,40 @@
+import click
+import sys
+from tai_sql.generators import BaseGenerator, ModelsGenerator, CRUDGenerator, ERDiagramGenerator
+from tai_api.generators.fastapi import EndpointsGenerator
+
+def run_generate():
+    """Run the configured generators."""
+    # Ejecutar cada generador
+    click.echo("🚀 Ejecutando generadores...")
+    click.echo()
+    
+    models_generator = ModelsGenerator(output_dir="api/api/database")
+    crud_generator = CRUDGenerator(output_dir="api/api/database", mode='async')
+    er_generator = ERDiagramGenerator(output_dir="api/api/diagrams")
+    endpoints_generator = EndpointsGenerator()
+
+    generators: list[BaseGenerator] = [
+        models_generator,
+        crud_generator,
+        er_generator,
+        endpoints_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/generate_endpoints.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+"""
+Ejemplo de uso del EndpointsGenerator de tai-api.
+
+Este script muestra cómo usar el EndpointsGenerator para generar automáticamente
+endpoints REST para FastAPI basados en los modelos definidos en tai_sql.
+"""
+
+import sys
+import os
+
+from tai_api.generators.fastapi import EndpointsGenerator
+from tai_sql import pm
+
+def main():
+    """
+    Función principal que demuestra el uso del EndpointsGenerator.
+    """
+    print("🚀 Generando endpoints de FastAPI con tai-api...")
+    config = pm.load_config()
+
+    if config:
+        pm.set_current_schema(config.default_schema)
+    
+    # Crear una instancia del generador
+    generator = EndpointsGenerator()
+    
+    try:
+        # Generar los endpoints
+        generator.generate()
+        print("\n✅ ¡Endpoints generados exitosamente!")
+            
+    except Exception as e:
+        import logging
+        logging.exception(e)
+        print(f"❌ Error al generar endpoints: {e}")
+        return 1
+        
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(main())

tai_api/cli/commands/cmd_generate/main.py

@@ -0,0 +1,26 @@
+import sys
+import click
+
+from tai_sql import pm
+from .funcs import run_generate
+
+@click.command()
+@click.option('--schema', '-s', help='Nombre del esquema')
+def generate(schema: str=None):
+    """Genera recursos para la API."""
+
+    if schema:
+        pm.set_current_schema(schema)
+    
+    else:
+        config = pm.load_config()
+        if config:
+            pm.set_current_schema(config.default_schema)
+
+    if not schema and not pm.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/main.py

@@ -0,0 +1,14 @@
+import click
+from .commands import (
+    generate,
+)
+
+@click.group()
+def cli():
+    """CLI para tai-api: Un framework para APIs basado en FastAPI."""
+    pass
+
+cli.add_command(generate)
+
+if __name__ == '__main__':
+    cli()

tai_api/generators/fastapi/__init__.py

@@ -0,0 +1,3 @@
+from .endpoints import EndpointsGenerator
+
+__all__ = ["EndpointsGenerator"]

tai_api/generators/fastapi/endpoints.py

@@ -0,0 +1,161 @@
+import os
+from pathlib import Path
+from typing import ClassVar
+import jinja2
+from tai_sql.generators import BaseGenerator
+from tai_sql import pm
+
+
+class EndpointsGenerator(BaseGenerator):
+    """
+    Generador de endpoints para FastAPI.
+    
+    Este generador crea los endpoints necesarios para interactuar con los modelos
+    definidos en tai_sql, utilizando la configuración proporcionada.
+    
+    Genera automáticamente:
+    - Endpoints CRUD completos para cada tabla
+    - Archivos router_{table_name}.py en routers/generated/
+    - Importaciones automáticas de DTOs y DAOs
+    
+    Atributos:
+        output_dir (str): Directorio donde se generarán los routers
+        template_dir (str): Directorio donde están los templates Jinja2
+    """
+
+    _jinja_env: ClassVar[jinja2.Environment] = None
+    
+    def __init__(
+            self,
+            output_dir: str = "api/api/routers/generated",
+            database_resources_path: str = "api/database"):
+        """
+        Inicializa el generador de endpoints.
+        
+        Args:
+            output_dir: Directorio donde se generarán los archivos router
+            template_dir: Directorio donde están los templates Jinja2
+        """
+        super().__init__(output_dir)
+        self.database_import_path = ".".join(Path(database_resources_path).parts + (pm.db.schema_name,))
+
+    @property
+    def jinja_env(self) -> jinja2.Environment:
+        """Retorna el entorno Jinja2 configurado"""
+        if self._jinja_env is None:
+            templates_dir = os.path.join(os.path.dirname(__file__), 'templates')
+            self._jinja_env = jinja2.Environment(
+                loader=jinja2.FileSystemLoader(templates_dir),
+                trim_blocks=True,
+                lstrip_blocks=True
+            )
+        return self._jinja_env
+    
+    @property
+    def crud_class(self) -> str:
+        """Retorna el nombre de la clase CRUD para el esquema actual"""
+        return f"{pm.db.schema_name.title()}AsyncDBAPI"
+    
+    def generate(self):
+        """
+        Genera todos los archivos router para las tablas definidas en models.
+        """
+        # Crear directorio de salida si no existe
+        os.makedirs(self.config.output_dir, exist_ok=True)
+        
+        # Generar routers para cada modelo
+        self._generate_routers()
+        # Generar router para enumeraciones
+        self._generate_enumerations_router()
+        # Generar archivo __init__.py para importar todos los routers
+        self._generate_init_file()
+    
+    def _generate_routers(self):
+        """
+        Genera los routers para cada modelo definido en models.
+        """
+        # Cargar el template Jinja2
+        template = self.jinja_env.get_template("router_template.py.j2")
+
+        imports = [
+            "from fastapi import APIRouter, Depends, Query",
+            f"from {self.database_import_path} import *",
+            "from api.responses import (",
+            "    APIResponse, PaginatedResponse, RecordNotFoundException,",
+            "    ValidationException",
+            ")",
+            "from typing import Optional, List",
+            "from tai_alphi import Alphi"
+        ]
+        # Generar router para cada modelo
+        for model in self.models:
+            model_imports = imports.copy()
+            has_datetime = any(col.type == 'datetime' or col.type == 'date' or col.type == 'time' for col in model.columns.values())
+            if has_datetime:
+                model_imports.append('from datetime import datetime, date, time')
+            content = template.render(
+                imports=model_imports,
+                model=model.info(),
+                import_path=self.database_import_path,
+                crud_class=self.crud_class
+            )
+            # Escribir archivo
+            output_file = Path(self.config.output_dir) / f"router_{model.tablename}.py"
+            with open(output_file, 'w', encoding='utf-8') as f:
+                f.write(content)
+
+    def _generate_enumerations_router(self):
+        """
+        Genera el router para todas las enumeraciones del sistema.
+        """
+        # Cargar el template Jinja2 para enumeraciones
+        template = self.jinja_env.get_template("enums_template.py.j2")
+        
+        # Preparar las importaciones necesarias
+        imports = [
+            "from fastapi import APIRouter, Depends",
+            "from typing import List, Dict, Optional",
+            f"from {self.database_import_path} import *",
+            "from api.responses import APIResponse"
+        ]
+        
+        # Renderizar el template
+        rendered_code = template.render(
+            imports=imports,
+            crud_class=self.crud_class,
+            enumerations=[enum.info() for enum in pm.db.enums],
+        )
+        
+        # Escribir el archivo
+        output_file = Path(self.config.output_dir) / "router_enums.py"
+        with open(output_file, "w", encoding="utf-8") as f:
+            f.write(rendered_code)
+
+    def _generate_init_file(self):
+        """
+        Genera el archivo __init__.py para importar todos los routers generados.
+        """
+        # Cargar el template Jinja2 para enumeraciones
+        template = self.jinja_env.get_template("__init__.py.j2")
+
+        init_content = ["# Archivo generado automáticamente por tai-api", ""]
+        
+        # Importar todos los routers
+        imports = ["from fastapi import APIRouter"]
+        routers = {}
+        for model in self.models:
+            routers[f"router_{model.tablename}"] = f"{model.tablename}_router"
+        
+        routers["router_enums"] = "enumerations_router"
+
+        imports.extend([f"from .{router_file} import {router_var}" for router_file, router_var in routers.items()])
+
+        rendered_code = template.render(
+            imports=imports,
+            routers=routers,
+        )
+
+        # Escribir archivo
+        init_file = os.path.join(self.config.output_dir, "__init__.py")
+        with open(init_file, 'w', encoding='utf-8') as f:
+            f.write(rendered_code)

tai_api/generators/fastapi/templates/__init__.py.j2

@@ -0,0 +1,7 @@
+{{ imports|join('\n') }}
+
+generated_api_router = APIRouter()
+
+{% for router in routers.values() %}
+generated_api_router.include_router({{ router }})
+{% endfor %}

tai_api/generators/fastapi/templates/enums_template.py.j2

@@ -0,0 +1,25 @@
+{#- Template Jinja2 para generar router de enumeraciones -#}
+{#- Este template genera endpoints GET para todas las enumeraciones del sistema -#}
+{{ imports|join('\n') }}
+
+enumerations_router = APIRouter(
+    prefix="/enums",
+    tags=["Enumeraciones"]
+)
+
+{% for enum in enumerations %}
+@enumerations_router.get("/{{ enum.hypen_name }}", tags=["Enumeraciones"], response_model=APIResponse[List[{{ enum.type }}]])
+async def get_{{ enum.name }}_enumeration(
+    api: {{ crud_class }} = Depends({{ crud_class }})
+) -> APIResponse[List[{{ enum.type }}]]:
+    """
+    Obtiene los valores de la enumeración {{ enum.name }}.
+    """
+    values = api.{{ enum.name }}.find_many()
+    
+    return APIResponse.success(
+        data=values,
+        message="Enumeración {{ enum.name }} obtenida exitosamente"
+    )
+
+{% endfor %}

tai_api/generators/fastapi/templates/macros.j2

@@ -0,0 +1,96 @@
+
+
+{% macro generate_query_parameters(model) -%}
+{% for column in model.columns -%}
+{% if not column.args.get('autoincrement', False) -%}
+    {% if column.args.get('primary_key', False) or column.is_foreign_key -%}
+{{ column.name }}: Optional[{{ column.type }}] = None,
+    {% elif 'str' == column.type or 'Text' == column.type or 'bool' == column.type -%}
+{{ column.name }}: Optional[{{ column.type }}] = None,
+    {% elif  'date' == column.type or 'int' == column.type or 'BigInteger' == column.type -%}
+{{ column.name }}: Optional[{{ column.type }}] = None,
+min_{{ column.name }}: Optional[{{ column.type }}] = None,
+max_{{ column.name }}: Optional[{{ column.type }}] = None,
+    {% elif 'float' == column.type or 'Numeric' == column.type or 'datetime' == column.type or 'time' == column.type -%}
+min_{{ column.name }}: Optional[{{ column.type }}] = None,
+max_{{ column.name }}: Optional[{{ column.type }}] = None,
+    {% else -%}
+{{ column.name }}: Optional[{{ column.type }}] = None,
+    {%- endif -%}
+{%- endif -%}
+{%- endfor -%}
+{%- endmacro -%}
+
+
+{% macro generate_query_args(model) -%}
+{% for column in model.columns -%}
+{% if not column.args.get('autoincrement', False) -%}
+{% if column.args.get('primary_key', False) or column.is_foreign_key -%}
+{{ column.name }}: Filtrar por {{ column.name }}
+{% elif 'str' == column.type or 'Text' == column.type or 'bool' == column.type -%}
+{{ column.name }}: Filtrar por {{ column.name }}
+{% elif  'date' == column.type or 'int' == column.type or 'BigInteger' == column.type -%}
+{{ column.name }}: Filtrar por {{ column.name }}
+min_{{ column.name }}: Filtrar por fecha mínima (incluída)
+max_{{ column.name }}: Filtrar por fecha máxima (incluída)
+{% elif 'float' == column.type or 'Numeric' == column.type or 'datetime' == column.type or 'time' == column.type -%}
+min_{{ column.name }}: Filtrar por valor mínimo de {{ column.name }} (incluído)
+max_{{ column.name }}: Filtrar por valor máximo de {{ column.name }} (incluído)
+{% else -%}
+{{ column.name }}: Filtrar por {{ column.name }}
+{%- endif -%}
+{%- endif -%}
+{%- endfor -%}
+{%- endmacro %}
+
+
+{% macro asing_parameters(model) -%}
+{% for column in model.columns -%}
+{% if not column.args.get('autoincrement', False) -%}
+{% if column.args.get('primary_key', False) or column.is_foreign_key -%}
+{{ column.name }}={{ column.name }},
+{% elif 'str' == column.type or 'Text' == column.type or 'bool' == column.type -%}
+{{ column.name }}={{ column.name }},
+{% elif  'date' == column.type or 'int' == column.type or 'BigInteger' == column.type -%}
+{{ column.name }}={{ column.name }},
+min_{{ column.name }}=min_{{ column.name }},
+max_{{ column.name }}=max_{{ column.name }},
+{% elif 'float' == column.type or 'Numeric' == column.type or 'datetime' == column.type or 'time' == column.type -%}
+min_{{ column.name }}=min_{{ column.name }},
+max_{{ column.name }}=max_{{ column.name }},
+{% else -%}
+{{ column.name }}={{ column.name }},
+{%- endif -%}
+{%- endif -%}
+{%- endfor -%}
+{%- endmacro %}
+
+
+{% macro generate_filter_query(model) -%}
+{% for column in model.columns -%}
+{% if not column.args.get('autoincrement', False) -%}
+{% if column.args.get('primary_key', False) or column.is_foreign_key -%}
+if {{ column.name }} is not None:
+    query = query.where({{ model.name }}.{{ column.name }} == {{ column.name }})
+{% elif 'str' == column.type or 'Text' == column.type or 'bool' == column.type -%}
+if {{ column.name }} is not None:
+    query = query.where({{ model.name }}.{{ column.name }} == {{ column.name }})
+{% elif 'date' == column.type or 'int' == column.type or 'BigInteger' == column.type -%}
+if {{ column.name }} is not None:
+    query = query.where({{ model.name }}.{{ column.name }} == {{ column.name }})
+if min_{{ column.name }} is not None:
+    query = query.where({{ model.name }}.{{ column.name }} >= min_{{ column.name }})
+if max_{{ column.name }} is not None:
+    query = query.where({{ model.name }}.{{ column.name }} <= max_{{ column.name }})
+{% elif 'float' == column.type or 'Numeric' == column.type or 'datetime' == column.type or 'time' == column.type -%}
+if min_{{ column.name }} is not None:
+    query = query.where({{ model.name }}.{{ column.name }} >= min_{{ column.name }})
+if max_{{ column.name }} is not None:
+    query = query.where({{ model.name }}.{{ column.name }} <= max_{{ column.name }})
+{% else -%}
+if {{ column.name }} is not None:
+    query = query.where({{ model.name }}.{{ column.name }} == {{ column.name }})
+{%- endif -%}
+{%- endif -%}
+{%- endfor -%}
+{%- endmacro %}

tai_api/generators/fastapi/templates/router_template.py.j2

@@ -0,0 +1,247 @@
+{#- Template Jinja2 para generar routers de FastAPI -#}
+{#- Este template genera endpoints CRUD completos para cada tabla -#}
+{#- Confia en los manejadores globales de excepciones para el manejo de errores -#}
+{{ imports|join('\n') }}
+
+{% set router_name = model.tablename + "_router" %}
+{% set pk_path_params = "/{" + (model.columns | selectattr('args.primary_key', 'equalto', True) | map(attribute='name') | join('}/{')) + "}/" %}
+{% import "macros.j2" as macros %}
+
+logger = Alphi.get_logger_by_name("tai-api")
+
+{{ router_name }} = APIRouter(
+    prefix="/{{ model.tablename | replace('_', '-') }}",
+    tags=["{{ model.name }}"]
+)
+
+@{{ router_name }}.get("/", tags=["{{ model.name }}"], response_model=APIResponse[List[{{ model.name }}Read]])
+async def {{ model.tablename }}_find_many(
+    limit: Optional[int] = None,
+    offset: Optional[int] = None,
+    {{ macros.generate_query_parameters(model).rstrip('\n') | indent(4) }}
+    includes: List[str] = Query(None),
+    api: {{ crud_class }} = Depends({{ crud_class }})
+) -> APIResponse[List[{{ model.name }}Read]]:
+    """
+    Obtiene una lista de {{ model.name }}s con filtros opcionales.
+    """
+    # Validaciones básicas de entrada
+    if limit is not None and limit < 0:
+        raise ValidationException("El límite no puede ser negativo", "limit")
+    if offset is not None and offset < 0:
+        raise ValidationException("El offset no puede ser negativo", "offset")
+    if limit is not None and limit > 1000:
+        raise ValidationException("El límite no puede ser mayor a 1000", "limit")
+        
+    result = await api.{{ model.tablename }}.find_many(
+        limit=limit,
+        offset=offset,
+        {{ macros.asing_parameters(model).rstrip('\n') | indent(8) }}
+        includes=includes
+    )
+    
+    # Obtener el total para metadatos de paginación si es necesario
+    total = None
+    if limit is not None or offset is not None:
+        try:
+            total = await api.{{ model.tablename }}.count(
+                {{ macros.asing_parameters(model).rstrip('\n') | indent(16) }}
+            )
+        except Exception as e:
+            logger.warning(f"No se pudo obtener el total de registros: {str(e)}")
+    
+    return PaginatedResponse.success_paginated(
+        data=result,
+        total=total,
+        limit=limit,
+        offset=offset,
+        message=f"{{ model.name }}s obtenidos exitosamente"
+    )
+
+{% if not model.is_view %}
+@{{ router_name }}.get("{{ pk_path_params }}", tags=["{{ model.name }}"], response_model=APIResponse[{{ model.name }}Read])
+async def {{ model.tablename }}_find(
+    {% for column in model.columns if column.args.get('primary_key', False) %}
+    {{ column.name }}: {{ column.type }},
+    {% endfor %}
+    includes: List[str] = Query(None),
+    api: {{ crud_class }} = Depends({{ crud_class }})
+) -> APIResponse[{{ model.name }}Read]:
+    """
+    Obtiene un {{ model.name }} por su primary key.
+    """
+    # Validaciones básicas de entrada
+    {% for column in model.columns if column.args.get('primary_key', False) and column.args.get('autoincrement', False) %}
+    {% if column.type in ['int', 'BigInteger'] %}
+    if {{ column.name }} <= 0:
+        raise ValidationException("{{ column.name }} debe ser mayor a 0", "{{ column.name }}")
+    {% endif %}
+    {% endfor %}
+    
+    result = await api.{{ model.tablename }}.find(
+        {% for column in model.columns if column.args.get('primary_key', False) %}
+        {{ column.name }}={{ column.name }},
+        {% endfor %}
+        includes=includes
+    )
+    
+    if result is None:
+        raise RecordNotFoundException("{{ model.name }}")
+        
+    return APIResponse.success(
+        data=result,
+        message="{{ model.name }} obtenido exitosamente"
+    )
+
+@{{ router_name }}.get("/count", tags=["{{ model.name }}"], response_model=APIResponse[int])
+async def {{ model.tablename }}_count(
+    {{ macros.generate_query_parameters(model).rstrip('\n') | indent(4) }}
+    api: {{ crud_class }} = Depends({{ crud_class }})
+) -> APIResponse[int]:
+    """
+    Cuenta el número de {{ model.name }}s que coinciden con los filtros.
+    """
+    result = await api.{{ model.tablename }}.count(
+        {{ macros.asing_parameters(model).rstrip('\n') | indent(8) }}
+    )
+    
+    return APIResponse.success(
+        data=result,
+        message="Conteo realizado exitosamente"
+    )
+
+@{{ router_name }}.get("/exists", tags=["{{ model.name }}"], response_model=APIResponse[bool])
+async def {{ model.tablename }}_exists(
+    {{ macros.generate_query_parameters(model).rstrip('\n') | indent(4) }}
+    api: {{ crud_class }} = Depends({{ crud_class }})
+) -> APIResponse[bool]:
+    """
+    Verifica si existe al menos un {{ model.name }} que coincida con los filtros.
+    """
+    result = await api.{{ model.tablename }}.exists(
+        {{ macros.asing_parameters(model).rstrip('\n') | indent(8) }}
+    )
+    
+    return APIResponse.success(
+        data=result,
+        message="Verificación realizada exitosamente"
+    )
+
+@{{ router_name }}.post("/", tags=["{{ model.name }}"], response_model=APIResponse[{{ model.name }}Read])
+async def {{ model.tablename }}_create(
+    {{ model.tablename }}: {{ model.name }}Create,
+    api: {{ crud_class }} = Depends({{ crud_class }})
+) -> APIResponse[{{ model.name }}Read]:
+    """
+    Crea un nuevo {{ model.name }}.
+    """
+    result = await api.{{ model.tablename }}.create({{ model.tablename }})
+    
+    return APIResponse.success(
+        data=result,
+        message="{{ model.name }} creado exitosamente"
+    )
+
+@{{ router_name }}.patch("{{ pk_path_params }}", tags=["{{ model.name }}"], response_model=APIResponse[int])
+async def {{ model.tablename }}_update(
+    {% for column in model.columns if column.args.get('primary_key', False) %}
+    {{ column.name }}: {{ column.type }},
+    {% endfor %}
+    values: {{ model.name }}UpdateValues,
+    api: {{ crud_class }} = Depends({{ crud_class }})
+) -> APIResponse[int]:
+    """
+    Actualiza un {{ model.name }} específico.
+    """
+    # Validaciones básicas de entrada
+    {% for column in model.columns if column.args.get('primary_key', False) %}
+    {% if column.type in ['int', 'BigInteger'] %}
+    if {{ column.name }} <= 0:
+        raise ValidationException("{{ column.name }} debe ser mayor a 0", "{{ column.name }}")
+    {% endif %}
+    {% endfor %}
+    
+    # Verificar que el registro existe antes de actualizar
+    existing = await api.{{ model.tablename }}.find(
+        {% for column in model.columns if column.args.get('primary_key', False) %}
+        {{ column.name }}={{ column.name }},
+        {% endfor %}
+    )
+    
+    if existing is None:
+        raise RecordNotFoundException("{{ model.name }}")
+    
+    result = await api.{{ model.tablename }}.update(
+        {% for column in model.columns if column.args.get('primary_key', False) %}
+        {{ column.name }}={{ column.name }},
+        {% endfor %}
+        updated_values=values
+    )
+    
+    if result == 0:
+        raise RecordNotFoundException("{{ model.name }}")
+        
+    return APIResponse.success(
+        data=result,
+        message="{{ model.name }} actualizado exitosamente"
+    )
+
+@{{ router_name }}.patch("/", tags=["{{ model.name }}"], response_model=APIResponse[int])
+async def {{ model.tablename }}_update_many(
+    payload: {{ model.name }}Update,
+    api: {{ crud_class }} = Depends({{ crud_class }})
+) -> APIResponse[int]:
+    """
+    Actualiza múltiples {{ model.name }}s.
+    """
+    result = await api.{{ model.tablename }}.update_many(payload)
+    
+    message = f"{result} {{ model.name }}s actualizados exitosamente" if result > 0 else "No se encontraron registros que coincidan con los criterios"
+    
+    return APIResponse.success(
+        data=result,
+        message=message
+    )
+
+@{{ router_name }}.delete("{{ pk_path_params }}", tags=["{{ model.name }}"], response_model=APIResponse[int])
+async def {{ model.tablename }}_delete(
+    {% for column in model.columns if column.args.get('primary_key', False) %}
+    {{ column.name }}: {{ column.type }},
+    {% endfor %}
+    api: {{ crud_class }} = Depends({{ crud_class }})
+) -> APIResponse[int]:
+    """
+    Elimina un {{ model.name }} por su primary key.
+    """
+    # Validaciones básicas de entrada
+    {% for column in model.columns if column.args.get('primary_key', False) %}
+    {% if column.type in ['int', 'BigInteger'] %}
+    if {{ column.name }} <= 0:
+        raise ValidationException("{{ column.name }} debe ser mayor a 0", "{{ column.name }}")
+    {% endif %}
+    {% endfor %}
+    
+    # Verificar que el registro existe antes de eliminar
+    existing = await api.{{ model.tablename }}.find(
+        {% for column in model.columns if column.args.get('primary_key', False) %}
+        {{ column.name }}={{ column.name }},
+        {% endfor %}
+    )
+    
+    if existing is None:
+        raise RecordNotFoundException("{{ model.name }}")
+    
+    result = await api.{{ model.tablename }}.delete(
+        {% for column in model.columns if column.args.get('primary_key', False) %}
+        {{ column.name }}={{ column.name }},
+        {% endfor %}
+    )
+    
+    if result == 0:
+        raise RecordNotFoundException("{{ model.name }}")
+        
+    return APIResponse.success(
+        data=result,
+        message="{{ model.name }} eliminado exitosamente"
+    )
+{% endif %}