use crate::generators::layout::{self, Layer};
use std::path::Path;
use crate::generators::crates::ContextDeps;
use crate::generators::effective_fields;
use crate::generators::merge::merge_use_case;
use crate::generators::naming::{
crud_use_case, entity_ctx, pascal_to_snake, to_pascal_case, write_file,
};
use crate::generators::render::{RenderError, render};
use crate::generators::types::{FieldCtx, field_ctx, is_value_object, vo_import_path};
use crate::puerto_toml::{Field, ValueObjectDefinition};
fn use_case_context(
pascal: &str,
snake: &str,
fields: &[Field],
shared_vos: &[ValueObjectDefinition],
) -> tera::Context {
let eff = effective_fields(fields);
let mut vo_imports: Vec<String> = vec![];
for import in eff
.iter()
.filter(|f| is_value_object(f))
.map(|f| vo_import_path(f, snake, shared_vos, false))
{
if !vo_imports.contains(&import) {
vo_imports.push(import);
}
}
let field_ctxs: Vec<FieldCtx> = eff
.iter()
.map(|f| field_ctx(f, pascal, shared_vos))
.collect();
let mut ctx = entity_ctx(pascal, snake);
ctx.insert("fields", &field_ctxs);
ctx.insert("vo_imports", &vo_imports);
let mut reference_imports = vec![];
crate::generators::domain::push_reference_imports(&mut reference_imports, &eff);
ctx.insert("reference_imports", &reference_imports);
ctx
}
#[cfg(test)]
fn render_use_case(
action: &str,
pascal: &str,
snake: &str,
fields: &[Field],
shared_vos: &[ValueObjectDefinition],
) -> Result<String, RenderError> {
render_use_case_as(action, pascal, snake, fields, shared_vos, false)
}
fn render_use_case_as(
action: &str,
pascal: &str,
snake: &str,
fields: &[Field],
shared_vos: &[ValueObjectDefinition],
actor: bool,
) -> Result<String, RenderError> {
let mut ctx = use_case_context(pascal, snake, fields, shared_vos);
ctx.insert("actor", &actor);
render(&format!("application/{action}.tera"), &ctx)
}
fn render_write_use_case_with_events(
action: &str,
pascal: &str,
snake: &str,
fields: &[Field],
shared_vos: &[ValueObjectDefinition],
actor: bool,
) -> Result<String, RenderError> {
let mut ctx = use_case_context(pascal, snake, fields, shared_vos);
ctx.insert("actor", &actor);
render(&format!("application/{action}_events.tera"), &ctx)
}
#[cfg(test)]
pub fn generate_create_use_case_impl(
pascal: &str,
snake: &str,
fields: &[Field],
shared_vos: &[ValueObjectDefinition],
) -> Result<String, RenderError> {
render_use_case("create", pascal, snake, fields, shared_vos)
}
#[cfg(test)]
pub fn generate_get_use_case_impl(
pascal: &str,
snake: &str,
fields: &[Field],
shared_vos: &[ValueObjectDefinition],
) -> Result<String, RenderError> {
render_use_case("get", pascal, snake, fields, shared_vos)
}
#[cfg(test)]
pub fn generate_list_use_case_impl(
pascal: &str,
snake: &str,
fields: &[Field],
shared_vos: &[ValueObjectDefinition],
) -> Result<String, RenderError> {
render_use_case("list", pascal, snake, fields, shared_vos)
}
#[cfg(test)]
pub fn generate_update_use_case_impl(
pascal: &str,
snake: &str,
fields: &[Field],
shared_vos: &[ValueObjectDefinition],
) -> Result<String, RenderError> {
render_use_case("update", pascal, snake, fields, shared_vos)
}
#[cfg(test)]
pub fn generate_delete_use_case_impl(
pascal: &str,
snake: &str,
fields: &[Field],
shared_vos: &[ValueObjectDefinition],
) -> Result<String, RenderError> {
render_use_case("delete", pascal, snake, fields, shared_vos)
}
fn render_contract(
action: &str,
pascal: &str,
snake: &str,
fields: &[Field],
shared_vos: &[ValueObjectDefinition],
actor: bool,
) -> Result<String, RenderError> {
let template = format!("domain/use_case_{action}.tera");
if matches!(action, "create" | "update") {
return crate::generators::domain::generate_use_case_trait(
&template,
&[],
pascal,
snake,
fields,
actor,
);
}
let eff = effective_fields(fields);
let field_ctxs: Vec<FieldCtx> = eff
.iter()
.map(|f| field_ctx(f, pascal, shared_vos))
.collect();
let mut reference_imports = vec![];
crate::generators::domain::push_reference_imports(&mut reference_imports, &eff);
let mut ctx = entity_ctx(pascal, snake);
ctx.insert("fields", &field_ctxs);
ctx.insert("reference_imports", &reference_imports);
ctx.insert("actor", &actor);
render(&template, &ctx)
}
pub fn write_application_files(
pascal: &str,
snake: &str,
base: &Path,
fields: &[Field],
shared_vos: &[ValueObjectDefinition],
) -> Result<(), Box<dyn std::error::Error>> {
let access = crate::generators::auth::Access::of(base, pascal);
let config = crate::puerto_toml::read(base).ok();
let events = config.as_ref().is_some_and(|c| c.project.has_events());
for action in ["create", "get", "list", "update", "delete"] {
let use_case = crud_use_case(action, snake);
let actor = access.is_protected(&use_case);
let implementation = if events && matches!(action, "create" | "update" | "delete") {
render_write_use_case_with_events(action, pascal, snake, fields, shared_vos, actor)?
} else {
render_use_case_as(action, pascal, snake, fields, shared_vos, actor)?
};
let contract = render_contract(action, pascal, snake, fields, shared_vos, actor)?;
write_file(
&base.join(layout::use_case(snake, &use_case)),
&merge_use_case(&contract, &implementation),
)?;
}
crate::generators::crates::finish(
base,
snake,
Layer::Application,
&ContextDeps::read(base, fields),
)
}
pub fn run_generate_application(name: &str, base: &Path) -> Result<(), Box<dyn std::error::Error>> {
let config = crate::puerto_toml::read(base)?;
let pascal = to_pascal_case(name);
let snake = pascal_to_snake(&pascal);
if !config.entity.iter().any(|e| e.name == pascal) {
return Err(format!(
"{pascal} not found in puerto.toml. Run `puerto generar dominio {pascal}` first."
)
.into());
}
let fields: Vec<Field> = config
.entity
.iter()
.find(|e| e.name == pascal)
.map(|e| e.fields.clone())
.unwrap_or_default();
let shared_vos = config.value_object.clone();
write_application_files(&pascal, &snake, base, &fields, &shared_vos)?;
println!(
"✓ {}/ — 5 use cases (create, get, list, update, delete)",
layout::crate_dir(&snake, Layer::Application)
);
println!();
println!(" Next: puerto generar repositorio {pascal}");
Ok(())
}