Revert "!"

This reverts commit 9bba035.

Author: Tuntii

Cargo.lock

@@ -4,8 +4,6 @@ members = [
     "crates/rustapi-rs",
     "crates/rustapi-core",
     "crates/rustapi-macros",
-    "crates/rustapi-validate",
-    "crates/rustapi-openapi",
     "examples/hello-world",
 ]
 
@@ -50,17 +48,9 @@ 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,12 +27,6 @@ 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,12 +1,8 @@
 //! RustApi application builder
 
 use crate::error::Result;
-use crate::router::{get, MethodRouter, Router};
+use crate::router::{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
@@ -28,8 +24,6 @@ use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilte
 /// ```
 pub struct RustApi {
     router: Router,
-    openapi: Option<OpenApiDoc>,
-    docs_path: Option<String>,
 }
 
 impl RustApi {
@@ -45,8 +39,6 @@ impl RustApi {
 
         Self {
             router: Router::new(),
-            openapi: None,
-            docs_path: None,
         }
     }
 
@@ -108,40 +100,16 @@ 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()
-    ///     .openapi(OpenApiDoc::new("My API", "1.0.0"))
-    ///     .docs("/docs")  // Swagger UI at /docs, spec at /openapi.json
+    ///     .docs("/docs")  // Swagger UI at /docs
     /// ```
-    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"));
-        }
+    pub fn docs(self, _path: &str) -> Self {
+        // TODO: Implement OpenAPI + Swagger UI
         self
     }
 
@@ -155,42 +123,7 @@ impl RustApi {
     ///     .run("127.0.0.1:8080")
     ///     .await
     /// ```
-    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);
-        }
-
+    pub async fn run(self, addr: &str) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
         let server = Server::new(self.router);
         server.run(addr).await
     }
@@ -206,20 +139,3 @@ 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,7 +2,6 @@
 
 use http::StatusCode;
 use serde::Serialize;
-use std::collections::HashMap;
 use std::fmt;
 
 /// Result type alias for RustAPI operations
@@ -34,36 +33,6 @@ 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 {
@@ -119,43 +88,6 @@ 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,7 +13,6 @@ 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)
 ///
@@ -288,80 +287,4 @@ 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,15 +15,9 @@ mod server;
 
 // Public API
 pub use app::RustApi;
-pub use error::{ApiError, FieldError, Result};
-pub use extract::{Body, FromRequest, FromRequestParts, Json, Path, Query, State, ValidatedJson};
+pub use error::{ApiError, Result};
+pub use extract::{Body, FromRequest, FromRequestParts, Json, Path, Query, State};
 pub use handler::{Handler, HandlerService};
 pub use request::Request;
-pub use response::{created, json, no_content, text, Created, Html, IntoResponse, NoContent, Redirect, Response};
+pub use response::{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;