feat: auto-wire mod declarations in main.rs after import/add resource (rapina-rs#365)

Co-authored-by: Antonio Souza <arfs.antonio@gmail.com>

Author: uemuradevexe

rapina-cli/src/commands/add.rs

@@ -1,3 +1,5 @@
+use std::path::Path;
+
 use colored::Colorize;
 
 use super::codegen::{self, FieldInfo};
@@ -92,59 +94,11 @@ fn validate_resource_name(name: &str) -> Result<(), String> {
     Ok(())
 }
 
-fn print_next_steps(singular: &str, plural: &str, pascal: &str) {
+fn print_next_steps(pascal: &str) {
     println!();
     println!("  {}:", "Next steps".bright_yellow());
     println!();
-    println!(
-        "  1. Add the module declaration to {}:",
-        "src/main.rs".cyan()
-    );
-    println!();
-    println!("     mod {};", plural);
-    println!("     mod entity;");
-    println!("     mod migrations;");
-    println!();
-    println!("  2. Register the routes in your {}:", "Router".cyan());
-    println!();
-    println!(
-        "     use {plural}::handlers::{{list_{plural}, get_{singular}, create_{singular}, update_{singular}, delete_{singular}}};",
-        plural = plural,
-        singular = singular,
-    );
-    println!();
-    println!("     let router = Router::new()");
-    println!(
-        "         .get(\"/{plural}\", list_{plural})",
-        plural = plural
-    );
-    println!(
-        "         .get(\"/{plural}/:id\", get_{singular})",
-        plural = plural,
-        singular = singular,
-    );
-    println!(
-        "         .post(\"/{plural}\", create_{singular})",
-        plural = plural,
-        singular = singular,
-    );
-    println!(
-        "         .put(\"/{plural}/:id\", update_{singular})",
-        plural = plural,
-        singular = singular,
-    );
-    println!(
-        "         .delete(\"/{plural}/:id\", delete_{singular});",
-        plural = plural,
-        singular = singular,
-    );
-    println!();
-    println!(
-        "  3. Enable the database feature in {}:",
-        "Cargo.toml".cyan()
-    );
-    println!();
-    println!("     rapina = {{ version = \"...\", features = [\"postgres\"] }}");
+    println!("  1. Run {} to verify", "cargo build".cyan());
     println!();
     println!(
         "  Resource {} created successfully!",
@@ -184,7 +138,10 @@ pub fn resource(name: &str, field_args: &[String]) -> Result<(), String> {
     codegen::update_entity_file(pascal, &fields, None, None, false)?;
     codegen::create_migration_file(plural, pascal_plural, &fields, pk_type)?;
 
-    print_next_steps(singular, plural, pascal);
+    if let Err(e) = codegen::wire_main_rs(&[plural.as_str()], Path::new(".")) {
+        eprintln!("  {} Could not auto-wire main.rs: {}", "!".yellow(), e);
+    }
+    print_next_steps(pascal);
 
     Ok(())
 }

rapina-cli/src/commands/codegen.rs

@@ -762,6 +762,190 @@ fn create_feature_module_in(
     Ok(())
 }
 
+/// Inserts `mod <name>;` declarations into `src/main.rs` for any modules not
+/// already declared. Silently returns Ok if main.rs does not exist.
+pub(crate) fn wire_main_rs(modules: &[&str], project_root: &Path) -> Result<(), String> {
+    let main_path = project_root.join("src").join("main.rs");
+    if !main_path.exists() {
+        return Ok(());
+    }
+
+    let content =
+        fs::read_to_string(&main_path).map_err(|e| format!("Failed to read main.rs: {e}"))?;
+
+    // Filter out modules already declared.
+    let new_modules: Vec<&str> = modules
+        .iter()
+        .copied()
+        .filter(|m| {
+            !content.lines().any(|l| {
+                l.trim_start().starts_with("mod ")
+                    && l.trim_end().ends_with(';')
+                    && l.contains(&format!("mod {m};"))
+            })
+        })
+        .collect();
+
+    if new_modules.is_empty() {
+        return Ok(());
+    }
+
+    let lines: Vec<&str> = content.lines().collect();
+
+    // Find the index of the last `mod ...;` line.
+    let last_mod_idx = lines
+        .iter()
+        .rposition(|l| l.trim_start().starts_with("mod ") && l.trim_end().ends_with(';'));
+
+    let insertion_line = match last_mod_idx {
+        Some(idx) => idx + 1,
+        None => {
+            // No existing mod declarations — insert before `fn main` or `#[tokio::main]`.
+            lines
+                .iter()
+                .position(|l| l.contains("fn main") || l.contains("#[tokio::main]"))
+                .unwrap_or(lines.len())
+        }
+    };
+
+    let mut result = lines[..insertion_line].join("\n");
+    if !result.ends_with('\n') {
+        result.push('\n');
+    }
+    for m in &new_modules {
+        result.push_str(&format!("mod {m};\n"));
+    }
+    if insertion_line < lines.len() {
+        result.push_str(&lines[insertion_line..].join("\n"));
+        if content.ends_with('\n') {
+            result.push('\n');
+        }
+    }
+
+    fs::write(&main_path, &result).map_err(|e| format!("Failed to write main.rs: {e}"))?;
+
+    for m in &new_modules {
+        println!(
+            "  {} Wired {} in {}",
+            "✓".green(),
+            format!("mod {m};").cyan(),
+            "src/main.rs".cyan()
+        );
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod wire_tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    fn write_main(dir: &TempDir, content: &str) -> std::path::PathBuf {
+        let src = dir.path().join("src");
+        std::fs::create_dir_all(&src).unwrap();
+        let path = src.join("main.rs");
+        std::fs::write(&path, content).unwrap();
+        dir.path().to_path_buf()
+    }
+
+    #[test]
+    fn inserts_after_last_mod() {
+        let dir = TempDir::new().unwrap();
+        let root = write_main(
+            &dir,
+            "\
+use rapina::prelude::*;
+
+mod entity;
+mod migrations;
+
+#[tokio::main]
+async fn main() {}
+",
+        );
+        wire_main_rs(&["todos"], &root).unwrap();
+        let content = std::fs::read_to_string(root.join("src/main.rs")).unwrap();
+        assert!(content.contains("mod todos;"));
+        let mod_pos = content.find("mod todos;").unwrap();
+        let main_pos = content.find("#[tokio::main]").unwrap();
+        assert!(mod_pos < main_pos);
+    }
+
+    #[test]
+    fn skips_duplicate() {
+        let dir = TempDir::new().unwrap();
+        let root = write_main(
+            &dir,
+            "\
+mod entity;
+mod todos;
+
+fn main() {}
+",
+        );
+        wire_main_rs(&["todos"], &root).unwrap();
+        let content = std::fs::read_to_string(root.join("src/main.rs")).unwrap();
+        assert_eq!(content.matches("mod todos;").count(), 1);
+    }
+
+    #[test]
+    fn inserts_multiple_modules() {
+        let dir = TempDir::new().unwrap();
+        let root = write_main(
+            &dir,
+            "\
+mod entity;
+mod migrations;
+
+fn main() {}
+",
+        );
+        wire_main_rs(&["users", "posts"], &root).unwrap();
+        let content = std::fs::read_to_string(root.join("src/main.rs")).unwrap();
+        assert!(content.contains("mod users;"));
+        assert!(content.contains("mod posts;"));
+    }
+
+    #[test]
+    fn no_main_rs_is_silent() {
+        let dir = TempDir::new().unwrap();
+        let result = wire_main_rs(&["todos"], dir.path());
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn no_existing_mods_inserts_before_fn_main() {
+        let dir = TempDir::new().unwrap();
+        let root = write_main(
+            &dir,
+            "\
+use rapina::prelude::*;
+
+fn main() {}
+",
+        );
+        wire_main_rs(&["todos"], &root).unwrap();
+        let content = std::fs::read_to_string(root.join("src/main.rs")).unwrap();
+        assert!(content.contains("mod todos;"));
+        let mod_pos = content.find("mod todos;").unwrap();
+        let main_pos = content.find("fn main()").unwrap();
+        assert!(mod_pos < main_pos);
+    }
+
+    #[test]
+    fn no_double_blank_line() {
+        let dir = TempDir::new().unwrap();
+        let root = write_main(&dir, "mod entity;\nmod migrations;\n\nfn main() {}\n");
+        wire_main_rs(&["todos"], &root).unwrap();
+        let content = std::fs::read_to_string(root.join("src/main.rs")).unwrap();
+        assert!(
+            !content.contains("\n\n\n"),
+            "triple newline found (double blank line)"
+        );
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

rapina-cli/src/commands/import.rs

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::path::Path;
 
 use colored::Colorize;
 
@@ -675,6 +676,12 @@ pub fn database(
         imported.push((table.name.clone(), pascal));
     }
 
+    // Auto-wire mod declarations into src/main.rs
+    let plural_names: Vec<&str> = imported.iter().map(|(name, _)| name.as_str()).collect();
+    if let Err(e) = codegen::wire_main_rs(&plural_names, Path::new(".")) {
+        eprintln!("  {} Could not auto-wire main.rs: {}", "!".yellow(), e);
+    }
+
     // Summary
     println!();
     println!(
@@ -691,9 +698,7 @@ pub fn database(
     println!("  {}:", "Next steps".bright_yellow());
     println!();
     println!("  1. Review generated files in {}", "src/".cyan());
-    println!("  2. Add module declarations to {}", "src/main.rs".cyan());
-    println!("  3. Register routes in your Router");
-    println!("  4. Run {} to verify", "cargo build".cyan());
+    println!("  2. Run {} to verify", "cargo build".cyan());
     println!();
 
     Ok(())