Fix CRUD generator multi-table db.rs and server e2e registration

Tuntii · Tuntii · commit 58992b680c40 · 2026-07-05T09:07:11.000+03:00
diff --git a/crates/cargo-rustapi/src/commands/generate.rs b/crates/cargo-rustapi/src/commands/generate.rs
@@ -188,8 +188,9 @@ async fn generate_crud(name: &str) -> Result<()> {
     );
     println!();
 
+    let singular = singularize(name);
     ensure_crud_dependencies().await?;
-    ensure_db_module(&table).await?;
+    upsert_db_resource(&table, &singular).await?;
     generate_sqlx_model(name, &type_name).await?;
     generate_sqlx_handler(name, &type_name, &table).await?;
 
@@ -204,7 +205,8 @@ async fn generate_crud(name: &str) -> Result<()> {
         "     let pool = db::init_pool(\"sqlite:{}.db\").await?;",
         table
     );
-    println!("     RustApi::auto().state(pool).run(\"127.0.0.1:8080\").await?;");
+    println!("  3. Mount generated handlers (or use RustApi::auto()):");
+    print_route_registration_hints(name);
 
     Ok(())
 }
@@ -256,56 +258,106 @@ async fn ensure_crud_dependencies() -> Result<()> {
     Ok(())
 }
 
-async fn ensure_db_module(table: &str) -> Result<()> {
-    let db_path = Path::new("src/db.rs");
-    if db_path.exists() {
-        return Ok(());
-    }
-
-    let singular = singularize(table);
-    let content = format!(
-        r#"//! Database bootstrap for generated CRUD resources.
+const DB_RS_HEADER: &str = r#"//! Database bootstrap for generated CRUD resources.
+//!
+//! Each `cargo rustapi generate crud <name>` call adds a table-specific module below.
+//! Default columns are the standard scaffold (`id`, `name`, `description`, timestamps).
 
 use sqlx::sqlite::SqlitePoolOptions;
 use sqlx::SqlitePool;
 
-/// Table name used by generated CRUD handlers.
-pub const TABLE: &str = "{table}";
-
-/// Singular resource label for error messages.
-pub const SINGULAR: &str = "{singular}";
-
-const COLUMNS_DDL: &str = "
+/// Default CRUD column layout for generated resources (customize per model as needed).
+macro_rules! crud_columns {
+    () => {
+        "
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT NOT NULL,
     description TEXT,
     created_at TEXT NOT NULL,
     updated_at TEXT NOT NULL
-";
+"
+    };
+}
+
+"#;
+
+async fn upsert_db_resource(table: &str, singular: &str) -> Result<()> {
+    let db_path = Path::new("src/db.rs");
+    let table_mod = table_module_name(table);
+    let module_block = format!(
+        r#"pub mod {table_mod} {{
+    pub const TABLE: &str = "{table}";
+    pub const SINGULAR: &str = "{singular}";
+    pub(crate) const COLUMNS_DDL: &str = crud_columns!();
+}}
 
-/// Open a SQLite pool and ensure the resource table exists.
+"#,
+        table_mod = table_mod,
+        table = table,
+        singular = singular,
+    );
+    let ensure_line = format!(
+        "    ensure_table(&pool, {table_mod}::TABLE, {table_mod}::COLUMNS_DDL).await?;\n",
+        table_mod = table_mod,
+    );
+
+    if !db_path.exists() {
+        let content = format!(
+            "{header}{module_block}\
+async fn ensure_table(pool: &SqlitePool, table: &str, columns: &str) -> Result<(), sqlx::Error> {{
+    let schema = format!(\"CREATE TABLE IF NOT EXISTS {{}} ({{}})\", table, columns.trim());
+    sqlx::query(&schema).execute(pool).await?;
+    Ok(())
+}}
+
+/// Open a SQLite pool and ensure all generated resource tables exist.
 pub async fn init_pool(database_url: &str) -> Result<SqlitePool, sqlx::Error> {{
     let pool = SqlitePoolOptions::new()
         .max_connections(5)
         .connect(database_url)
         .await?;
-    let schema = format!(
-        "CREATE TABLE IF NOT EXISTS {{}} ({{}})",
-        TABLE,
-        COLUMNS_DDL.trim()
-    );
-    sqlx::query(&schema).execute(&pool).await?;
-    Ok(pool)
+{ensure_lines}    Ok(pool)
 }}
-"#,
-        table = table,
-        singular = singular,
-    );
+",
+            header = DB_RS_HEADER,
+            module_block = module_block,
+            ensure_lines = ensure_line,
+        );
+        fs::write(db_path, content).await?;
+        println!(
+            "{} Generated database module: {}",
+            style("✓").green(),
+            db_path.display()
+        );
+        return Ok(());
+    }
+
+    let mut content = fs::read_to_string(db_path).await?;
+    let mod_marker = format!("pub mod {table_mod} ");
+    if content.contains(&mod_marker) {
+        println!(
+            "{} db.rs already tracks table '{}'",
+            style("•").yellow(),
+            table
+        );
+        return Ok(());
+    }
+
+    let insert_at = content
+        .find("async fn ensure_table")
+        .ok_or_else(|| anyhow::anyhow!("src/db.rs is missing ensure_table helper"))?;
+    content.insert_str(insert_at, &module_block);
+
+    let ok_pool = content
+        .rfind("    Ok(pool)")
+        .ok_or_else(|| anyhow::anyhow!("src/db.rs is missing init_pool tail"))?;
+    content.insert_str(ok_pool, &ensure_line);
 
     fs::write(db_path, content).await?;
     println!(
-        "{} Generated database module: {}",
+        "{} Updated database module for table '{}': {}",
         style("✓").green(),
+        table,
         db_path.display()
     );
     Ok(())
@@ -358,15 +410,16 @@ pub struct Update{type_name} {{
     Ok(())
 }
 
-async fn generate_sqlx_handler(name: &str, type_name: &str, _table: &str) -> Result<()> {
+async fn generate_sqlx_handler(name: &str, type_name: &str, table: &str) -> Result<()> {
     let handlers_dir = Path::new("src/handlers");
     ensure_handlers_module(handlers_dir, name).await?;
 
     let singular = singularize(name);
+    let table_mod = table_module_name(table);
     let handler_content = format!(
         r#"//! {} handlers (SQLx SQLite)
 
-use crate::db::{{SINGULAR, TABLE}};
+use crate::db::{table_mod}::{{SINGULAR, TABLE}};
 use crate::models::{{Create{type_name}, Update{type_name}, {type_name}}};
 use rustapi_rs::prelude::*;
 use sqlx::SqlitePool;
@@ -580,26 +633,20 @@ async fn ensure_models_module(models_dir: &Path, name: &str) -> Result<()> {
 
 fn print_route_registration_hints(name: &str) {
     println!();
-    println!("Don't forget to register the routes in main.rs:");
-    println!(
-        "  {}",
-        style(format!(".mount(handlers::{}::list)", name)).cyan()
-    );
-    println!(
-        "  {}",
-        style(format!(".mount(handlers::{}::get)", name)).cyan()
-    );
-    println!(
-        "  {}",
-        style(format!(".mount(handlers::{}::create)", name)).cyan()
-    );
+    println!("Register the generated handlers in main.rs:");
     println!(
         "  {}",
-        style(format!(".mount(handlers::{}::update)", name)).cyan()
+        style(format!(
+            ".route(\"/{name}\", get(handlers::{name}::list).post(handlers::{name}::create))"
+        ))
+        .cyan()
     );
     println!(
         "  {}",
-        style(format!(".mount(handlers::{}::delete)", name)).cyan()
+        style(format!(
+            ".route(\"/{name}/{{id}}\", get(handlers::{name}::get).put(handlers::{name}::update).delete(handlers::{name}::delete))"
+        ))
+        .cyan()
     );
 }
 
@@ -616,6 +663,10 @@ fn to_pascal_case(s: &str) -> String {
     s.split(&['-', '_'][..]).map(capitalize).collect()
 }
 
+fn table_module_name(table: &str) -> String {
+    table.replace('-', "_")
+}
+
 fn singularize(s: &str) -> String {
     if let Some(stripped) = s.strip_suffix("ies") {
         format!("{}y", stripped)
diff --git a/crates/cargo-rustapi/tests/cli_tests.rs b/crates/cargo-rustapi/tests/cli_tests.rs
@@ -349,8 +349,13 @@ mod generate_command {
         );
         assert!(handler.contains("sqlx::query_as"));
         assert!(
-            handler.contains("crate::db::{SINGULAR, TABLE}"),
-            "generated handler must use db::TABLE and db::SINGULAR"
+            handler.contains("crate::db::items::{SINGULAR, TABLE}"),
+            "generated handler must use per-table db module constants"
+        );
+        let db_rs = fs::read_to_string(project_path.join("src/db.rs")).expect("read db.rs");
+        assert!(
+            db_rs.contains("pub mod items"),
+            "db.rs must define a per-resource items module"
         );
 
         let rustapi_path = workspace_root
@@ -382,6 +387,7 @@ path = "src/lib.rs"
 
 [dev-dependencies]
 rustapi-testing = {{ path = "{testing_path}" }}
+reqwest = {{ version = "0.12", default-features = false, features = ["json", "rustls-tls"] }}
 "#
             ));
         }
@@ -410,45 +416,120 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
 
         fs::create_dir_all(project_path.join("tests")).expect("create tests dir");
         let e2e_test = r#"use rustapi_rs::prelude::*;
-use rustapi_testing::{TestClient, TestRequest};
 use test_crud_sqlx::db;
+use test_crud_sqlx::handlers::items::{create, delete, get as get_one, list, update};
+use std::time::Duration;
+use tokio::sync::oneshot;
 
 #[tokio::test]
-async fn generated_items_routes_create_and_list() {
+async fn generated_items_routes_create_and_list_via_server() {
     let pool = db::init_pool("sqlite::memory:").await.expect("pool");
-    let app = RustApi::auto().state(pool);
-    let client = TestClient::new(app);
-
-    let create = client
-        .request(
-            TestRequest::post("/items")
-                .header("content-type", "application/json")
-                .body("{\"name\":\"widget\",\"description\":\"demo\"}"),
-        )
-        .await;
-    create.assert_status(StatusCode::CREATED);
-
-    let list = client.request(TestRequest::get("/items")).await;
-    list.assert_status(StatusCode::OK);
-    let body = list.text();
+    let app = RustApi::new()
+        .state(pool)
+        .route("/items", get(list).post(create))
+        .route("/items/{id}", get(get_one).put(update).delete(delete));
+
+    let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind ephemeral port");
+    let port = listener.local_addr().expect("local addr").port();
+    drop(listener);
+
+    let addr = format!("127.0.0.1:{port}");
+    let (shutdown_tx, shutdown_rx) = oneshot::channel();
+    let server = tokio::spawn(async move {
+        app.run_with_shutdown(&addr, async {
+            shutdown_rx.await.ok();
+        })
+        .await
+    });
+
+    tokio::time::sleep(Duration::from_millis(400)).await;
+
+    let client = reqwest::Client::new();
+    let base = format!("http://127.0.0.1:{port}");
+
+    let create_res = client
+        .post(format!("{base}/items"))
+        .header("content-type", "application/json")
+        .body("{\"name\":\"widget\",\"description\":\"demo\"}")
+        .send()
+        .await
+        .expect("create request");
+    assert_eq!(create_res.status(), 201, "POST /items should return 201");
+
+    let list_res = client
+        .get(format!("{base}/items"))
+        .send()
+        .await
+        .expect("list request");
+    assert_eq!(list_res.status(), 200, "GET /items should return 200");
+    let body = list_res.text().await.expect("list body");
     assert!(body.contains("widget"), "list response must include created item");
+
+    shutdown_tx.send(()).ok();
+    server.await.expect("server task").expect("server run");
 }
 "#;
         fs::write(project_path.join("tests/crud_e2e.rs"), e2e_test).expect("write e2e test");
 
         let output = std::process::Command::new("cargo")
             .current_dir(&project_path)
-            .args(["test", "--test", "crud_e2e"])
+            .args(["test", "--test", "crud_e2e", "--", "--nocapture"])
             .output()
             .expect("cargo test status");
         assert!(
             output.status.success(),
-            "generated CRUD project must pass e2e route test:\n{}\n{}",
+            "generated CRUD project must pass server e2e route test:\n{}\n{}",
             String::from_utf8_lossy(&output.stdout),
             String::from_utf8_lossy(&output.stderr)
         );
     }
 
+    #[test]
+    fn test_generate_crud_multiple_resources_share_db_module() {
+        let dir = tempdir().expect("Failed to create temp dir");
+        let project_name = "test-crud-multi";
+        let project_path = dir.path().join(project_name);
+
+        cargo_rustapi()
+            .current_dir(dir.path())
+            .args(["new", project_name, "--template", "minimal", "--yes"])
+            .assert()
+            .success();
+
+        cargo_rustapi()
+            .current_dir(&project_path)
+            .args(["generate", "crud", "items"])
+            .assert()
+            .success();
+
+        cargo_rustapi()
+            .current_dir(&project_path)
+            .args(["generate", "crud", "products"])
+            .assert()
+            .success();
+
+        let db_rs = fs::read_to_string(project_path.join("src/db.rs")).expect("read db.rs");
+        assert!(
+            db_rs.contains("pub mod items"),
+            "db.rs must track items table"
+        );
+        assert!(
+            db_rs.contains("pub mod products"),
+            "db.rs must track products table"
+        );
+        assert!(
+            db_rs.matches("ensure_table(&pool").count() >= 2,
+            "init_pool must ensure every generated table"
+        );
+
+        let products_handler = fs::read_to_string(project_path.join("src/handlers/products.rs"))
+            .expect("read handler");
+        assert!(
+            products_handler.contains("crate::db::products::{SINGULAR, TABLE}"),
+            "second resource must use its own db module"
+        );
+    }
+
     #[test]
     fn test_generate_model() {
         let dir = tempdir().expect("Failed to create temp dir");
