// GENERADO por puerto. Edita puerto.toml y después ejecuta `puerto generar bootstrap`.
{% if auth -%}
use std::sync::Arc;
{% endif -%}
{% if local -%}
use aplicacion_usuario::login::LoginImpl;
use aplicacion_usuario::logout::LogoutImpl;
use aplicacion_usuario::registrar_usuario::RegistrarUsuarioImpl;
use dominio_usuario::repositorio::RepositorioUsuario;
use infra_usuario::repositorio::RepositorioUsuarioPostgres;
use poem::EndpointExt;
use puerto_sqlx::auth::{CredencialesPostgres, SesionesPostgres};
{% elif auth -%}
use infra_usuario::aprovisionamiento::AutenticadorAprovisionador;
use infra_usuario::repositorio::RepositorioUsuario{% if user_db %}Postgres{% else %}EnMemoria{% endif %};
use poem::EndpointExt;
{% endif -%}
use poem::Endpoint;
use poem_openapi::OpenApiService;
{% if local %}use puerto_nucleo::auth::{Autenticador, AlmacenCredenciales, HasherContrasena};
{% elif auth %}use puerto_nucleo::auth::Autenticador;
{% endif -%}
{% if local %}use rest_usuario::auth::rutas::ApiAuth;
{% endif -%}
{% if auth %}use rest_usuario::me::rutas::ApiMe;
{% endif -%}
{% for entity in entities -%}
use rest_{{ entity.snake }}::rutas::Api{{ entity.pascal }};
{% endfor %}
/// Las rutas, cableadas. Un error es lo que paró el arranque: `main` lo muestra y sale con 1.
pub async fn construir_app(config: puerto_web::Config) -> Result<impl Endpoint, String> {
{%- if has_db %}
let database_url = std::env::var("DATABASE_URL")
.map_err(|_| "DATABASE_URL no está definida — defínela en .env (.env.example trae una)".to_string())?;
let pool = puerto_sqlx::crear_pool_postgres(&database_url)
.await
.map_err(|e| format!("{e} — ¿está arrancada la base de datos? `make docker-compose/up`"))?;
puerto_sqlx::ejecutar_migraciones(&pool, &migrador::MIGRADOR)
.await
.map_err(|e| e.to_string())?;
{% endif %}
{%- if local %}
// Cuentas en esta base de datos (ADR-0021 § 2): sus sesiones son lo que consulta cada
// `BearerAuth`.
let usuarios: Arc<dyn RepositorioUsuario> = Arc::new(RepositorioUsuarioPostgres::new(pool.clone()));
let credenciales: Arc<dyn AlmacenCredenciales> = Arc::new(CredencialesPostgres::new(pool.clone()));
let hasher: Arc<dyn HasherContrasena> = Arc::new(puerto_auth::local::HasherArgon2::new());
let sesiones = Arc::new(SesionesPostgres::new(
pool.clone(),
puerto_sqlx::auth::ttl_sesion_from_env()?,
));
let autenticador: Arc<dyn Autenticador> = sesiones.clone();
let api_auth = ApiAuth {
registrar_usuario: Arc::new(RegistrarUsuarioImpl {
usuarios: Arc::clone(&usuarios),
credenciales: Arc::clone(&credenciales),
hasher: Arc::clone(&hasher),
}),
login: Arc::new(LoginImpl {
usuarios,
credenciales,
hasher,
sesiones: sesiones.clone(),
}),
logout: Arc::new(LogoutImpl { sesiones }),
};
let api_me = ApiMe;
{% elif auth %}
// Los tokens del proveedor, y una fila `Usuario` para cada quien llama (ADR-0021 § 3).
let config_auth = puerto_auth::ConfigOidc::from_env().map_err(|e| e.to_string())?;
let emisor = config_auth.emisor.clone();
let proveedor = puerto_auth::AutenticadorOidc::descubrir(config_auth)
.await
.map_err(|e| format!("{e} — ¿está arrancado el proveedor de auth? `make docker-compose/up`"))?;
let autenticador: Arc<dyn Autenticador> = Arc::new(AutenticadorAprovisionador::new(
Arc::new(proveedor),
Arc::new({% if user_db %}RepositorioUsuarioPostgres::new(pool.clone()){% else %}RepositorioUsuarioEnMemoria::new(){% endif %}),
emisor,
));
let api_me = ApiMe;
{% endif %}
{%- for entity in entities %}
{%- if entity.use_cases %}
let casos_{{ entity.snake }} = cableado::{{ entity.snake }}::construir({% if entity.db %}&pool{% endif %});
{%- endif %}
let api_{{ entity.snake }} = Api{{ entity.pascal }} {% if entity.use_cases %}{ {% for uc in entity.use_cases %}{{ uc.action }}: casos_{{ entity.snake }}.{{ uc.action }}{% if not loop.last %}, {% endif %}{% endfor %} }{% else %}{}{% endif %};
{% endfor %}{%- if has_db %}
let disponible = puerto_web::health::sondear(move || {
let pool = pool.clone();
async move { puerto_sqlx::ping(&pool).await }
});
{%- else %}
let disponible = puerto_web::health::siempre_disponible();
{%- endif %}
// `app.rs` es del proyecto: el middleware y las rutas que se añadan allí envuelven todo esto.
Ok(crate::app::configurar(puerto_web::rutas(
servicio_openapi({{ apis }}),
&config,
disponible,
)){% if auth %}
// Lo que consulta cada `BearerAuth`.
.data(autenticador){% endif %})
}
/// El servicio de la API, construido en un solo sitio: cualquier otro que lea su spec (el test de
/// exportación de un proyecto con `web/`) ve la API que responde el servidor.
fn servicio_openapi<T: poem_openapi::OpenApi>(api: T) -> OpenApiService<T, ()> {
OpenApiService::new(api, env!("CARGO_PKG_NAME"), env!("CARGO_PKG_VERSION"))
}
{%- if web %}
#[cfg(test)]
mod tests {
use super::*;
{%- if wraps_mocks %}
use std::sync::Arc;
{%- endif %}
{% for entity in entities -%}
{% for uc in entity.use_cases %}
use aplicacion_{{ entity.snake }}::{{ uc.action }}::dobles::Mock{{ uc.uc_pascal }};
{%- endfor %}
{%- endfor %}
{%- if local %}
use aplicacion_usuario::login::dobles::MockLogin;
use aplicacion_usuario::logout::dobles::MockLogout;
use aplicacion_usuario::registrar_usuario::dobles::MockRegistrarUsuario;
{%- endif %}
/// El contrato de la API del que se generan los tipos del frontend (`make web/sync`).
const OPENAPI_JSON: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/../../docs/api/openapi.json");
/// Se construye con casos de uso dobles: sin servidor ni base de datos. Si falta el fichero,
/// se escribe; si es distinto, falla: ejecuta `make web/sync` (pone `UPDATE_OPENAPI=1`) y haz
/// commit del diff.
#[test]
fn la_spec_openapi_coincide_con_docs_api_openapi_json() {
{%- for entity in entities %}
let api_{{ entity.snake }} = Api{{ entity.pascal }} {% if entity.use_cases %}{ {% for uc in entity.use_cases %}{{ uc.action }}: Arc::new(Mock{{ uc.uc_pascal }}::new()){% if not loop.last %}, {% endif %}{% endfor %} }{% else %}{}{% endif %};
{%- endfor %}
{%- if auth %}
let api_me = ApiMe;
{%- endif %}
{%- if local %}
let api_auth = ApiAuth {
registrar_usuario: Arc::new(MockRegistrarUsuario::new()),
login: Arc::new(MockLogin::new()),
logout: Arc::new(MockLogout::new()),
};
{%- endif %}
let spec = servicio_openapi({{ apis }}).spec();
let ruta = std::path::Path::new(OPENAPI_JSON);
if std::env::var_os("UPDATE_OPENAPI").is_some() || !ruta.exists() {
let directorio = ruta.parent().expect("docs/api/openapi.json tiene directorio padre");
std::fs::create_dir_all(directorio).expect("crear docs/api");
std::fs::write(ruta, &spec).expect("escribir docs/api/openapi.json");
return;
}
let en_disco = std::fs::read_to_string(ruta).expect("leer docs/api/openapi.json");
assert!(
en_disco == spec,
"docs/api/openapi.json no es la API que sirve este código: ejecuta `make web/sync`"
);
}
}
{%- endif %}