!

Author: Tuntii

Cargo.lock

@@ -4,6 +4,8 @@ members = [
     "crates/rustapi-rs",
     "crates/rustapi-core",
     "crates/rustapi-macros",
+    "crates/rustapi-validate",
+    "crates/rustapi-openapi",
     "examples/hello-world",
 ]
 
@@ -48,9 +50,17 @@ pin-project-lite = "0.2"
 # Proc macros
 syn = { version = "2.0", features = ["full", "parsing", "extra-traits"] }
 quote = "1.0"
+
+# Validation
+validator = { version = "0.18", features = ["derive"] }
 proc-macro2 = "1.0"
 inventory = "0.3"
 
+# OpenAPI
+utoipa = { version = "5", features = ["preserve_order"] }
+
 # Internal crates
 rustapi-core = { path = "crates/rustapi-core" }
 rustapi-macros = { path = "crates/rustapi-macros" }
+rustapi-openapi = { path = "crates/rustapi-openapi" }
+rustapi-validate = { path = "crates/rustapi-validate" }

Cargo.toml

@@ -27,6 +27,12 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 serde_urlencoded = "0.7"
 
+# Validation
+validator = { workspace = true }
+
+# OpenAPI
+rustapi-openapi = { workspace = true }
+
 # Middleware
 tower = { workspace = true }
 tower-service = { workspace = true }

crates/rustapi-core/Cargo.toml

@@ -1,8 +1,12 @@
 //! RustApi application builder
 
 use crate::error::Result;
-use crate::router::{MethodRouter, Router};
+use crate::router::{get, MethodRouter, Router};
 use crate::server::Server;
+use crate::response::{Html, Response};
+use crate::extract::Json;
+use rustapi_openapi::{OpenApiDoc, swagger_ui_html};
+use std::sync::Arc;
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
 
 /// Main application builder for RustAPI
@@ -24,6 +28,8 @@ use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilte
 /// ```
 pub struct RustApi {
     router: Router,
+    openapi: Option<OpenApiDoc>,
+    docs_path: Option<String>,
 }
 
 impl RustApi {
@@ -39,6 +45,8 @@ impl RustApi {
 
         Self {
             router: Router::new(),
+            openapi: None,
+            docs_path: None,
         }
     }
 
@@ -100,16 +108,40 @@ impl RustApi {
         self
     }
 
+    /// Configure OpenAPI documentation
+    ///
+    /// # Example
+    ///
+    /// ```rust,ignore
+    /// use rustapi_openapi::OpenApiDoc;
+    ///
+    /// RustApi::new()
+    ///     .openapi(OpenApiDoc::new("My API", "1.0.0")
+    ///         .description("A sample API")
+    ///         .server("http://localhost:8080"))
+    /// ```
+    pub fn openapi(mut self, doc: OpenApiDoc) -> Self {
+        self.openapi = Some(doc);
+        self
+    }
+
     /// Enable Swagger UI at the specified path
     ///
+    /// Also enables `/openapi.json` endpoint automatically.
+    ///
     /// # Example
     ///
     /// ```rust,ignore
     /// RustApi::new()
-    ///     .docs("/docs")  // Swagger UI at /docs
+    ///     .openapi(OpenApiDoc::new("My API", "1.0.0"))
+    ///     .docs("/docs")  // Swagger UI at /docs, spec at /openapi.json
     /// ```
-    pub fn docs(self, _path: &str) -> Self {
-        // TODO: Implement OpenAPI + Swagger UI
+    pub fn docs(mut self, path: &str) -> Self {
+        self.docs_path = Some(path.to_string());
+        // Create default OpenAPI doc if not set
+        if self.openapi.is_none() {
+            self.openapi = Some(OpenApiDoc::new("RustAPI", "1.0.0"));
+        }
         self
     }
 
@@ -123,7 +155,42 @@ impl RustApi {
     ///     .run("127.0.0.1:8080")
     ///     .await
     /// ```
-    pub async fn run(self, addr: &str) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    pub async fn run(mut self, addr: &str) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+        // Add OpenAPI endpoints if configured
+        if let Some(doc) = self.openapi.take() {
+            let doc = Arc::new(doc);
+            let docs_path = self.docs_path.take();
+            
+            // Add /openapi.json endpoint
+            let doc_for_json = doc.clone();
+            self.router = self.router.route(
+                "/openapi.json",
+                get(move || {
+                    let doc = doc_for_json.clone();
+                    async move {
+                        OpenApiJsonResponse(doc.to_json())
+                    }
+                }),
+            );
+
+            // Add Swagger UI endpoint if docs path is set
+            if let Some(path) = docs_path {
+                let title = doc.title().to_string();
+                self.router = self.router.route(
+                    &path,
+                    get(move || {
+                        let title = title.clone();
+                        async move {
+                            Html(swagger_ui_html("/openapi.json", &title))
+                        }
+                    }),
+                );
+                tracing::info!("📚 Swagger UI available at http://{}{}", addr, path);
+            }
+            
+            tracing::info!("📄 OpenAPI spec at http://{}/openapi.json", addr);
+        }
+
         let server = Server::new(self.router);
         server.run(addr).await
     }
@@ -139,3 +206,20 @@ impl Default for RustApi {
         Self::new()
     }
 }
+
+/// Response type for OpenAPI JSON
+struct OpenApiJsonResponse(String);
+
+impl crate::response::IntoResponse for OpenApiJsonResponse {
+    fn into_response(self) -> Response {
+        use bytes::Bytes;
+        use http::{header, StatusCode};
+        use http_body_util::Full;
+
+        http::Response::builder()
+            .status(StatusCode::OK)
+            .header(header::CONTENT_TYPE, "application/json")
+            .body(Full::new(Bytes::from(self.0)))
+            .unwrap()
+    }
+}

crates/rustapi-core/src/app.rs

@@ -2,6 +2,7 @@
 
 use http::StatusCode;
 use serde::Serialize;
+use std::collections::HashMap;
 use std::fmt;
 
 /// Result type alias for RustAPI operations
@@ -33,6 +34,36 @@ pub struct FieldError {
     pub code: String,
     /// Human-readable message
     pub message: String,
+    /// Optional parameters (e.g., min/max values)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub params: Option<HashMap<String, serde_json::Value>>,
+}
+
+impl FieldError {
+    /// Create a new field error
+    pub fn new(field: impl Into<String>, code: impl Into<String>, message: impl Into<String>) -> Self {
+        Self {
+            field: field.into(),
+            code: code.into(),
+            message: message.into(),
+            params: None,
+        }
+    }
+
+    /// Create a field error with parameters
+    pub fn with_params(
+        field: impl Into<String>,
+        code: impl Into<String>,
+        message: impl Into<String>,
+        params: HashMap<String, serde_json::Value>,
+    ) -> Self {
+        Self {
+            field: field.into(),
+            code: code.into(),
+            message: message.into(),
+            params: Some(params),
+        }
+    }
 }
 
 impl ApiError {
@@ -88,6 +119,43 @@ impl ApiError {
         Self::new(StatusCode::INTERNAL_SERVER_ERROR, "internal_error", message)
     }
 
+    /// Create from validator::ValidationErrors
+    pub fn from_validation_errors(errors: validator::ValidationErrors) -> Self {
+        let mut field_errors = Vec::new();
+
+        for (field, error_kinds) in errors.field_errors() {
+            for error in error_kinds {
+                let code = error.code.to_string();
+                let message = error
+                    .message
+                    .as_ref()
+                    .map(|m| m.to_string())
+                    .unwrap_or_else(|| format!("Validation failed for field '{}'", field));
+
+                let params = if error.params.is_empty() {
+                    None
+                } else {
+                    let mut map = HashMap::new();
+                    for (key, value) in &error.params {
+                        if let Ok(json_value) = serde_json::to_value(value) {
+                            map.insert(key.to_string(), json_value);
+                        }
+                    }
+                    Some(map)
+                };
+
+                field_errors.push(FieldError {
+                    field: field.to_string(),
+                    code,
+                    message,
+                    params,
+                });
+            }
+        }
+
+        Self::validation(field_errors)
+    }
+
     /// Add internal details (for logging, hidden from response in prod)
     pub fn with_internal(mut self, details: impl Into<String>) -> Self {
         self.internal = Some(details.into());

crates/rustapi-core/src/error.rs

@@ -13,6 +13,7 @@ use serde::Serialize;
 use std::future::Future;
 use std::ops::{Deref, DerefMut};
 use std::str::FromStr;
+use validator::Validate;
 
 /// Trait for extracting data from request parts (headers, path, query)
 ///
@@ -287,4 +288,80 @@ impl_from_request_parts_for_primitives!(
     String
 );
 
+/// Validated JSON body extractor
+///
+/// Parses the request body as JSON, deserializes into type `T`, 
+/// and validates using the `validator` crate.
+/// Returns 422 Unprocessable Entity on validation failure.
+///
+/// # Example
+///
+/// ```rust,ignore
+/// use validator::Validate;
+///
+/// #[derive(Deserialize, Validate)]
+/// struct CreateUser {
+///     #[validate(email)]
+///     email: String,
+///     #[validate(length(min = 3, max = 50))]
+///     name: String,
+/// }
+///
+/// async fn create_user(ValidatedJson(body): ValidatedJson<CreateUser>) -> impl IntoResponse {
+///     // body is already deserialized AND validated
+/// }
+/// ```
+#[derive(Debug, Clone, Copy, Default)]
+pub struct ValidatedJson<T>(pub T);
+
+impl<T: DeserializeOwned + Validate + Send> FromRequest for ValidatedJson<T> {
+    async fn from_request(req: &mut Request) -> Result<Self> {
+        let body = req.take_body().ok_or_else(|| {
+            ApiError::internal("Body already consumed")
+        })?;
+
+        let value: T = serde_json::from_slice(&body)?;
+        
+        // Validate the deserialized value
+        value.validate().map_err(|e| ApiError::from_validation_errors(e))?;
+        
+        Ok(ValidatedJson(value))
+    }
+}
+
+impl<T> Deref for ValidatedJson<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T> DerefMut for ValidatedJson<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl<T> From<T> for ValidatedJson<T> {
+    fn from(value: T) -> Self {
+        ValidatedJson(value)
+    }
+}
+
+// IntoResponse for ValidatedJson - same as Json
+impl<T: Serialize> IntoResponse for ValidatedJson<T> {
+    fn into_response(self) -> crate::response::Response {
+        match serde_json::to_vec(&self.0) {
+            Ok(body) => http::Response::builder()
+                .status(StatusCode::OK)
+                .header(header::CONTENT_TYPE, "application/json")
+                .body(Full::new(Bytes::from(body)))
+                .unwrap(),
+            Err(err) => ApiError::internal(format!("Failed to serialize response: {}", err))
+                .into_response(),
+        }
+    }
+}
+
 // Re-export Json from response for extraction (they share the type)

crates/rustapi-core/src/extract.rs

@@ -15,9 +15,15 @@ mod server;
 
 // Public API
 pub use app::RustApi;
-pub use error::{ApiError, Result};
-pub use extract::{Body, FromRequest, FromRequestParts, Json, Path, Query, State};
+pub use error::{ApiError, FieldError, Result};
+pub use extract::{Body, FromRequest, FromRequestParts, Json, Path, Query, State, ValidatedJson};
 pub use handler::{Handler, HandlerService};
 pub use request::Request;
-pub use response::{Created, Html, IntoResponse, NoContent, Redirect, Response};
+pub use response::{created, json, no_content, text, Created, Html, IntoResponse, NoContent, Redirect, Response};
 pub use router::{delete, get, patch, post, put, MethodRouter, Router};
+
+// Re-export validator traits for users
+pub use validator::Validate;
+
+// Re-export OpenAPI types
+pub use rustapi_openapi::OpenApiDoc;