spikard 0.3.6 → 0.5.0

data/vendor/crates/spikard-http/src/handler_trait_tests.rs

@@ -100,6 +100,7 @@ mod tests {
         let request_data = RequestData {
             path_params: Arc::new(path_params),
             query_params: json!({"page": 1}),
+            validated_params: None,
             raw_query_params: Arc::new(HashMap::new()),
             body: json!({"test": "data"}),
             raw_body: None,
@@ -131,6 +132,7 @@ mod tests {
         let request_data = RequestData {
             path_params: Arc::new(HashMap::new()),
             query_params: Value::Null,
+            validated_params: None,
             raw_query_params: Arc::new(HashMap::new()),
             body: Value::Null,
             raw_body: None,
@@ -169,6 +171,7 @@ mod tests {
         let request_data = RequestData {
             path_params: Arc::new(HashMap::new()),
             query_params: json!({"api_key": "secret123"}),
+            validated_params: None,
             raw_query_params: Arc::new(raw_query_params.clone()),
             body: Value::Null,
             raw_body: None,
@@ -192,6 +195,7 @@ mod tests {
         let request_data_no_param = RequestData {
             path_params: Arc::new(HashMap::new()),
             query_params: Value::Null,
+            validated_params: None,
             raw_query_params: Arc::new(HashMap::new()),
             body: Value::Null,
             raw_body: None,
@@ -229,6 +233,7 @@ mod tests {
         let request_data = RequestData {
             path_params: Arc::new(path_params),
             query_params: json!({"filter": "active"}),
+            validated_params: None,
             raw_query_params: Arc::new(raw_query_params),
             body: json!({"name": "test"}),
             raw_body: None,
@@ -254,6 +259,7 @@ mod tests {
         let request_data = RequestData {
             path_params: Arc::new(HashMap::new()),
             query_params: Value::Null,
+            validated_params: None,
             raw_query_params: Arc::new(HashMap::new()),
             body: Value::Null,
             raw_body: None,

data/vendor/crates/spikard-http/src/lib.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::pedantic, clippy::nursery)]
+#![cfg_attr(test, allow(clippy::all))]
 //! Spikard HTTP Server
 //!
 //! Pure Rust HTTP server with language-agnostic handler trait.
@@ -13,20 +15,15 @@ pub mod debug;
 pub mod di_handler;
 pub mod handler_response;
 pub mod handler_trait;
+pub mod jsonrpc;
 pub mod lifecycle;
 pub mod middleware;
 pub mod openapi;
-pub mod parameters;
-pub mod problem;
 pub mod query_parser;
 pub mod response;
-pub mod router;
-pub mod schema_registry;
 pub mod server;
 pub mod sse;
 pub mod testing;
-pub mod type_hints;
-pub mod validation;
 pub mod websocket;
 
 use serde::{Deserialize, Serialize};
@@ -44,20 +41,22 @@ pub use body_metadata::ResponseBodySize;
 pub use di_handler::DependencyInjectingHandler;
 pub use handler_response::HandlerResponse;
 pub use handler_trait::{Handler, HandlerResult, RequestData, ValidatedParams};
+pub use jsonrpc::JsonRpcConfig;
 pub use lifecycle::{HookResult, LifecycleHook, LifecycleHooks, LifecycleHooksBuilder, request_hook, response_hook};
 pub use openapi::{ContactInfo, LicenseInfo, OpenApiConfig, SecuritySchemeInfo, ServerInfo};
-pub use parameters::ParameterValidator;
-pub use problem::{CONTENT_TYPE_PROBLEM_JSON, ProblemDetails};
 pub use response::Response;
-pub use router::{Route, RouteHandler, Router};
-pub use schema_registry::SchemaRegistry;
 pub use server::Server;
-pub use spikard_core::{CompressionConfig, CorsConfig, Method, RateLimitConfig, RouteMetadata};
+pub use spikard_core::{
+    CompressionConfig, CorsConfig, Method, ParameterValidator, ProblemDetails, RateLimitConfig, Route, RouteHandler,
+    RouteMetadata, Router, SchemaRegistry, SchemaValidator,
+};
 pub use sse::{SseEvent, SseEventProducer, SseState, sse_handler};
 pub use testing::{ResponseSnapshot, SnapshotError, snapshot_response};
-pub use validation::SchemaValidator;
 pub use websocket::{WebSocketHandler, WebSocketState, websocket_handler};
 
+/// Reexport from spikard_core for convenience
+pub use spikard_core::problem::CONTENT_TYPE_PROBLEM_JSON;
+
 /// JWT authentication configuration
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct JwtConfig {
@@ -139,10 +138,14 @@ pub struct ServerConfig {
     pub shutdown_timeout: u64,
     /// OpenAPI documentation configuration
     pub openapi: Option<crate::openapi::OpenApiConfig>,
+    /// JSON-RPC configuration
+    pub jsonrpc: Option<crate::jsonrpc::JsonRpcConfig>,
     /// Lifecycle hooks for request/response processing
     pub lifecycle_hooks: Option<std::sync::Arc<LifecycleHooks>>,
     /// Background task executor configuration
     pub background_tasks: BackgroundTaskConfig,
+    /// Enable per-request HTTP tracing (tower-http `TraceLayer`)
+    pub enable_http_trace: bool,
     /// Dependency injection container (requires 'di' feature)
     #[cfg(feature = "di")]
     pub di_container: Option<std::sync::Arc<spikard_core::di::DependencyContainer>>,
@@ -154,10 +157,10 @@ impl Default for ServerConfig {
             host: "127.0.0.1".to_string(),
             port: 8000,
             workers: 1,
-            enable_request_id: true,
+            enable_request_id: false,
             max_body_size: Some(10 * 1024 * 1024),
-            request_timeout: Some(30),
-            compression: Some(CompressionConfig::default()),
+            request_timeout: None,
+            compression: None,
             rate_limit: None,
             jwt_auth: None,
             api_key_auth: None,
@@ -165,8 +168,10 @@ impl Default for ServerConfig {
             graceful_shutdown: true,
             shutdown_timeout: 30,
             openapi: None,
+            jsonrpc: None,
             lifecycle_hooks: None,
             background_tasks: BackgroundTaskConfig::default(),
+            enable_http_trace: false,
             #[cfg(feature = "di")]
             di_container: None,
         }
@@ -256,6 +261,12 @@ impl ServerConfigBuilder {
         self
     }
 
+    /// Enable or disable per-request HTTP tracing (tower-http `TraceLayer`)
+    pub fn enable_http_trace(mut self, enable: bool) -> Self {
+        self.config.enable_http_trace = enable;
+        self
+    }
+
     /// Set maximum request body size in bytes (None = unlimited, not recommended)
     pub fn max_body_size(mut self, size: Option<usize>) -> Self {
         self.config.max_body_size = size;
@@ -322,6 +333,12 @@ impl ServerConfigBuilder {
         self
     }
 
+    /// Set JSON-RPC configuration
+    pub fn jsonrpc(mut self, jsonrpc: Option<crate::jsonrpc::JsonRpcConfig>) -> Self {
+        self.config.jsonrpc = jsonrpc;
+        self
+    }
+
     /// Set lifecycle hooks for request/response processing
     pub fn lifecycle_hooks(mut self, hooks: Option<std::sync::Arc<LifecycleHooks>>) -> Self {
         self.config.lifecycle_hooks = hooks;
@@ -360,24 +377,16 @@ impl ServerConfigBuilder {
 
         let key_str = key.into();
 
-        // Get or create DI container (mutable)
         let container = if let Some(container) = self.config.di_container.take() {
-            // Try to get mutable access - this will only work if we're the only owner
-            Arc::try_unwrap(container).unwrap_or_else(|_arc| {
-                // If we can't unwrap, we lose existing dependencies
-                // This is a fallback that shouldn't happen in normal builder usage (linear chaining)
-                DependencyContainer::new()
-            })
+            Arc::try_unwrap(container).unwrap_or_else(|_arc| DependencyContainer::new())
         } else {
             DependencyContainer::new()
         };
 
         let mut container = container;
 
-        // Create ValueDependency
         let dep = ValueDependency::new(key_str.clone(), value);
 
-        // Register (panic on error for builder pattern)
         container
             .register(key_str, Arc::new(dep))
             .expect("Failed to register dependency");
@@ -433,7 +442,6 @@ impl ServerConfigBuilder {
 
         let key_str = key.into();
 
-        // Get or create DI container (mutable)
         let container = if let Some(container) = self.config.di_container.take() {
             Arc::try_unwrap(container).unwrap_or_else(|_| DependencyContainer::new())
         } else {
@@ -442,10 +450,8 @@ impl ServerConfigBuilder {
 
         let mut container = container;
 
-        // Clone factory for the closure
         let factory_clone = factory.clone();
 
-        // Create FactoryDependency using builder
         let dep = FactoryDependency::builder(key_str.clone())
             .factory(
                 move |_req: &axum::http::Request<()>,
@@ -501,7 +507,6 @@ impl ServerConfigBuilder {
 
         let key = dependency.key().to_string();
 
-        // Get or create DI container (mutable)
         let container = if let Some(container) = self.config.di_container.take() {
             Arc::try_unwrap(container).unwrap_or_else(|_| DependencyContainer::new())
         } else {

data/vendor/crates/spikard-http/src/lifecycle/adapter.rs

@@ -115,6 +115,11 @@ impl HookRegistry {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::lifecycle::HookResult;
+    use axum::body::Body;
+    use axum::http::{Request, Response, StatusCode};
+    use std::future::Future;
+    use std::pin::Pin;
 
     #[test]
     fn test_error_messages() {
@@ -146,4 +151,80 @@ mod tests {
         let deser_err = error::deserialize_failed("response", "malformed");
         assert!(deser_err.contains("response"));
     }
+
+    #[tokio::test]
+    async fn serial_extract_body_roundtrips_bytes() {
+        let body = Body::from("hello");
+        let bytes = serial::extract_body(body).await.expect("extract body");
+        assert_eq!(&bytes[..], b"hello");
+    }
+
+    #[test]
+    fn serial_parse_json_handles_empty_valid_and_invalid_json() {
+        let empty = serial::parse_json(&[]).expect("parse empty");
+        assert_eq!(empty, serde_json::Value::Null);
+
+        let valid = serial::parse_json(br#"{"ok":true}"#).expect("parse json");
+        assert_eq!(valid["ok"], true);
+
+        let invalid = serial::parse_json(b"not-json").expect("parse fallback");
+        assert_eq!(invalid, serde_json::Value::String("not-json".to_string()));
+    }
+
+    #[test]
+    fn hook_registry_registers_all_hooks_via_callback() {
+        struct NoopHook {
+            hook_name: String,
+        }
+
+        impl LifecycleHook<Request<Body>, Response<Body>> for NoopHook {
+            fn name(&self) -> &str {
+                &self.hook_name
+            }
+
+            fn execute_request<'a>(
+                &'a self,
+                req: Request<Body>,
+            ) -> Pin<Box<dyn Future<Output = Result<HookResult<Request<Body>, Response<Body>>, String>> + Send + 'a>>
+            {
+                Box::pin(async move { Ok(HookResult::Continue(req)) })
+            }
+
+            fn execute_response<'a>(
+                &'a self,
+                resp: Response<Body>,
+            ) -> Pin<Box<dyn Future<Output = Result<HookResult<Response<Body>, Response<Body>>, String>> + Send + 'a>>
+            {
+                Box::pin(async move { Ok(HookResult::Continue(resp)) })
+            }
+        }
+
+        let mut hooks = HttpLifecycleHooks::new();
+        assert!(hooks.is_empty());
+
+        let hook_list: Vec<Arc<dyn LifecycleHook<Request<Body>, Response<Body>>>> = vec![
+            Arc::new(NoopHook {
+                hook_name: "one".to_string(),
+            }),
+            Arc::new(NoopHook {
+                hook_name: "two".to_string(),
+            }),
+        ];
+
+        HookRegistry::register_from_list(&mut hooks, hook_list, "on_request", |hooks, hook| {
+            hooks.add_on_request(hook);
+        });
+
+        let dbg = format!("{:?}", hooks);
+        assert!(dbg.contains("on_request_count"));
+        assert!(dbg.contains("2"));
+
+        let req = Request::builder().body(Body::empty()).unwrap();
+        let result = futures::executor::block_on(hooks.execute_on_request(req)).expect("hook run");
+        assert!(matches!(result, HookResult::Continue(_)));
+
+        let resp = Response::builder().status(StatusCode::OK).body(Body::empty()).unwrap();
+        let resp = futures::executor::block_on(hooks.execute_on_response(resp)).expect("hook run");
+        assert_eq!(resp.status(), StatusCode::OK);
+    }
 }