spikard 0.8.3 → 0.10.2

data/vendor/crates/spikard-core/src/di/factory.rs

@@ -440,7 +440,7 @@ mod tests {
                     let config: Option<Arc<String>> = resolved.get("config");
                     let config_value = config.map(|c| (*c).clone()).unwrap_or_default();
 
-                    Ok(Arc::new(format!("Service using {}", config_value)) as Arc<dyn Any + Send + Sync>)
+                    Ok(Arc::new(format!("Service using {config_value}")) as Arc<dyn Any + Send + Sync>)
                 })
             })
             .build();
@@ -524,7 +524,7 @@ mod tests {
             .singleton(false)
             .build();
 
-        let debug_str = format!("{:?}", factory);
+        let debug_str = format!("{factory:?}");
         assert!(debug_str.contains("FactoryDependency"));
         assert!(debug_str.contains("test"));
         assert!(debug_str.contains("dep1"));

data/vendor/crates/spikard-core/src/di/resolved.rs

@@ -31,7 +31,7 @@ type CleanupTask = Box<dyn FnOnce() -> BoxFuture<'static, ()> + Send>;
 ///
 /// // Insert a dependency
 /// let value = Arc::new(42i32);
-/// resolved.insert("answer".to_string(), value.clone());
+/// resolved.insert("answer".to_string(), value);
 ///
 /// // Retrieve with type safety
 /// let retrieved: Option<Arc<i32>> = resolved.get("answer");
@@ -335,7 +335,7 @@ mod tests {
     fn test_insert_and_get() {
         let mut resolved = ResolvedDependencies::new();
         let value = Arc::new(42i32);
-        resolved.insert("answer".to_string(), value.clone());
+        resolved.insert("answer".to_string(), value);
 
         let retrieved: Option<Arc<i32>> = resolved.get("answer");
         assert_eq!(retrieved.map(|v| *v), Some(42));

data/vendor/crates/spikard-core/src/di/value.rs

@@ -275,7 +275,7 @@ mod tests {
     #[test]
     fn test_debug() {
         let dep = ValueDependency::new("test", 42i32);
-        let debug_str = format!("{:?}", dep);
+        let debug_str = format!("{dep:?}");
         assert!(debug_str.contains("ValueDependency"));
         assert!(debug_str.contains("test"));
     }

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

@@ -1,5 +1,6 @@
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
+use std::sync::OnceLock;
 
 /// HTTP method
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
@@ -67,6 +68,73 @@ pub struct CorsConfig {
     pub max_age: Option<u32>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub allow_credentials: Option<bool>,
+
+    // Optimized caches (lazy-initialized on first use)
+    #[serde(skip)]
+    #[doc(hidden)]
+    pub methods_joined_cache: OnceLock<String>,
+    #[serde(skip)]
+    #[doc(hidden)]
+    pub headers_joined_cache: OnceLock<String>,
+}
+
+impl CorsConfig {
+    /// Get the cached joined methods string for preflight responses
+    pub fn allowed_methods_joined(&self) -> &str {
+        self.methods_joined_cache
+            .get_or_init(|| self.allowed_methods.join(", "))
+    }
+
+    /// Get the cached joined headers string for preflight responses
+    pub fn allowed_headers_joined(&self) -> &str {
+        self.headers_joined_cache
+            .get_or_init(|| self.allowed_headers.join(", "))
+    }
+
+    /// Check if an origin is allowed (O(1) with wildcard, O(n) for exact match)
+    pub fn is_origin_allowed(&self, origin: &str) -> bool {
+        if origin.is_empty() {
+            return false;
+        }
+        self.allowed_origins.iter().any(|o| o == "*" || o == origin)
+    }
+
+    /// Check if a method is allowed (O(1) with wildcard, O(n) for exact match)
+    pub fn is_method_allowed(&self, method: &str) -> bool {
+        self.allowed_methods
+            .iter()
+            .any(|m| m == "*" || m.eq_ignore_ascii_case(method))
+    }
+
+    /// Check if all requested headers are allowed (O(n) where n = num requested headers)
+    pub fn are_headers_allowed(&self, requested: &[&str]) -> bool {
+        // Check if wildcard is set
+        if self.allowed_headers.iter().any(|h| h == "*") {
+            return true;
+        }
+
+        // Check each requested header
+        requested.iter().all(|req_header| {
+            self.allowed_headers
+                .iter()
+                .any(|h| h.to_lowercase() == req_header.to_lowercase())
+        })
+    }
+}
+
+impl Default for CorsConfig {
+    fn default() -> Self {
+        Self {
+            allowed_origins: vec!["*".to_string()],
+            allowed_methods: vec!["*".to_string()],
+            allowed_headers: vec![],
+            expose_headers: None,
+            max_age: None,
+            allow_credentials: None,
+            methods_joined_cache: OnceLock::new(),
+            headers_joined_cache: OnceLock::new(),
+        }
+    }
 }
 
 /// Route metadata extracted from bindings
@@ -93,6 +161,11 @@ pub struct RouteMetadata {
     /// JSON-RPC method metadata (if this route is exposed as a JSON-RPC method)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub jsonrpc_method: Option<Value>,
+    /// Optional static response configuration: `{"status": 200, "body": "OK", "content_type": "text/plain"}`
+    /// When present, the handler is replaced by a `StaticResponseHandler` that bypasses the full
+    /// middleware pipeline for maximum throughput.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub static_response: Option<Value>,
 }
 
 /// Compression configuration shared across runtimes
@@ -386,6 +459,7 @@ mod tests {
             expose_headers: None,
             max_age: None,
             allow_credentials: None,
+            ..Default::default()
         };
         assert_eq!(cors.allowed_origins.len(), 1);
         assert_eq!(cors.allowed_methods.len(), 2);
@@ -408,6 +482,7 @@ mod tests {
             #[cfg(feature = "di")]
             handler_dependencies: None,
             jsonrpc_method: None,
+            static_response: None,
         };
         assert_eq!(metadata.method, "GET");
         assert_eq!(metadata.path, "/api/users");

data/vendor/crates/spikard-core/src/lifecycle.rs

@@ -465,11 +465,11 @@ mod tests {
     #[test]
     fn test_hook_result_debug_format() {
         let continue_result: HookResult<i32, String> = HookResult::Continue(100);
-        let debug_str = format!("{:?}", continue_result);
+        let debug_str = format!("{continue_result:?}");
         assert!(debug_str.contains("Continue"));
 
         let short_circuit_result: HookResult<i32, String> = HookResult::ShortCircuit("err".to_string());
-        let debug_str = format!("{:?}", short_circuit_result);
+        let debug_str = format!("{short_circuit_result:?}");
         assert!(debug_str.contains("ShortCircuit"));
     }
 
@@ -494,16 +494,16 @@ mod tests {
     #[test]
     fn test_lifecycle_hooks_debug_format_empty() {
         let hooks: LifecycleHooks<String, String> = LifecycleHooks::default();
-        let debug_str = format!("{:?}", hooks);
+        let debug_str = format!("{hooks:?}");
         assert!(debug_str.contains("LifecycleHooks"));
         assert!(debug_str.contains("on_request_count"));
-        assert!(debug_str.contains("0"));
+        assert!(debug_str.contains('0'));
     }
 
     #[test]
     fn test_lifecycle_hooks_clone() {
         let hooks1: LifecycleHooks<String, String> = LifecycleHooks::default();
-        let hooks2 = hooks1.clone();
+        let hooks2 = hooks1;
         assert!(hooks2.is_empty());
     }
 
@@ -566,15 +566,15 @@ mod tests {
 
     #[cfg(not(target_arch = "wasm32"))]
     impl NativeLifecycleHook<String, String> for TestRequestHook {
-        fn name(&self) -> &str {
+        fn name(&self) -> &'static str {
             "test_request_hook"
         }
 
-        fn execute_request<'a>(&'a self, req: String) -> RequestHookFutureSend<'a, String, String> {
+        fn execute_request<'a>(&self, req: String) -> RequestHookFutureSend<'a, String, String> {
             Box::pin(async move { Ok(HookResult::Continue(req + "_modified")) })
         }
 
-        fn execute_response<'a>(&'a self, _resp: String) -> ResponseHookFutureSend<'a, String> {
+        fn execute_response<'a>(&self, _resp: String) -> ResponseHookFutureSend<'a, String> {
             Box::pin(async { Err("not implemented".to_string()) })
         }
     }
@@ -588,11 +588,11 @@ mod tests {
             "test_request_hook"
         }
 
-        fn execute_request<'a>(&'a self, req: String) -> RequestHookFutureLocal<'a, String, String> {
+        fn execute_request<'a>(&self, req: String) -> RequestHookFutureLocal<'a, String, String> {
             Box::pin(async move { Ok(HookResult::Continue(req + "_modified")) })
         }
 
-        fn execute_response<'a>(&'a self, _resp: String) -> ResponseHookFutureLocal<'a, String> {
+        fn execute_response<'a>(&self, _resp: String) -> ResponseHookFutureLocal<'a, String> {
             Box::pin(async { Err("not implemented".to_string()) })
         }
     }
@@ -628,15 +628,15 @@ mod tests {
 
     #[cfg(not(target_arch = "wasm32"))]
     impl NativeLifecycleHook<String, String> for TestResponseHook {
-        fn name(&self) -> &str {
+        fn name(&self) -> &'static str {
             "test_response_hook"
         }
 
-        fn execute_request<'a>(&'a self, _req: String) -> RequestHookFutureSend<'a, String, String> {
+        fn execute_request<'a>(&self, _req: String) -> RequestHookFutureSend<'a, String, String> {
             Box::pin(async { Err("not implemented".to_string()) })
         }
 
-        fn execute_response<'a>(&'a self, resp: String) -> ResponseHookFutureSend<'a, String> {
+        fn execute_response<'a>(&self, resp: String) -> ResponseHookFutureSend<'a, String> {
             Box::pin(async move { Ok(HookResult::Continue(resp + "_processed")) })
         }
     }
@@ -650,11 +650,11 @@ mod tests {
             "test_response_hook"
         }
 
-        fn execute_request<'a>(&'a self, _req: String) -> RequestHookFutureLocal<'a, String, String> {
+        fn execute_request<'a>(&self, _req: String) -> RequestHookFutureLocal<'a, String, String> {
             Box::pin(async { Err("not implemented".to_string()) })
         }
 
-        fn execute_response<'a>(&'a self, resp: String) -> ResponseHookFutureLocal<'a, String> {
+        fn execute_response<'a>(&self, resp: String) -> ResponseHookFutureLocal<'a, String> {
             Box::pin(async move { Ok(HookResult::Continue(resp + "_processed")) })
         }
     }
@@ -783,15 +783,15 @@ mod tests {
 
     #[cfg(not(target_arch = "wasm32"))]
     impl NativeLifecycleHook<String, String> for TestShortCircuitHook {
-        fn name(&self) -> &str {
+        fn name(&self) -> &'static str {
             "short_circuit"
         }
 
-        fn execute_request<'a>(&'a self, _req: String) -> RequestHookFutureSend<'a, String, String> {
+        fn execute_request<'a>(&self, _req: String) -> RequestHookFutureSend<'a, String, String> {
             Box::pin(async { Ok(HookResult::ShortCircuit("short_circuit_response".to_string())) })
         }
 
-        fn execute_response<'a>(&'a self, _resp: String) -> ResponseHookFutureSend<'a, String> {
+        fn execute_response<'a>(&self, _resp: String) -> ResponseHookFutureSend<'a, String> {
             Box::pin(async { Err("not implemented".to_string()) })
         }
     }
@@ -805,11 +805,11 @@ mod tests {
             "short_circuit"
         }
 
-        fn execute_request<'a>(&'a self, _req: String) -> RequestHookFutureLocal<'a, String, String> {
+        fn execute_request<'a>(&self, _req: String) -> RequestHookFutureLocal<'a, String, String> {
             Box::pin(async { Ok(HookResult::ShortCircuit("short_circuit_response".to_string())) })
         }
 
-        fn execute_response<'a>(&'a self, _resp: String) -> ResponseHookFutureLocal<'a, String> {
+        fn execute_response<'a>(&self, _resp: String) -> ResponseHookFutureLocal<'a, String> {
             Box::pin(async { Err("not implemented".to_string()) })
         }
     }
@@ -858,15 +858,15 @@ mod tests {
 
     #[cfg(not(target_arch = "wasm32"))]
     impl NativeLifecycleHook<String, String> for TestResponseShortCircuitHook {
-        fn name(&self) -> &str {
+        fn name(&self) -> &'static str {
             "response_short_circuit"
         }
 
-        fn execute_request<'a>(&'a self, _req: String) -> RequestHookFutureSend<'a, String, String> {
+        fn execute_request<'a>(&self, _req: String) -> RequestHookFutureSend<'a, String, String> {
             Box::pin(async { Err("not implemented".to_string()) })
         }
 
-        fn execute_response<'a>(&'a self, resp: String) -> ResponseHookFutureSend<'a, String> {
+        fn execute_response<'a>(&self, resp: String) -> ResponseHookFutureSend<'a, String> {
             Box::pin(async move { Ok(HookResult::ShortCircuit("short_circuit_".to_string() + &resp)) })
         }
     }
@@ -880,11 +880,11 @@ mod tests {
             "response_short_circuit"
         }
 
-        fn execute_request<'a>(&'a self, _req: String) -> RequestHookFutureLocal<'a, String, String> {
+        fn execute_request<'a>(&self, _req: String) -> RequestHookFutureLocal<'a, String, String> {
             Box::pin(async { Err("not implemented".to_string()) })
         }
 
-        fn execute_response<'a>(&'a self, resp: String) -> ResponseHookFutureLocal<'a, String> {
+        fn execute_response<'a>(&self, resp: String) -> ResponseHookFutureLocal<'a, String> {
             Box::pin(async move { Ok(HookResult::ShortCircuit("short_circuit_".to_string() + &resp)) })
         }
     }
@@ -938,16 +938,16 @@ mod tests {
 
     #[cfg(not(target_arch = "wasm32"))]
     impl NativeLifecycleHook<String, String> for TestAppendHook {
-        fn name(&self) -> &str {
+        fn name(&self) -> &'static str {
             "append"
         }
 
-        fn execute_request<'a>(&'a self, req: String) -> RequestHookFutureSend<'a, String, String> {
+        fn execute_request<'a>(&self, req: String) -> RequestHookFutureSend<'a, String, String> {
             let suffix = self.0;
             Box::pin(async move { Ok(HookResult::Continue(req + suffix)) })
         }
 
-        fn execute_response<'a>(&'a self, _resp: String) -> ResponseHookFutureSend<'a, String> {
+        fn execute_response<'a>(&self, _resp: String) -> ResponseHookFutureSend<'a, String> {
             Box::pin(async { Err("not implemented".to_string()) })
         }
     }
@@ -961,12 +961,12 @@ mod tests {
             "append"
         }
 
-        fn execute_request<'a>(&'a self, req: String) -> RequestHookFutureLocal<'a, String, String> {
+        fn execute_request<'a>(&self, req: String) -> RequestHookFutureLocal<'a, String, String> {
             let suffix = self.0;
             Box::pin(async move { Ok(HookResult::Continue(req + suffix)) })
         }
 
-        fn execute_response<'a>(&'a self, _resp: String) -> ResponseHookFutureLocal<'a, String> {
+        fn execute_response<'a>(&self, _resp: String) -> ResponseHookFutureLocal<'a, String> {
             Box::pin(async { Err("not implemented".to_string()) })
         }
     }
@@ -994,15 +994,15 @@ mod tests {
 
     #[cfg(not(target_arch = "wasm32"))]
     impl NativeLifecycleHook<String, String> for TestAppendResponseHook {
-        fn name(&self) -> &str {
+        fn name(&self) -> &'static str {
             "append_response"
         }
 
-        fn execute_request<'a>(&'a self, _req: String) -> RequestHookFutureSend<'a, String, String> {
+        fn execute_request<'a>(&self, _req: String) -> RequestHookFutureSend<'a, String, String> {
             Box::pin(async { Err("not implemented".to_string()) })
         }
 
-        fn execute_response<'a>(&'a self, resp: String) -> ResponseHookFutureSend<'a, String> {
+        fn execute_response<'a>(&self, resp: String) -> ResponseHookFutureSend<'a, String> {
             let suffix = self.0;
             Box::pin(async move { Ok(HookResult::Continue(resp + suffix)) })
         }
@@ -1017,11 +1017,11 @@ mod tests {
             "append_response"
         }
 
-        fn execute_request<'a>(&'a self, _req: String) -> RequestHookFutureLocal<'a, String, String> {
+        fn execute_request<'a>(&self, _req: String) -> RequestHookFutureLocal<'a, String, String> {
             Box::pin(async { Err("not implemented".to_string()) })
         }
 
-        fn execute_response<'a>(&'a self, resp: String) -> ResponseHookFutureLocal<'a, String> {
+        fn execute_response<'a>(&self, resp: String) -> ResponseHookFutureLocal<'a, String> {
             let suffix = self.0;
             Box::pin(async move { Ok(HookResult::Continue(resp + suffix)) })
         }
@@ -1055,15 +1055,15 @@ mod tests {
 
     #[cfg(not(target_arch = "wasm32"))]
     impl NativeLifecycleHook<String, String> for TestErrorHook {
-        fn name(&self) -> &str {
+        fn name(&self) -> &'static str {
             "error_hook"
         }
 
-        fn execute_request<'a>(&'a self, _req: String) -> RequestHookFutureSend<'a, String, String> {
+        fn execute_request<'a>(&self, _req: String) -> RequestHookFutureSend<'a, String, String> {
             Box::pin(async { Err("hook_error".to_string()) })
         }
 
-        fn execute_response<'a>(&'a self, _resp: String) -> ResponseHookFutureSend<'a, String> {
+        fn execute_response<'a>(&self, _resp: String) -> ResponseHookFutureSend<'a, String> {
             Box::pin(async { Err("hook_error".to_string()) })
         }
     }
@@ -1077,11 +1077,11 @@ mod tests {
             "error_hook"
         }
 
-        fn execute_request<'a>(&'a self, _req: String) -> RequestHookFutureLocal<'a, String, String> {
+        fn execute_request<'a>(&self, _req: String) -> RequestHookFutureLocal<'a, String, String> {
             Box::pin(async { Err("hook_error".to_string()) })
         }
 
-        fn execute_response<'a>(&'a self, _resp: String) -> ResponseHookFutureLocal<'a, String> {
+        fn execute_response<'a>(&self, _resp: String) -> ResponseHookFutureLocal<'a, String> {
             Box::pin(async { Err("hook_error".to_string()) })
         }
     }
@@ -1160,9 +1160,9 @@ mod tests {
         #[cfg(target_arch = "wasm32")]
         hooks.add_on_request(Arc::new(TestRequestHookLocal));
 
-        let debug_str = format!("{:?}", hooks);
+        let debug_str = format!("{hooks:?}");
         assert!(debug_str.contains("on_request_count"));
-        assert!(debug_str.contains("1"));
+        assert!(debug_str.contains('1'));
     }
 
     #[cfg(not(target_arch = "wasm32"))]
@@ -1243,7 +1243,7 @@ mod tests {
     }
 
     #[test]
-    fn test_is_empty_comprehensive() {
+    fn test_is_empty_before_and_after_adding_hooks() {
         let mut hooks: LifecycleHooks<String, String> = LifecycleHooks::new();
         assert!(hooks.is_empty());
 

data/vendor/crates/spikard-core/src/parameters.rs

@@ -824,7 +824,7 @@ mod tests {
             &HashMap::new(),
             &HashMap::new(),
         );
-        assert!(result.is_ok(), "Validation should succeed: {:?}", result);
+        assert!(result.is_ok(), "Validation should succeed: {result:?}");
 
         let params = result.unwrap();
         assert_eq!(params, json!({"item_id": "foobar"}));
@@ -858,9 +858,9 @@ mod tests {
             &HashMap::new(),
         );
         if result.is_err() {
-            eprintln!("Error for 'True': {:?}", result);
+            eprintln!("Error for 'True': {result:?}");
         }
-        assert!(result.is_ok(), "Validation should succeed for 'True': {:?}", result);
+        assert!(result.is_ok(), "Validation should succeed for 'True': {result:?}");
         let params = result.unwrap();
         assert_eq!(params, json!({"value": true}));
 
@@ -873,7 +873,7 @@ mod tests {
             &HashMap::new(),
             &HashMap::new(),
         );
-        assert!(result.is_ok(), "Validation should succeed for '1': {:?}", result);
+        assert!(result.is_ok(), "Validation should succeed for '1': {result:?}");
         let params = result.unwrap();
         assert_eq!(params, json!({"value": true}));
 
@@ -886,7 +886,7 @@ mod tests {
             &HashMap::new(),
             &HashMap::new(),
         );
-        assert!(result.is_ok(), "Validation should succeed for 'false': {:?}", result);
+        assert!(result.is_ok(), "Validation should succeed for 'false': {result:?}");
         let params = result.unwrap();
         assert_eq!(params, json!({"value": false}));
 
@@ -899,7 +899,7 @@ mod tests {
             &HashMap::new(),
             &HashMap::new(),
         );
-        assert!(result.is_ok(), "Validation should succeed for 'TRUE': {:?}", result);
+        assert!(result.is_ok(), "Validation should succeed for 'TRUE': {result:?}");
         let params = result.unwrap();
         assert_eq!(params, json!({"value": true}));
     }
@@ -930,7 +930,7 @@ mod tests {
             &HashMap::new(),
             &HashMap::new(),
         );
-        assert!(result.is_ok(), "Validation should succeed for integer 1: {:?}", result);
+        assert!(result.is_ok(), "Validation should succeed for integer 1: {result:?}");
         let params = result.unwrap();
         assert_eq!(params, json!({"flag": true}));
 
@@ -944,7 +944,7 @@ mod tests {
             &HashMap::new(),
             &HashMap::new(),
         );
-        assert!(result.is_ok(), "Validation should succeed for integer 0: {:?}", result);
+        assert!(result.is_ok(), "Validation should succeed for integer 0: {result:?}");
         let params = result.unwrap();
         assert_eq!(params, json!({"flag": false}));
 
@@ -958,11 +958,7 @@ mod tests {
             &HashMap::new(),
             &HashMap::new(),
         );
-        assert!(
-            result.is_ok(),
-            "Validation should succeed for boolean true: {:?}",
-            result
-        );
+        assert!(result.is_ok(), "Validation should succeed for boolean true: {result:?}");
         let params = result.unwrap();
         assert_eq!(params, json!({"flag": true}));
 
@@ -978,8 +974,7 @@ mod tests {
         );
         assert!(
             result.is_ok(),
-            "Validation should succeed for boolean false: {:?}",
-            result
+            "Validation should succeed for boolean false: {result:?}"
         );
         let params = result.unwrap();
         assert_eq!(params, json!({"flag": false}));
@@ -1191,7 +1186,7 @@ mod tests {
 
         let validator = ParameterValidator::new(schema).unwrap();
         let mut raw_query_params: HashMap<String, Vec<String>> = HashMap::new();
-        raw_query_params.insert("flag".to_string(), vec!["".to_string()]);
+        raw_query_params.insert("flag".to_string(), vec![String::new()]);
 
         let result = validator
             .validate_and_extract(
@@ -1349,7 +1344,7 @@ mod tests {
 
         let validator = ParameterValidator::new(schema).unwrap();
         let mut raw_query_params: HashMap<String, Vec<String>> = HashMap::new();
-        raw_query_params.insert("flag".to_string(), vec!["".to_string()]);
+        raw_query_params.insert("flag".to_string(), vec![String::new()]);
 
         let result = validator.validate_and_extract(
             &json!({"flag": ""}),
@@ -1793,7 +1788,7 @@ mod tests {
             &HashMap::new(),
         );
 
-        assert!(result.is_ok(), "String parameter should pass: {:?}", result);
+        assert!(result.is_ok(), "String parameter should pass: {result:?}");
         let extracted = result.unwrap();
         assert_eq!(extracted["start_time"], json!(time_string));
     }
@@ -2386,7 +2381,7 @@ mod tests {
 
         let validator = ParameterValidator::new(schema).unwrap();
         let mut raw_query_params: HashMap<String, Vec<String>> = HashMap::new();
-        raw_query_params.insert("flag".to_string(), vec!["".to_string()]);
+        raw_query_params.insert("flag".to_string(), vec![String::new()]);
 
         let result = validator.validate_and_extract(
             &json!({"flag": ""}),

data/vendor/crates/spikard-core/src/problem.rs

@@ -247,7 +247,7 @@ mod tests {
                     error_type: "missing".to_string(),
                     loc: vec!["body".to_string(), "username".to_string()],
                     msg: "Field required".to_string(),
-                    input: Value::String("".to_string()),
+                    input: Value::String(String::new()),
                     ctx: None,
                 },
                 ValidationErrorDetail {

data/vendor/crates/spikard-core/src/request_data.rs

@@ -830,20 +830,11 @@ mod tests {
     fn test_request_data_large_json_body() {
         let mut large_obj = serde_json::Map::new();
         for i in 0..100 {
-            large_obj.insert(
-                format!("field_{}", i),
-                json!({"value": i, "name": format!("item_{}", i)}),
-            );
+            large_obj.insert(format!("field_{i}"), json!({"value": i, "name": format!("item_{}", i)}));
         }
         let body = json!(large_obj);
 
-        let data = create_request_data(
-            "/api/batch",
-            "POST",
-            body.clone(),
-            json!({}),
-            RequestDataCollections::default(),
-        );
+        let data = create_request_data("/api/batch", "POST", body, json!({}), RequestDataCollections::default());
 
         assert!(data.body.is_object());
         assert_eq!(data.body.as_object().unwrap().len(), 100);
@@ -1000,10 +991,10 @@ mod tests {
     #[test]
     fn test_request_data_empty_string_values() {
         let mut headers = HashMap::new();
-        headers.insert("empty-header".to_string(), "".to_string());
+        headers.insert("empty-header".to_string(), String::new());
 
         let mut path_params = HashMap::new();
-        path_params.insert("id".to_string(), "".to_string());
+        path_params.insert("id".to_string(), String::new());
 
         let data = create_request_data(
             "/api/test",
@@ -1017,8 +1008,8 @@ mod tests {
             },
         );
 
-        assert_eq!(data.headers.get("empty-header"), Some(&"".to_string()));
-        assert_eq!(data.path_params.get("id"), Some(&"".to_string()));
+        assert_eq!(data.headers.get("empty-header"), Some(&String::new()));
+        assert_eq!(data.path_params.get("id"), Some(&String::new()));
     }
 
     #[test]
@@ -1092,7 +1083,7 @@ mod tests {
             RequestDataCollections::default(),
         );
 
-        let debug_str = format!("{:?}", data);
+        let debug_str = format!("{data:?}");
         assert!(debug_str.contains("RequestData"));
         assert!(debug_str.contains("/api/test"));
     }

data/vendor/crates/spikard-core/src/router.rs

@@ -278,6 +278,7 @@ mod tests {
             cors: None,
             body_param_name: None,
             jsonrpc_method: None,
+            static_response: None,
             #[cfg(feature = "di")]
             handler_dependencies: None,
         };
@@ -312,6 +313,7 @@ mod tests {
             cors: None,
             body_param_name: None,
             jsonrpc_method: None,
+            static_response: None,
             #[cfg(feature = "di")]
             handler_dependencies: None,
         };
@@ -344,6 +346,7 @@ mod tests {
             cors: None,
             body_param_name: None,
             jsonrpc_method: None,
+            static_response: None,
             #[cfg(feature = "di")]
             handler_dependencies: None,
         };
@@ -360,6 +363,7 @@ mod tests {
             cors: None,
             body_param_name: None,
             jsonrpc_method: None,
+            static_response: None,
             #[cfg(feature = "di")]
             handler_dependencies: None,
         };
@@ -438,6 +442,7 @@ mod tests {
             cors: None,
             body_param_name: None,
             jsonrpc_method: None,
+            static_response: None,
             #[cfg(feature = "di")]
             handler_dependencies: None,
         };
@@ -511,6 +516,7 @@ mod tests {
             cors: None,
             body_param_name: None,
             jsonrpc_method: None,
+            static_response: None,
             #[cfg(feature = "di")]
             handler_dependencies: None,
         };