use crate::generators::layout::{self, Layer};
use std::collections::BTreeMap;
use std::fs;
use std::path::Path;
use serde::Serialize;
use crate::generators::bootstrap::uses_unit_of_work;
use crate::generators::naming::{
crud_events, event_variant, pascal_to_snake, to_pascal_case, write_file,
};
use crate::generators::render::render;
use crate::puerto_toml::{Consumer, PuertoConfig};
pub const KAFKA_TRANSPORT: &str = "kafka";
const RESERVED_CONSUMER_TYPES: &[&str] = &[
"Arc",
"SobreEvento",
"ManejadorEvento",
"ResultadoManejo",
"ConfigKafka",
"PublicadorKafka",
"SuscripcionKafka",
"Bucles",
"DescartadosPostgres",
"EntregasPostgres",
"OutboxPostgres",
"SuscripcionPostgres",
"ConfigWorker",
];
#[derive(Debug, Clone, PartialEq, Serialize)]
pub struct DeclaredEvent {
pub event_type: String,
pub constant: String,
pub const_lower: String,
pub variant: String,
pub entity_pascal: String,
pub entity_snake: String,
}
pub fn declared_events(config: &PuertoConfig) -> Vec<DeclaredEvent> {
config
.entity
.iter()
.filter(|e| uses_unit_of_work(e, config.project.has_events()))
.flat_map(|entity| {
let snake = pascal_to_snake(&entity.name);
crud_events(&snake)
.into_iter()
.chain(
entity
.events
.iter()
.map(|event| (event_variant(&snake, event), event.clone())),
)
.map(|(variant, event_type)| DeclaredEvent {
constant: event_type.to_uppercase(),
const_lower: event_type.clone(),
event_type,
variant,
entity_pascal: entity.name.clone(),
entity_snake: snake.clone(),
})
.collect::<Vec<_>>()
})
.collect()
}
pub fn has_worker(config: &PuertoConfig) -> bool {
config.project.events.is_some()
}
fn on_kafka(config: &PuertoConfig) -> bool {
config.project.events.as_deref() == Some(KAFKA_TRANSPORT)
}
pub(crate) fn subscribed(
consumer: &Consumer,
declared: &[DeclaredEvent],
) -> Result<Vec<DeclaredEvent>, String> {
consumer
.events
.iter()
.map(|event| {
declared
.iter()
.find(|d| d.event_type == *event)
.cloned()
.ok_or_else(|| undeclared_event(event, declared))
})
.collect()
}
fn undeclared_event(event: &str, declared: &[DeclaredEvent]) -> String {
let known: Vec<&str> = declared.iter().map(|d| d.event_type.as_str()).collect();
if known.is_empty() {
format!("event '{event}' is not declared: no CRUD entity records events yet")
} else {
format!(
"event '{event}' is not declared by any entity. Declared: {}",
known.join(", ")
)
}
}
#[derive(Serialize)]
struct RegistryConsumer {
name: String,
pascal: String,
events: Vec<String>,
aggregates: Vec<String>,
handler: String,
}
pub fn generate_registry(config: &PuertoConfig) -> Result<String, Box<dyn std::error::Error>> {
let declared = declared_events(config);
let mut constants: BTreeMap<String, Vec<String>> = BTreeMap::new();
let mut consumers = vec![];
for consumer in &config.consumer {
let events = subscribed(consumer, &declared)
.map_err(|e| format!("consumer '{}': {e}", consumer.name))?;
for event in &events {
let names = constants.entry(event.entity_snake.clone()).or_default();
if !names.contains(&event.constant) {
names.push(event.constant.clone());
}
}
let mut aggregates: Vec<String> = events.iter().map(|e| e.entity_snake.clone()).collect();
aggregates.sort();
aggregates.dedup();
let pascal = to_pascal_case(&consumer.name);
consumers.push(RegistryConsumer {
name: consumer.name.clone(),
handler: format!("{pascal}::construir(&pool)"),
pascal,
events: events.into_iter().map(|e| e.constant).collect(),
aggregates,
});
}
let mut template_mailers: Vec<String> = vec![];
for mail in config.mail.iter().filter(|m| !m.on.is_empty()) {
let consumer = Consumer {
name: format!("correo_{}", mail.name),
events: mail.on.clone(),
};
let events =
subscribed(&consumer, &declared).map_err(|e| format!("mail '{}': {e}", mail.name))?;
for event in &events {
let names = constants.entry(event.entity_snake.clone()).or_default();
if !names.contains(&event.constant) {
names.push(event.constant.clone());
}
}
let mut aggregates: Vec<String> = events.iter().map(|e| e.entity_snake.clone()).collect();
aggregates.sort();
aggregates.dedup();
let mail_pascal = to_pascal_case(&mail.name);
template_mailers.push(format!(
"infra_correo::{}::EnviadorCorreo{mail_pascal}Plantilla",
mail.name
));
let pascal = format!("EnviarCorreo{mail_pascal}");
consumers.push(RegistryConsumer {
handler: format!(
"{pascal} {{ enviador: Arc::new(EnviadorCorreo{mail_pascal}Plantilla::new(enviador.clone())), \
correos_enviados: correos_enviados.clone() }}"
),
name: consumer.name,
pascal,
events: events.into_iter().map(|e| e.constant).collect(),
aggregates,
});
}
let mails = !template_mailers.is_empty();
let mut imports: Vec<String> = constants
.into_iter()
.map(|(snake, mut names)| {
names.sort();
format!("dominio_{snake}::eventos::{}", braced(&names))
})
.collect();
let kafka = on_kafka(config);
let adapters: &[&str] = match (kafka, consumers.is_empty()) {
(false, true) => &["EntregasPostgres", "OutboxPostgres"],
(false, false) => &[
"DescartadosPostgres",
"EntregasPostgres",
"OutboxPostgres",
"SuscripcionPostgres",
],
(true, true) => &["OutboxPostgres"],
(true, false) => &["DescartadosPostgres", "OutboxPostgres"],
};
let adapters: Vec<String> = adapters.iter().map(|a| a.to_string()).collect();
imports.push(format!("puerto_sqlx::eventos::{}", braced(&adapters)));
if mails {
imports.push("puerto_sqlx::correo::CorreosEnviadosPostgres".into());
imports.extend(template_mailers);
}
imports.push("puerto_eventos::{Bucles, ConfigWorker}".into());
if kafka {
let types = if consumers.is_empty() {
"{ConfigKafka, PublicadorKafka}"
} else {
"{ConfigKafka, PublicadorKafka, SuscripcionKafka}"
};
imports.push(format!("puerto_kafka::{types}"));
}
if mails {
imports.push("puerto_correo::{ConfigCorreo, EnviadorCorreoSmtp}".into());
}
let mut modules: Vec<(&str, &str)> = consumers
.iter()
.map(|c| (c.name.as_str(), c.pascal.as_str()))
.collect();
modules.sort_unstable();
let mut ctx = tera::Context::new();
ctx.insert("imports", &imports);
ctx.insert("consumers", &consumers);
ctx.insert("modules", &modules);
ctx.insert("mails", &mails);
if !kafka {
return Ok(render("worker/registry.tera", &ctx)?);
}
let mut aggregates: Vec<String> = declared.into_iter().map(|e| e.entity_snake).collect();
aggregates.sort();
aggregates.dedup();
ctx.insert("aggregates", &aggregates);
ctx.insert("project", &config.project.name);
Ok(render("worker/registry_kafka.tera", &ctx)?)
}
fn braced(names: &[String]) -> String {
match names {
[single] => single.clone(),
_ => format!("{{{}}}", names.join(", ")),
}
}
pub fn generate_consumer(
name: &str,
events: &[DeclaredEvent],
) -> Result<String, Box<dyn std::error::Error>> {
let Some(first) = events.first() else {
return Err(format!("consumer '{name}' subscribes to no event").into());
};
let mut by_entity: BTreeMap<&str, (Vec<String>, &str)> = BTreeMap::new();
for event in events {
let (names, pascal) = by_entity
.entry(&event.entity_snake)
.or_insert((vec![], &event.entity_pascal));
names.push(event.constant.clone());
if !names.contains(&format!("Snapshot{pascal}")) {
names.push(format!("Snapshot{pascal}"));
}
}
let imports: Vec<String> = by_entity
.into_iter()
.map(|(snake, (mut names, _))| {
names.sort();
format!("dominio_{snake}::eventos::{}", braced(&names))
})
.collect();
let mut ctx = tera::Context::new();
ctx.insert("name", name);
ctx.insert("pascal", &to_pascal_case(name));
ctx.insert("events", events);
ctx.insert("first", first);
ctx.insert("imports", &imports);
Ok(render("worker/consumer.tera", &ctx)?)
}
pub fn regenerate_registry(
base: &Path,
config: &PuertoConfig,
) -> Result<(), Box<dyn std::error::Error>> {
let dir = base.join(layout::WORKER_GENERATED_DIR);
if !has_worker(config) || !dir.is_dir() {
return Ok(());
}
write_file(&base.join(layout::REGISTRY_RS), &generate_registry(config)?)?;
add_worker_dependencies(base, config)
}
fn add_worker_dependencies(
base: &Path,
config: &PuertoConfig,
) -> Result<(), Box<dyn std::error::Error>> {
use crate::generators::bootstrap::add_crate_dependency;
let declared = declared_events(config);
let mut contexts: Vec<String> = vec![];
let subscriptions =
config
.consumer
.iter()
.cloned()
.chain(
config
.mail
.iter()
.filter(|m| !m.on.is_empty())
.map(|m| Consumer {
name: format!("correo_{}", m.name),
events: m.on.clone(),
}),
);
for consumer in subscriptions {
for event in subscribed(&consumer, &declared)? {
if !contexts.contains(&event.entity_snake) {
contexts.push(event.entity_snake);
}
}
}
contexts.sort();
for c in &contexts {
let name = layout::crate_name(c, Layer::Domain);
add_crate_dependency(
base,
layout::WORKER_MANIFEST,
"dependencies",
&name,
"{ workspace = true }",
)?;
add_crate_dependency(
base,
layout::WORKER_MANIFEST,
"dev-dependencies",
&name,
"{ workspace = true, features = [\"pruebas\"] }",
)?;
}
if config.mail.iter().any(|m| !m.on.is_empty()) {
let correo = layout::MAIL_CONTEXT;
for layer in [Layer::Domain, Layer::Infrastructure] {
add_crate_dependency(
base,
layout::WORKER_MANIFEST,
"dependencies",
&layout::crate_name(correo, layer),
"{ workspace = true }",
)?;
}
add_crate_dependency(
base,
layout::WORKER_MANIFEST,
"dev-dependencies",
&layout::crate_name(correo, Layer::Domain),
"{ workspace = true, features = [\"pruebas\"] }",
)?;
}
Ok(())
}
pub(crate) fn with_module(src: &str, name: &str) -> String {
let declaration = format!("pub mod {name};");
let (mut modules, other): (Vec<&str>, Vec<&str>) = src
.lines()
.partition(|line| line.starts_with("pub mod ") && line.ends_with(';'));
if !modules.contains(&declaration.as_str()) {
modules.push(&declaration);
}
modules.sort_unstable();
other
.into_iter()
.chain(modules)
.map(|line| format!("{line}\n"))
.collect()
}
fn makefile_targets(db_name: &str) -> String {
format!(
r#"
.PHONY: worker eventos/descartados
worker: docker-compose/up ## Arranca el worker: hace de relay del outbox y ejecuta los consumidores (health en :8081)
@echo "${{GREEN}}Arrancando el worker...${{NC}}"
$(CARGO) run -p worker
eventos/descartados: docker-compose/up ## Lista los 20 eventos descartados más recientes
$(DOCKER_COMPOSE) exec -T postgres psql -U devuser -d {db_name} -c \
"SELECT registrado_en, consumidor, tipo_evento, intentos, motivo, detalle FROM descartados ORDER BY registrado_en DESC LIMIT 20"
"#
)
}
pub fn apply_worker_to_new_project(base: &Path) -> Result<(), Box<dyn std::error::Error>> {
let config = crate::puerto_toml::read(base)?;
let kafka = on_kafka(&config);
crate::generators::project::add_workspace_dependency(base, "puerto-eventos")?;
if kafka {
crate::generators::project::add_workspace_dependency(base, "puerto-kafka")?;
}
let mut ctx = tera::Context::new();
ctx.insert("kafka", &kafka);
for (path, template) in [
(layout::WORKER_MANIFEST, "worker/cargo_toml.tera"),
(
&format!("{}/AGENTS.md", layout::WORKER_DIR),
"worker/agents.tera",
),
(
&format!("{}/main.rs", layout::WORKER_SRC),
"worker/main.tera",
),
(
&format!("{}/generado.rs", layout::WORKER_SRC),
"worker/generated.tera",
),
(layout::CONSUMERS_RS, "worker/consumers.tera"),
] {
write_file(&base.join(path), &render(template, &ctx)?)?;
}
write_file(
&base.join(layout::REGISTRY_RS),
&generate_registry(&config)?,
)?;
crate::generators::crates::sync_workspace_dependencies(base)?;
let makefile = base.join("Makefile");
if makefile.exists() {
let mut src = fs::read_to_string(&makefile)?;
if !src.contains("eventos/descartados") {
let db_name = config.project.name.replace('-', "_");
src.push_str(&makefile_targets(&db_name));
fs::write(&makefile, src)?;
}
}
for file in [".env", ".env.example"] {
let path = base.join(file);
let mut content = fs::read_to_string(&path).unwrap_or_default();
if !content.contains("WORKER_PORT") {
content.push_str("\n# Worker\nWORKER_PORT=8081\n");
}
if kafka && !content.contains("KAFKA_BROKERS") {
content.push_str(
"\n# Kafka (Redpanda, en docker-compose.yml)\nKAFKA_BROKERS=localhost:9092\n",
);
}
fs::write(&path, content)?;
}
if kafka {
add_redpanda_to_compose(base, &config.project.name)?;
}
Ok(())
}
fn redpanda_service(project_name: &str) -> String {
format!(
r#" redpanda:
image: docker.redpanda.com/redpandadata/redpanda:v24.2.7
container_name: {project_name}-redpanda
command:
- redpanda
- start
- --mode
- dev-container
- --smp
- "1"
- --kafka-addr
- PLAINTEXT://0.0.0.0:9092
- --advertise-kafka-addr
- PLAINTEXT://localhost:${{KAFKA_HOST_PORT:-9092}}
ports:
- "${{KAFKA_HOST_PORT:-9092}}:9092"
volumes:
- redpanda-data:/var/lib/redpanda/data
restart: unless-stopped
healthcheck:
test: ["CMD-SHELL", "rpk cluster health | grep -q 'Healthy:.*true'"]
interval: 5s
timeout: 5s
retries: 10
"#
)
}
fn add_redpanda_to_compose(
base: &Path,
project_name: &str,
) -> Result<(), Box<dyn std::error::Error>> {
let path = base.join("docker-compose.yml");
let src = fs::read_to_string(&path)?;
if src.contains("redpanda:") {
return Ok(());
}
let Some(at) = src.find("\nvolumes:\n") else {
return Err(format!("{}: no top-level `volumes:`", path.display()).into());
};
let out = format!(
"{}{}{} redpanda-data:\n",
&src[..=at],
redpanda_service(project_name),
&src[at..]
);
fs::write(&path, out)?;
Ok(())
}
pub fn run_generate_consumer(
name: &str,
events: &[String],
base: &Path,
) -> Result<(), Box<dyn std::error::Error>> {
let config = crate::puerto_toml::read(base)?;
if !has_worker(&config) {
return Err(
"this project has no worker — consumers need a project created with \
`puerto nuevo --db --eventos db|kafka`"
.into(),
);
}
crate::validation::validate_consumer_name(name)?;
let pascal = to_pascal_case(name);
let taken = RESERVED_CONSUMER_TYPES.contains(&pascal.as_str())
|| config.entity.iter().any(|e| {
[
format!("Evento{}", e.name),
format!("Snapshot{}", e.name),
format!("Madre{}", e.name),
]
.contains(&pascal)
});
if taken {
return Err(format!(
"consumer name '{name}' would be the type `{pascal}`, which the worker already uses"
)
.into());
}
if config.consumer.iter().any(|c| c.name == name) {
return Err(format!("consumer '{name}' is already declared").into());
}
if let Some(mail) = name
.strip_prefix("correo_")
.filter(|mail| config.mail.iter().any(|m| m.name == *mail))
{
return Err(format!(
"consumer name '{name}' is reserved: the worker runs mail '{mail}' as the consumer \
'correo_{mail}'. Pick another name"
)
.into());
}
if events.is_empty() {
return Err("a consumer needs at least one event: --tras <event_type>".into());
}
let mut unique: Vec<String> = vec![];
for event in events {
if !unique.contains(event) {
unique.push(event.clone());
}
}
let consumer = Consumer {
name: name.to_string(),
events: unique,
};
let subscribed = subscribed(&consumer, &declared_events(&config))?;
let path = base.join(layout::consumer(name));
if path.exists() {
return Err(format!(
"{} already exists — it is never overwritten. Remove it or pick another name",
path.display()
)
.into());
}
let content = generate_consumer(name, &subscribed)?;
crate::puerto_toml::add_consumer(base, consumer)?;
write_file(&path, &content)?;
let modules = base.join(layout::CONSUMERS_RS);
fs::write(&modules, with_module(&fs::read_to_string(&modules)?, name))?;
regenerate_registry(base, &crate::puerto_toml::read(base)?)?;
println!(
"✓ Consumer '{name}' added, on: {}",
subscribed
.iter()
.map(|e| e.event_type.as_str())
.collect::<Vec<_>>()
.join(", ")
);
println!(
" presentacion/worker/src/consumidores/{name}.rs — yours: make it idempotent, it can see an event twice."
);
println!(
" presentacion/worker/src/generado/registro.rs regenerated. Run it with `make worker`."
);
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn should_sort_only_module_declarations_when_a_consumer_is_added() {
let src = "pub mod zeta;\npub mod helpers {}\n";
let out = with_module(src, "alpha");
assert_eq!(out, "pub mod helpers {}\npub mod alpha;\npub mod zeta;\n");
}
#[test]
fn should_not_declare_a_module_twice() {
assert_eq!(with_module("pub mod audit;\n", "audit"), "pub mod audit;\n");
}
}