Pass component registrar to MethodRouter

Add a component_registrar parameter to MethodRouter::insert_boxed_with_operation and store it for each handler. Update RustApi route registration to destructure Route and pass the component_registrar when inserting handlers. Add request/response test types, handler, and a test (test_auto_registers_openapi_components_for_body_refs) to verify OpenAPI components for request bodies/responses are auto-registered and no dangling $ref values remain. Also import serde::Serialize for the new response type.

Author: Tuntii

Cargo.toml

@@ -17,7 +17,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.1.412"
+version = "0.1.416"
 edition = "2021"
 authors = ["RustAPI Contributors, Tuntii"]
 license = "MIT OR Apache-2.0"
@@ -141,3 +141,4 @@ strip = false
 
 
 
+

crates/rustapi-core/src/app.rs

@@ -491,7 +491,16 @@ impl RustApi {
         let mut by_path: BTreeMap<String, MethodRouter> = BTreeMap::new();
 
         for route in routes {
-            let method_enum = match route.method {
+            let crate::handler::Route {
+                path: route_path,
+                method,
+                handler,
+                operation,
+                component_registrar,
+                ..
+            } = route;
+
+            let method_enum = match method {
                 "GET" => http::Method::GET,
                 "POST" => http::Method::POST,
                 "PUT" => http::Method::PUT,
@@ -500,14 +509,19 @@ impl RustApi {
                 _ => http::Method::GET,
             };
 
-            let path = if route.path.starts_with('/') {
-                route.path.to_string()
+            let path = if route_path.starts_with('/') {
+                route_path.to_string()
             } else {
-                format!("/{}", route.path)
+                format!("/{}", route_path)
             };
 
             let entry = by_path.entry(path).or_default();
-            entry.insert_boxed_with_operation(method_enum, route.handler, route.operation);
+            entry.insert_boxed_with_operation(
+                method_enum,
+                handler,
+                operation,
+                component_registrar,
+            );
         }
 
         #[cfg(feature = "tracing")]

crates/rustapi-core/src/router.rs

@@ -190,6 +190,7 @@ impl MethodRouter {
         method: Method,
         handler: BoxedHandler,
         operation: Operation,
+        component_registrar: fn(&mut rustapi_openapi::OpenApiSpec),
     ) {
         if self.handlers.contains_key(&method) {
             panic!(
@@ -200,6 +201,7 @@ impl MethodRouter {
 
         self.handlers.insert(method.clone(), handler);
         self.operations.insert(method, operation);
+        self.component_registrars.push(component_registrar);
     }
 
     /// Add a GET handler

crates/rustapi-rs/tests/auto_route.rs

@@ -1,7 +1,7 @@
 use rustapi_rs::collect_auto_routes;
 use rustapi_rs::prelude::*;
 use rustapi_rs::{get, post};
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 
 // Standard handler
 #[get("/test-auto-rs")]
@@ -65,6 +65,25 @@ struct Pagination {
     page_size: Option<u32>,
 }
 
+#[derive(Debug, Clone, Deserialize, Schema)]
+struct AutoCreatePin {
+    title: String,
+}
+
+#[derive(Debug, Clone, Serialize, Schema)]
+struct AutoCreatePinResponse {
+    id: i64,
+    title: String,
+}
+
+#[post("/auto-create-pin")]
+async fn auto_create_pin(Json(body): Json<AutoCreatePin>) -> Created<AutoCreatePinResponse> {
+    Created(AutoCreatePinResponse {
+        id: 1,
+        title: body.title,
+    })
+}
+
 #[get("/query")]
 async fn query_handler(Query(p): Query<Pagination>) -> &'static str {
     let _ = (&p.page, &p.page_size);
@@ -153,3 +172,44 @@ fn test_openapi_includes_query_params() {
         "OpenAPI should include query parameter 'page_size'"
     );
 }
+
+#[test]
+fn test_auto_registers_openapi_components_for_body_refs() {
+    use rustapi_openapi::schema::RustApiSchema;
+
+    let app = RustApi::auto();
+    let spec = app.openapi_spec();
+
+    assert!(
+        spec.validate_integrity().is_ok(),
+        "auto route OpenAPI spec should not contain dangling $ref values"
+    );
+
+    let components = spec.components.as_ref().expect("components should exist");
+    let create_pin_name = <AutoCreatePin as RustApiSchema>::component_name().unwrap();
+    let response_name = <AutoCreatePinResponse as RustApiSchema>::component_name().unwrap();
+
+    assert!(components.schemas.contains_key(create_pin_name));
+    assert!(components.schemas.contains_key(response_name));
+
+    let path_item = spec
+        .paths
+        .get("/auto-create-pin")
+        .expect("/auto-create-pin path should exist");
+    let op = path_item
+        .post
+        .as_ref()
+        .expect("POST /auto-create-pin should exist");
+    let media_type = op
+        .request_body
+        .as_ref()
+        .and_then(|body| body.content.get("application/json"))
+        .expect("request body media type should exist");
+
+    match media_type.schema.as_ref().expect("schema should exist") {
+        rustapi_openapi::SchemaRef::Ref { reference } => {
+            assert_eq!(reference, "#/components/schemas/AutoCreatePin");
+        }
+        other => panic!("expected request body schema ref, got {other:?}"),
+    }
+}