use anyhow::{anyhow, Result};
use handlebars::Handlebars;
use std::collections::HashMap;
use std::fs::{self, File};
use std::io::Write;
use std::path::PathBuf;
pub async fn generate_controller(names: String, crud: bool, routes: bool) -> Result<()> {
let project_path = std::env::current_dir()?;
let controller_dir = project_path.join("src").join("controllers");
if !controller_dir.exists() {
fs::create_dir_all(&controller_dir)?;
}
let template_content = include_str!("../../templates/components/controller.rs.template");
let mut handlebars = Handlebars::new();
handlebars.register_template_string("controller", template_content)?;
let controller_names: Vec<&str> = names.split(',').map(|s| s.trim()).collect();
for name in controller_names {
let snake_name = to_snake_case(name);
let controller_path = controller_dir.join(format!("{}.rs", snake_name));
if controller_path.exists() {
println!("⚠️ Controller '{}' already exists, skipping", snake_name);
continue;
}
let mut vars = HashMap::new();
vars.insert("controller_name", snake_name.clone());
vars.insert("controller_title", to_title_case(&snake_name));
vars.insert("route_prefix", snake_name.clone());
vars.insert(
"description",
format!("{} operations", to_title_case(&snake_name)),
);
if crud {
vars.insert("crud", "true".to_string());
}
if routes {
vars.insert("routes", "true".to_string());
}
let rendered = handlebars.render("controller", &vars)?;
let mut file = File::create(&controller_path)?;
file.write_all(rendered.as_bytes())?;
println!("✅ Created controller: {}", controller_path.display());
}
println!("\n📝 Don't forget to:");
println!(" - Add your controller(s) to auto-discovery or manual registration");
println!(" - Create corresponding view templates if using view responses");
if crud {
println!(" - Implement the TODO sections for database operations");
}
Ok(())
}
pub async fn generate_module(name: String, shared: bool, with_methods: bool) -> Result<()> {
let project_path = std::env::current_dir()?;
let module_dir = project_path.join("src").join("modules");
if !module_dir.exists() {
fs::create_dir_all(&module_dir)?;
}
let snake_name = to_snake_case(&name);
let module_path = module_dir.join(format!("{}.rs", snake_name));
if module_path.exists() {
return Err(anyhow!("Module '{}' already exists", snake_name));
}
let template_content = include_str!("../../templates/components/module.rs.template");
let mut handlebars = Handlebars::new();
handlebars.register_template_string("module", template_content)?;
let mut vars = HashMap::new();
vars.insert("module_name", snake_name.clone());
vars.insert("module_title", to_title_case(&snake_name));
vars.insert("module_struct", to_pascal_case(&snake_name));
vars.insert(
"description",
format!("{} functionality", to_title_case(&snake_name)),
);
if shared {
vars.insert("is_service", "true".to_string());
}
if with_methods {
vars.insert("with_methods", "true".to_string());
}
let rendered = handlebars.render("module", &vars)?;
let mut file = File::create(&module_path)?;
file.write_all(rendered.as_bytes())?;
println!("✅ Created module: {}", module_path.display());
println!(
" Type: {}",
if shared {
"Service (SharedModule)"
} else {
"Utility (Simple Helper)"
}
);
if shared {
println!("\n📝 Service Setup Instructions:");
println!(" 1. Add to your main.rs after MODULE::init():");
println!(
" MODULE::register(\"{}\", {}::new())?;",
snake_name,
to_pascal_case(&snake_name)
);
println!(" 2. Access it in your code:");
println!(" let service = MODULE::get(\"{}\")?;", snake_name);
} else {
println!("\n📝 Utility Usage:");
println!(" 1. Import directly in your code:");
println!(" use modules::{}::{{}};", snake_name);
println!(" 2. Use the static functions:");
println!(
" let result = {}::helper_function(input);",
to_pascal_case(&snake_name)
);
}
Ok(())
}
pub async fn generate_middleware(
name: String,
auth: bool,
logging: bool,
priority: i32,
) -> Result<()> {
let project_path = std::env::current_dir()?;
let middleware_dir = project_path.join("src").join("middleware");
if !middleware_dir.exists() {
fs::create_dir_all(&middleware_dir)?;
}
let snake_name = to_snake_case(&name);
let middleware_path = middleware_dir.join(format!("{}.rs", snake_name));
if middleware_path.exists() {
return Err(anyhow!("Middleware '{}' already exists", snake_name));
}
let template_content = include_str!("../../templates/components/middleware.rs.template");
let mut handlebars = Handlebars::new();
handlebars.register_template_string("middleware", template_content)?;
let mut vars = HashMap::new();
vars.insert("middleware_name", snake_name.clone());
vars.insert("middleware_title", to_title_case(&snake_name));
vars.insert("middleware_struct", to_pascal_case(&snake_name));
vars.insert(
"description",
format!(
"{} middleware for request processing",
to_title_case(&snake_name)
),
);
vars.insert("priority", priority.to_string());
if priority < 0 {
vars.insert("priority_negative", "true".to_string());
} else if priority > 0 {
vars.insert("priority_positive", "true".to_string());
}
if auth {
vars.insert("auth", "true".to_string());
}
if logging {
vars.insert("logging", "true".to_string());
}
let rendered = handlebars.render("middleware", &vars)?;
let mut file = File::create(&middleware_path)?;
file.write_all(rendered.as_bytes())?;
println!("✅ Created middleware: {}", middleware_path.display());
println!("\n📝 Don't forget to:");
println!(" - Add your middleware to auto-discovery or manual registration");
println!(" - Configure the middleware behavior as needed");
if auth {
println!(" - Update the protected_paths for your application");
println!(" - Ensure session management is configured");
}
if logging {
println!(" - Configure logging levels in your application");
println!(" - Be careful about logging sensitive data");
}
println!(
" - Priority {} means: {}",
priority,
if priority < 0 {
"runs early in the chain"
} else if priority > 0 {
"runs late in the chain"
} else {
"default execution order"
}
);
Ok(())
}
pub async fn generate_event(name: String, lifecycle: bool, custom: bool) -> Result<()> {
let project_path = std::env::current_dir()?;
let events_dir = project_path.join("src").join("events");
if !events_dir.exists() {
fs::create_dir_all(&events_dir)?;
}
let snake_name = to_snake_case(&name);
let event_path = events_dir.join(format!("{}.rs", snake_name));
if event_path.exists() {
return Err(anyhow!("Event handler '{}' already exists", snake_name));
}
let template_content = include_str!("../../templates/components/event.rs.template");
let mut handlebars = Handlebars::new();
handlebars.register_template_string("event", template_content)?;
let mut vars = HashMap::new();
vars.insert("event_name", snake_name.clone());
vars.insert("event_title", to_title_case(&snake_name));
vars.insert(
"description",
format!("{} events", to_title_case(&snake_name)),
);
if lifecycle {
vars.insert("lifecycle", "true".to_string());
}
if custom {
vars.insert("custom", "true".to_string());
}
let rendered = handlebars.render("event", &vars)?;
let mut file = File::create(&event_path)?;
file.write_all(rendered.as_bytes())?;
println!("✅ Created event handler: {}", event_path.display());
println!("\n📝 Don't forget to:");
println!(" - Add your event handler to auto-discovery with auto_events!()");
println!(" - Or manually register it with .events_from()");
if custom {
println!(" - Emit your custom events from controllers or services");
println!(
" - Example: ctx.emit(\"{}.data.received\", data)?;",
snake_name
);
}
Ok(())
}
fn validate_component_name(snake_name: &str, original: &str) -> Result<()> {
if snake_name.is_empty() {
return Err(anyhow!("the name cannot be empty"));
}
let valid = snake_name
.chars()
.all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '_')
&& !snake_name.starts_with(|c: char| c.is_ascii_digit());
if !valid {
return Err(anyhow!(
"`{original}` is not a usable component name: it becomes both a file name \
and a Rust function, so it must be letters, digits and underscores only, \
and must not start with a digit (for example `chat` or `live_feed`)"
));
}
if snake_name.chars().all(|c| c == '_') {
return Err(anyhow!(
"`{original}` is not a usable component name: it would generate a function \
called `{snake_name}`, which is not an identifier"
));
}
if RUST_KEYWORDS.contains(&snake_name) {
return Err(anyhow!(
"`{original}` is a Rust keyword, so `async fn {snake_name}(..)` would not \
compile; pick another name (for example `{snake_name}_socket`)"
));
}
Ok(())
}
const RUST_KEYWORDS: [&str; 51] = [
"as", "async", "await", "break", "const", "continue", "crate", "dyn", "else", "enum",
"extern", "false", "fn", "for", "if", "impl", "in", "let", "loop", "match", "mod", "move",
"mut", "pub", "ref", "return", "self", "static", "struct", "super", "trait", "true", "try",
"type", "union", "unsafe", "use", "where", "while", "abstract", "become", "box", "do",
"final", "gen", "macro", "override", "priv", "typeof", "unsized", "virtual",
];
pub async fn generate_socket(name: String) -> Result<()> {
let project_path = std::env::current_dir()?;
let snake_name = to_snake_case(&name);
validate_component_name(&snake_name, &name)?;
let route_name = snake_name.replace('_', "-");
let controllers_dir = project_path.join("src").join("controllers");
let views_dir = project_path.join("views").join(&route_name);
let controller_path = controllers_dir.join(format!("{}.rs", snake_name));
let view_path = views_dir.join("index.html");
for path in [&controller_path, &view_path] {
if path.exists() {
return Err(anyhow!(
"{} already exists; pick another name or remove it first",
path.display()
));
}
}
let mut handlebars = Handlebars::new();
handlebars.register_template_string(
"socket",
include_str!("../../templates/components/socket.rs.template"),
)?;
handlebars.register_template_string(
"socket_view",
include_str!("../../templates/views/socket/index.html.template"),
)?;
let mut vars = HashMap::new();
vars.insert("name", route_name.clone());
vars.insert("name_underscored", snake_name.clone());
vars.insert("title", to_title_case(&snake_name));
let controller = handlebars.render("socket", &vars)?;
let view = handlebars.render("socket_view", &vars)?;
for dir in [&controllers_dir, &views_dir] {
if !dir.exists() {
fs::create_dir_all(dir)?;
}
}
File::create(&controller_path)?.write_all(controller.as_bytes())?;
if let Err(error) = File::create(&view_path).and_then(|mut f| f.write_all(view.as_bytes())) {
let _ = fs::remove_file(&controller_path);
return Err(error.into());
}
println!("✅ Created WebSocket controller");
println!(" Controller: {}", controller_path.display());
println!(" View: {}", view_path.display());
println!("\n📝 Next steps:");
println!(" - Controllers are auto-discovered from src/controllers/");
println!(" - Open http://127.0.0.1:8000/{}", route_name);
println!(
" - The socket is at ws://127.0.0.1:8000/{}/socket",
route_name
);
println!(" - Push into the room from anywhere:");
println!(
" SOCKET::room(\"/{}/socket\").map(|r| r.send_json(&payload));",
route_name
);
println!(" - Guide: https://numerum-tech.github.io/rustf/advanced/websocket.html");
Ok(())
}
pub async fn generate_worker(name: String) -> Result<()> {
let project_path = std::env::current_dir()?;
let workers_dir = project_path.join("src").join("workers");
if !workers_dir.exists() {
fs::create_dir_all(&workers_dir)?;
}
let snake_name = to_snake_case(&name);
let worker_path = workers_dir.join(format!("{}.rs", snake_name));
if worker_path.exists() {
return Err(anyhow!("Worker '{}' already exists", snake_name));
}
let template_content = include_str!("../../templates/components/worker.rs.template");
let mut handlebars = Handlebars::new();
handlebars.register_template_string("worker", template_content)?;
let mut vars = HashMap::new();
let kebab_name = snake_name.replace('_', "-");
vars.insert("worker_name", kebab_name.clone());
vars.insert("worker_name_underscored", snake_name.clone());
vars.insert("worker_title", to_title_case(&snake_name));
vars.insert(
"description",
format!(
"{} - background worker for async task execution",
to_title_case(&snake_name)
),
);
let rendered = handlebars.render("worker", &vars)?;
let mut file = File::create(&worker_path)?;
file.write_all(rendered.as_bytes())?;
println!("✅ Created worker: {}", worker_path.display());
println!("\n📝 Next steps:");
println!(" - Workers are auto-discovered from src/workers/ directory");
println!(
" - Execute with: WORKER::run(\"{}\", payload).await",
kebab_name
);
println!(
" - For progress updates: WORKER::call(\"{}\", None, payload).await",
kebab_name
);
println!(" - See the RustF book worker guide for examples:");
println!(" https://numerum-tech.github.io/rustf/advanced/workers.html");
Ok(())
}
pub async fn generate_crud(name: String) -> Result<()> {
let project_path = std::env::current_dir()?;
let plural = to_snake_case(&name);
if plural.is_empty() {
return Err(anyhow!("CRUD name cannot be empty"));
}
let singular = naive_singular(&plural);
let pascal_plural = to_pascal_case(&plural);
let pascal_singular = to_pascal_case(&singular);
let title_plural = to_title_case(&plural);
let title_singular = to_title_case(&singular);
let controllers_dir = project_path.join("src").join("controllers");
let modules_dir = project_path.join("src").join("modules");
let models_dir = project_path.join("src").join("models");
let views_dir = project_path.join("views").join(&plural);
let tests_dir = project_path.join("tests");
let model_path = models_dir.join(format!("{}.rs", plural));
if !model_path.exists() {
return Err(anyhow!(
"Model not found at {}\n\n\
`rustf-cli new crud` wires controllers/views/services around an EXISTING \
database model. Generate one first:\n\
\n 1. Define schemas/{}.yaml\n\
\n 2. Run: rustf-cli schema generate models\n\
\n 3. Re-run: rustf-cli new crud --name {}\n",
model_path.display(),
plural,
plural,
));
}
for dir in [&controllers_dir, &modules_dir, &views_dir, &tests_dir] {
fs::create_dir_all(dir)?;
}
let targets = [
controllers_dir.join(format!("{}.rs", plural)),
modules_dir.join(format!("{}_service.rs", plural)),
views_dir.join("index.html"),
views_dir.join("show.html"),
views_dir.join("new.html"),
views_dir.join("edit.html"),
tests_dir.join(format!("{}_test.rs", plural)),
];
for t in &targets {
if t.exists() {
return Err(anyhow!(
"'{}' already exists — refusing to overwrite",
t.display()
));
}
}
let mut vars = HashMap::new();
vars.insert("name", plural.clone());
vars.insert("name_singular", singular.clone());
vars.insert("pascal_name", pascal_plural.clone());
vars.insert("pascal_name_singular", pascal_singular.clone());
vars.insert("title", title_plural.clone());
vars.insert("title_singular", title_singular.clone());
let mut handlebars = Handlebars::new();
handlebars.set_strict_mode(false);
let rendering_plan: Vec<(&str, &str, PathBuf)> = vec![
(
"crud_controller",
include_str!("../../templates/components/crud_controller.rs.template"),
targets[0].clone(),
),
(
"crud_module",
include_str!("../../templates/components/crud_module.rs.template"),
targets[1].clone(),
),
(
"crud_index",
include_str!("../../templates/views/crud/index.html.template"),
targets[2].clone(),
),
(
"crud_show",
include_str!("../../templates/views/crud/show.html.template"),
targets[3].clone(),
),
(
"crud_new",
include_str!("../../templates/views/crud/new.html.template"),
targets[4].clone(),
),
(
"crud_edit",
include_str!("../../templates/views/crud/edit.html.template"),
targets[5].clone(),
),
(
"crud_test",
include_str!("../../templates/components/crud_test.rs.template"),
targets[6].clone(),
),
];
for (key, content, out_path) in rendering_plan {
handlebars.register_template_string(key, content)?;
let rendered = handlebars.render(key, &vars)?;
let mut file = File::create(&out_path)?;
file.write_all(rendered.as_bytes())?;
println!("✅ {}", out_path.display());
}
println!();
println!("📝 Scaffold layering (enforced in generated code):");
println!(" HTTP: src/controllers/{}.rs (calls {}Service only)", plural, pascal_plural);
println!(" Business: src/modules/{}_service.rs (only caller of {})", plural, pascal_singular);
println!(" Data: src/models/{}.rs (PRE-EXISTING — not touched)", plural);
println!(" Views: views/{}/{{index,show,new,edit}}.html", plural);
println!(" Tests: tests/{}_test.rs (stubs — uncomment + adjust crate import)", plural);
println!();
println!("📝 Next steps:");
println!(" 1. Open src/modules/{}_service.rs and fill in the `create` and `update`", plural);
println!(" field mappings marked with TODO — they need your schema's real field");
println!(" names (the generated model's builder + setters are typed per-field).");
println!(" 2. Update views/{}/{{new,edit,show}}.html to match the same schema fields.", plural);
println!(" 3. cargo run, then visit http://127.0.0.1:8000/{}", plural);
Ok(())
}
fn naive_singular(plural: &str) -> String {
if plural.ends_with('s') && plural.len() > 1 {
plural[..plural.len() - 1].to_string()
} else {
plural.to_string()
}
}
fn to_snake_case(s: &str) -> String {
let mut result = String::new();
let mut prev_is_upper = false;
for (i, ch) in s.chars().enumerate() {
if ch.is_uppercase() {
if i > 0 && !prev_is_upper {
result.push('_');
}
result.push(ch.to_lowercase().next().unwrap());
prev_is_upper = true;
} else if ch == '-' || ch == ' ' {
result.push('_');
prev_is_upper = false;
} else {
result.push(ch);
prev_is_upper = false;
}
}
result
}
fn to_pascal_case(s: &str) -> String {
s.split(|c: char| c == '_' || c == '-' || c == ' ')
.filter(|s| !s.is_empty())
.map(|word| {
let mut chars = word.chars();
match chars.next() {
None => String::new(),
Some(first) => first
.to_uppercase()
.chain(chars.as_str().to_lowercase().chars())
.collect(),
}
})
.collect()
}
fn to_title_case(s: &str) -> String {
s.split(|c: char| c == '_' || c == '-')
.filter(|s| !s.is_empty())
.map(|word| {
let mut chars = word.chars();
match chars.next() {
None => String::new(),
Some(first) => first
.to_uppercase()
.chain(chars.as_str().to_lowercase().chars())
.collect(),
}
})
.collect::<Vec<_>>()
.join(" ")
}