Add schema auto-registration and improve state handling

Introduces the #[rustapi_rs::schema] macro for automatic OpenAPI schema registration of structs and enums, and applies it to UserInfo. Enhances RustApi::state to store state in the router for extractor compatibility, and adds a test to verify state extraction. Also updates OpenApiSpec to register additional error body schemas.

Author: Tuntii

crates/rustapi-core/src/app.rs

@@ -47,7 +47,9 @@ impl RustApi {
             router: Router::new(),
             openapi_spec: rustapi_openapi::OpenApiSpec::new("RustAPI Application", "1.0.0")
                 .register::<rustapi_openapi::ErrorSchema>()
+                .register::<rustapi_openapi::ErrorBodySchema>()
                 .register::<rustapi_openapi::ValidationErrorSchema>()
+                .register::<rustapi_openapi::ValidationErrorBodySchema>()
                 .register::<rustapi_openapi::FieldErrorSchema>(),
             layers: LayerStack::new(),
             body_limit: Some(DEFAULT_BODY_LIMIT), // Default 1MB limit
@@ -201,11 +203,11 @@ impl RustApi {
     where
         S: Clone + Send + Sync + 'static,
     {
-        // For now, state is handled by the router/handlers directly capturing it
-        // or through a middleware. The current router (matchit) implementation
-        // doesn't support state injection directly in the same way axum does.
-        // This is a placeholder for future state management.
-        self
+        // Store state in the router's shared Extensions so `State<T>` extractor can retrieve it.
+        let state = _state;
+        let mut app = self;
+        app.router = app.router.state(state);
+        app
     }
 
     /// Register an OpenAPI schema
@@ -693,6 +695,33 @@ impl Default for RustApi {
     }
 }
 
+#[cfg(test)]
+mod tests {
+    use super::RustApi;
+    use crate::extract::{FromRequestParts, State};
+    use crate::request::Request;
+    use bytes::Bytes;
+    use http::Method;
+    use std::collections::HashMap;
+
+    #[test]
+    fn state_is_available_via_extractor() {
+        let app = RustApi::new().state(123u32);
+        let router = app.into_router();
+
+        let req = http::Request::builder()
+            .method(Method::GET)
+            .uri("/test")
+            .body(())
+            .unwrap();
+        let (parts, _) = req.into_parts();
+
+        let request = Request::new(parts, Bytes::new(), router.state_ref(), HashMap::new());
+        let State(value) = State::<u32>::from_request_parts(&request).unwrap();
+        assert_eq!(value, 123u32);
+    }
+}
+
 /// Check Basic Auth header against expected credentials
 #[cfg(feature = "swagger-ui")]
 fn check_basic_auth(req: &crate::Request, expected: &str) -> bool {

crates/rustapi-macros/src/lib.rs

@@ -21,6 +21,66 @@ use syn::{
     parse_macro_input, FnArg, GenericArgument, ItemFn, LitStr, PathArguments, ReturnType, Type,
 };
 
+/// Auto-register a schema type for zero-config OpenAPI.
+///
+/// Attach this to a `struct` or `enum` that also derives `Schema` (utoipa::ToSchema).
+/// This ensures the type is registered into RustAPI's OpenAPI components even if it is
+/// only referenced indirectly (e.g. as a nested field type).
+///
+/// ```rust,ignore
+/// use rustapi_rs::prelude::*;
+///
+/// #[rustapi_rs::schema]
+/// #[derive(Serialize, Schema)]
+/// struct UserInfo { /* ... */ }
+/// ```
+#[proc_macro_attribute]
+pub fn schema(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(item as syn::Item);
+
+    let (ident, generics) = match &input {
+        syn::Item::Struct(s) => (&s.ident, &s.generics),
+        syn::Item::Enum(e) => (&e.ident, &e.generics),
+        _ => {
+            return syn::Error::new_spanned(
+                &input,
+                "#[rustapi_rs::schema] can only be used on structs or enums",
+            )
+            .to_compile_error()
+            .into();
+        }
+    };
+
+    if !generics.params.is_empty() {
+        return syn::Error::new_spanned(
+            generics,
+            "#[rustapi_rs::schema] does not support generic types",
+        )
+        .to_compile_error()
+        .into();
+    }
+
+    let registrar_ident = syn::Ident::new(
+        &format!("__RUSTAPI_AUTO_SCHEMA_{}", ident),
+        proc_macro2::Span::call_site(),
+    );
+
+    let expanded = quote! {
+        #input
+
+        #[allow(non_upper_case_globals)]
+        #[::rustapi_rs::__private::linkme::distributed_slice(::rustapi_rs::__private::AUTO_SCHEMAS)]
+        #[linkme(crate = ::rustapi_rs::__private::linkme)]
+        static #registrar_ident: fn(&mut ::rustapi_rs::__private::rustapi_openapi::OpenApiSpec) =
+            |spec: &mut ::rustapi_rs::__private::rustapi_openapi::OpenApiSpec| {
+                spec.register_in_place::<#ident>();
+            };
+    };
+
+    debug_output("schema", &expanded);
+    expanded.into()
+}
+
 fn extract_schema_types(ty: &Type, out: &mut Vec<Type>, allow_leaf: bool) {
     match ty {
         Type::Reference(r) => extract_schema_types(&r.elem, out, allow_leaf),

crates/rustapi-openapi/src/lib.rs

@@ -36,7 +36,10 @@ mod spec;
 mod swagger;
 
 pub use config::OpenApiConfig;
-pub use schemas::{ErrorSchema, FieldErrorSchema, ValidationErrorSchema};
+pub use schemas::{
+    ErrorBodySchema, ErrorSchema, FieldErrorSchema, ValidationErrorBodySchema,
+    ValidationErrorSchema,
+};
 pub use spec::{
     ApiInfo, MediaType, OpenApiSpec, Operation, OperationModifier, Parameter, PathItem,
     RequestBody, ResponseModifier, ResponseSpec, SchemaRef,

crates/rustapi-openapi/src/spec.rs

@@ -138,8 +138,7 @@ impl OpenApiSpec {
 
     /// Register a type that implements Schema (utoipa::ToSchema)
     pub fn register<T: for<'a> utoipa::ToSchema<'a>>(mut self) -> Self {
-        let (name, schema) = T::schema(); // returns (Cow<str>, RefOr<Schema>)
-                                          // Convert to JSON value
+        let (name, schema) = T::schema();
         if let Ok(json_schema) = serde_json::to_value(schema) {
             self.schemas.insert(name.to_string(), json_schema);
         }

examples/proof-of-concept/src/models.rs

@@ -95,6 +95,7 @@ pub struct AuthResponse {
 }
 
 /// User information returned in auth responses
+#[rustapi_rs::schema]
 #[derive(Debug, Serialize, Schema)]
 pub struct UserInfo {
     pub id: u64,