spikard 0.8.2 → 0.8.3

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

@@ -88,6 +88,9 @@ impl ResolvedDependencies {
     /// let config = Arc::new("production".to_string());
     /// resolved.insert("config".to_string(), config);
     /// ```
+    ///
+    /// # Panics
+    /// Panics if the lock is poisoned.
     pub fn insert(&mut self, key: String, value: Arc<dyn Any + Send + Sync>) {
         self.dependencies.lock().unwrap().insert(key, value);
     }
@@ -126,6 +129,10 @@ impl ResolvedDependencies {
     /// let missing: Option<Arc<i32>> = resolved.get("missing");
     /// assert!(missing.is_none());
     /// ```
+    ///
+    /// # Panics
+    /// Panics if the lock is poisoned.
+    #[must_use]
     pub fn get<T: Send + Sync + 'static>(&self, key: &str) -> Option<Arc<T>> {
         self.dependencies
             .lock()
@@ -155,6 +162,10 @@ impl ResolvedDependencies {
     /// let any_ref = resolved.get_arc("data");
     /// assert!(any_ref.is_some());
     /// ```
+    ///
+    /// # Panics
+    /// Panics if the lock is poisoned.
+    #[must_use]
     pub fn get_arc(&self, key: &str) -> Option<Arc<dyn Any + Send + Sync>> {
         self.dependencies.lock().unwrap().get(key).cloned()
     }
@@ -177,6 +188,9 @@ impl ResolvedDependencies {
     /// assert!(resolved.contains("exists"));
     /// assert!(!resolved.contains("missing"));
     /// ```
+    ///
+    /// # Panics
+    /// Panics if the lock is poisoned.
     #[must_use]
     pub fn contains(&self, key: &str) -> bool {
         self.dependencies.lock().unwrap().contains_key(key)
@@ -202,6 +216,9 @@ impl ResolvedDependencies {
     /// assert!(keys.contains(&"config".to_string()));
     /// assert!(keys.contains(&"db".to_string()));
     /// ```
+    ///
+    /// # Panics
+    /// Panics if the lock is poisoned.
     #[must_use]
     pub fn keys(&self) -> Vec<String> {
         self.dependencies.lock().unwrap().keys().cloned().collect()
@@ -233,6 +250,9 @@ impl ResolvedDependencies {
     /// resolved.cleanup().await;
     /// # });
     /// ```
+    ///
+    /// # Panics
+    /// Panics if the lock is poisoned.
     pub fn add_cleanup_task(&self, task: CleanupTask) {
         self.cleanup_tasks.lock().unwrap().push(task);
     }
@@ -275,6 +295,9 @@ impl ResolvedDependencies {
     /// assert_eq!(*order.lock().unwrap(), vec![2, 1]);
     /// # });
     /// ```
+    ///
+    /// # Panics
+    /// Panics if the lock is poisoned.
     pub async fn cleanup(self) {
         let tasks = {
             let mut cleanup_tasks = self.cleanup_tasks.lock().unwrap();

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

@@ -134,6 +134,7 @@ impl<T: Clone + Send + Sync + 'static> std::fmt::Debug for ValueDependency<T> {
         f.debug_struct("ValueDependency")
             .field("key", &self.key)
             .field("value_type", &std::any::type_name::<T>())
+            .field("value", &"<T>")
             .finish()
     }
 }

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

@@ -31,6 +31,9 @@ impl StructuredError {
 }
 
 /// Catch panics and convert to a structured error so they don't cross FFI boundaries.
+///
+/// # Errors
+/// Returns a structured error if a panic occurs during function execution.
 pub fn shield_panic<T, F>(f: F) -> Result<T, StructuredError>
 where
     F: FnOnce() -> T + UnwindSafe,

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

@@ -15,16 +15,17 @@ pub enum Method {
 }
 
 impl Method {
-    pub fn as_str(&self) -> &'static str {
+    #[must_use]
+    pub const fn as_str(&self) -> &'static str {
         match self {
-            Method::Get => "GET",
-            Method::Post => "POST",
-            Method::Put => "PUT",
-            Method::Patch => "PATCH",
-            Method::Delete => "DELETE",
-            Method::Head => "HEAD",
-            Method::Options => "OPTIONS",
-            Method::Trace => "TRACE",
+            Self::Get => "GET",
+            Self::Post => "POST",
+            Self::Put => "PUT",
+            Self::Patch => "PATCH",
+            Self::Delete => "DELETE",
+            Self::Head => "HEAD",
+            Self::Options => "OPTIONS",
+            Self::Trace => "TRACE",
         }
     }
 }
@@ -40,15 +41,15 @@ impl std::str::FromStr for Method {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s.to_uppercase().as_str() {
-            "GET" => Ok(Method::Get),
-            "POST" => Ok(Method::Post),
-            "PUT" => Ok(Method::Put),
-            "PATCH" => Ok(Method::Patch),
-            "DELETE" => Ok(Method::Delete),
-            "HEAD" => Ok(Method::Head),
-            "OPTIONS" => Ok(Method::Options),
-            "TRACE" => Ok(Method::Trace),
-            _ => Err(format!("Unknown HTTP method: {}", s)),
+            "GET" => Ok(Self::Get),
+            "POST" => Ok(Self::Post),
+            "PUT" => Ok(Self::Put),
+            "PATCH" => Ok(Self::Patch),
+            "DELETE" => Ok(Self::Delete),
+            "HEAD" => Ok(Self::Head),
+            "OPTIONS" => Ok(Self::Options),
+            "TRACE" => Ok(Self::Trace),
+            _ => Err(format!("Unknown HTTP method: {s}")),
         }
     }
 }

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

@@ -29,10 +29,10 @@ pub trait NativeLifecycleHook<Req, Resp>: Send + Sync {
     fn name(&self) -> &str;
 
     /// Execute hook with a request
-    fn execute_request<'a>(&'a self, req: Req) -> RequestHookFutureSend<'a, Req, Resp>;
+    fn execute_request<'a>(&self, req: Req) -> RequestHookFutureSend<'a, Req, Resp>;
 
     /// Execute hook with a response
-    fn execute_response<'a>(&'a self, resp: Resp) -> ResponseHookFutureSend<'a, Resp>;
+    fn execute_response<'a>(&self, resp: Resp) -> ResponseHookFutureSend<'a, Resp>;
 }
 
 /// Trait for lifecycle hooks on local (wasm) targets (no Send requirements).
@@ -41,10 +41,10 @@ pub trait LocalLifecycleHook<Req, Resp> {
     fn name(&self) -> &str;
 
     /// Execute hook with a request
-    fn execute_request<'a>(&'a self, req: Req) -> RequestHookFutureLocal<'a, Req, Resp>;
+    fn execute_request<'a>(&self, req: Req) -> RequestHookFutureLocal<'a, Req, Resp>;
 
     /// Execute hook with a response
-    fn execute_response<'a>(&'a self, resp: Resp) -> ResponseHookFutureLocal<'a, Resp>;
+    fn execute_response<'a>(&self, resp: Resp) -> ResponseHookFutureLocal<'a, Resp>;
 }
 
 #[cfg(target_arch = "wasm32")]
@@ -97,17 +97,19 @@ impl<Req, Resp> std::fmt::Debug for LifecycleHooks<Req, Resp> {
 
 impl<Req, Resp> LifecycleHooks<Req, Resp> {
     /// Create a new empty hooks container
+    #[must_use]
     pub fn new() -> Self {
         Self::default()
     }
 
     /// Builder constructor for ergonomic hook registration
+    #[must_use]
     pub fn builder() -> LifecycleHooksBuilder<Req, Resp> {
         LifecycleHooksBuilder::new()
     }
 
     /// Check if any hooks are registered
-    #[inline(always)]
+    #[must_use]
     pub fn is_empty(&self) -> bool {
         self.on_request.is_empty()
             && self.pre_validation.is_empty()
@@ -136,6 +138,8 @@ impl<Req, Resp> LifecycleHooks<Req, Resp> {
         self.on_error.push(hook);
     }
 
+    /// # Errors
+    /// Returns an error string if a hook execution fails.
     pub async fn execute_on_request(&self, mut req: Req) -> Result<HookResult<Req, Resp>, String> {
         if self.on_request.is_empty() {
             return Ok(HookResult::Continue(req));
@@ -151,6 +155,8 @@ impl<Req, Resp> LifecycleHooks<Req, Resp> {
         Ok(HookResult::Continue(req))
     }
 
+    /// # Errors
+    /// Returns an error string if a hook execution fails.
     pub async fn execute_pre_validation(&self, mut req: Req) -> Result<HookResult<Req, Resp>, String> {
         if self.pre_validation.is_empty() {
             return Ok(HookResult::Continue(req));
@@ -166,6 +172,8 @@ impl<Req, Resp> LifecycleHooks<Req, Resp> {
         Ok(HookResult::Continue(req))
     }
 
+    /// # Errors
+    /// Returns an error string if a hook execution fails.
     pub async fn execute_pre_handler(&self, mut req: Req) -> Result<HookResult<Req, Resp>, String> {
         if self.pre_handler.is_empty() {
             return Ok(HookResult::Continue(req));
@@ -181,6 +189,8 @@ impl<Req, Resp> LifecycleHooks<Req, Resp> {
         Ok(HookResult::Continue(req))
     }
 
+    /// # Errors
+    /// Returns an error string if a hook execution fails.
     pub async fn execute_on_response(&self, mut resp: Resp) -> Result<Resp, String> {
         if self.on_response.is_empty() {
             return Ok(resp);
@@ -188,14 +198,15 @@ impl<Req, Resp> LifecycleHooks<Req, Resp> {
 
         for hook in &self.on_response {
             match hook.execute_response(resp).await? {
-                HookResult::Continue(r) => resp = r,
-                HookResult::ShortCircuit(r) => resp = r,
+                HookResult::Continue(r) | HookResult::ShortCircuit(r) => resp = r,
             }
         }
 
         Ok(resp)
     }
 
+    /// # Errors
+    /// Returns an error string if a hook execution fails.
     pub async fn execute_on_error(&self, mut resp: Resp) -> Result<Resp, String> {
         if self.on_error.is_empty() {
             return Ok(resp);
@@ -203,8 +214,7 @@ impl<Req, Resp> LifecycleHooks<Req, Resp> {
 
         for hook in &self.on_error {
             match hook.execute_response(resp).await? {
-                HookResult::Continue(r) => resp = r,
-                HookResult::ShortCircuit(r) => resp = r,
+                HookResult::Continue(r) | HookResult::ShortCircuit(r) => resp = r,
             }
         }
 
@@ -237,11 +247,11 @@ where
         &self.name
     }
 
-    fn execute_request<'a>(&'a self, req: Req) -> RequestHookFutureSend<'a, Req, Resp> {
+    fn execute_request<'a>(&self, req: Req) -> RequestHookFutureSend<'a, Req, Resp> {
         Box::pin((self.func)(req))
     }
 
-    fn execute_response<'a>(&'a self, _resp: Resp) -> ResponseHookFutureSend<'a, Resp> {
+    fn execute_response<'a>(&self, _resp: Resp) -> ResponseHookFutureSend<'a, Resp> {
         Box::pin(async move { Err("Request hook called with response - this is a bug".to_string()) })
     }
 }
@@ -258,11 +268,11 @@ where
         &self.name
     }
 
-    fn execute_request<'a>(&'a self, req: Req) -> RequestHookFutureLocal<'a, Req, Resp> {
+    fn execute_request<'a>(&self, req: Req) -> RequestHookFutureLocal<'a, Req, Resp> {
         Box::pin((self.func)(req))
     }
 
-    fn execute_response<'a>(&'a self, _resp: Resp) -> ResponseHookFutureLocal<'a, Resp> {
+    fn execute_response<'a>(&self, _resp: Resp) -> ResponseHookFutureLocal<'a, Resp> {
         Box::pin(async move { Err("Request hook called with response - this is a bug".to_string()) })
     }
 }
@@ -279,11 +289,11 @@ where
         &self.name
     }
 
-    fn execute_request<'a>(&'a self, _req: Req) -> RequestHookFutureSend<'a, Req, Resp> {
+    fn execute_request<'a>(&self, _req: Req) -> RequestHookFutureSend<'a, Req, Resp> {
         Box::pin(async move { Err("Response hook called with request - this is a bug".to_string()) })
     }
 
-    fn execute_response<'a>(&'a self, resp: Resp) -> ResponseHookFutureSend<'a, Resp> {
+    fn execute_response<'a>(&self, resp: Resp) -> ResponseHookFutureSend<'a, Resp> {
         Box::pin((self.func)(resp))
     }
 }
@@ -300,52 +310,66 @@ where
         &self.name
     }
 
-    fn execute_request<'a>(&'a self, _req: Req) -> RequestHookFutureLocal<'a, Req, Resp> {
+    fn execute_request<'a>(&self, _req: Req) -> RequestHookFutureLocal<'a, Req, Resp> {
         Box::pin(async move { Err("Response hook called with request - this is a bug".to_string()) })
     }
 
-    fn execute_response<'a>(&'a self, resp: Resp) -> ResponseHookFutureLocal<'a, Resp> {
+    fn execute_response<'a>(&self, resp: Resp) -> ResponseHookFutureLocal<'a, Resp> {
         Box::pin((self.func)(resp))
     }
 }
 
-/// Builder Pattern for LifecycleHooks
+/// Builder pattern for `LifecycleHooks`
 pub struct LifecycleHooksBuilder<Req, Resp> {
     hooks: LifecycleHooks<Req, Resp>,
 }
 
 impl<Req, Resp> LifecycleHooksBuilder<Req, Resp> {
+    /// Create a new builder
+    #[must_use]
     pub fn new() -> Self {
         Self {
             hooks: LifecycleHooks::default(),
         }
     }
 
+    /// Add an `on_request` hook
+    #[must_use]
     pub fn on_request(mut self, hook: Arc<CoreHook<Req, Resp>>) -> Self {
         self.hooks.add_on_request(hook);
         self
     }
 
+    /// Add a `pre_validation` hook
+    #[must_use]
     pub fn pre_validation(mut self, hook: Arc<CoreHook<Req, Resp>>) -> Self {
         self.hooks.add_pre_validation(hook);
         self
     }
 
+    /// Add a `pre_handler` hook
+    #[must_use]
     pub fn pre_handler(mut self, hook: Arc<CoreHook<Req, Resp>>) -> Self {
         self.hooks.add_pre_handler(hook);
         self
     }
 
+    /// Add an `on_response` hook
+    #[must_use]
     pub fn on_response(mut self, hook: Arc<CoreHook<Req, Resp>>) -> Self {
         self.hooks.add_on_response(hook);
         self
     }
 
+    /// Add an `on_error` hook
+    #[must_use]
     pub fn on_error(mut self, hook: Arc<CoreHook<Req, Resp>>) -> Self {
         self.hooks.add_on_error(hook);
         self
     }
 
+    /// Build the `LifecycleHooks` instance
+    #[must_use]
     pub fn build(self) -> LifecycleHooks<Req, Resp> {
         self.hooks
     }

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

@@ -69,6 +69,9 @@ impl ParameterValidator {
     ///
     /// The schema should describe all parameters with their types and constraints.
     /// Each property MUST have a "source" field indicating where the parameter comes from.
+    ///
+    /// # Errors
+    /// Returns an error if the schema is invalid or malformed.
     pub fn new(schema: Value) -> Result<Self, String> {
         let parameter_defs = Self::extract_parameter_defs(&schema)?;
         let validation_schema = Self::create_validation_schema(&schema);
@@ -88,6 +91,7 @@ impl ParameterValidator {
     }
 
     /// Whether this validator needs access to request headers.
+    #[must_use]
     pub fn requires_headers(&self) -> bool {
         self.inner
             .parameter_defs
@@ -96,6 +100,7 @@ impl ParameterValidator {
     }
 
     /// Whether this validator needs access to request cookies.
+    #[must_use]
     pub fn requires_cookies(&self) -> bool {
         self.inner
             .parameter_defs
@@ -104,6 +109,7 @@ impl ParameterValidator {
     }
 
     /// Whether the validator has any parameter definitions.
+    #[must_use]
     pub fn has_params(&self) -> bool {
         !self.inner.parameter_defs.is_empty()
     }
@@ -125,12 +131,22 @@ impl ParameterValidator {
 
             for (key, child) in obj {
                 match key.as_str() {
-                    // Structural keywords we support in the coercion pass.
-                    "type" | "format" | "properties" | "required" | "items" | "additionalProperties" => {}
-
-                    // Metadata keywords which don't affect validation semantics.
-                    "title" | "description" | "default" | "examples" | "deprecated" | "readOnly" | "writeOnly"
-                    | "$schema" | "$id" => {}
+                    // Structural keywords we support in the coercion pass, and metadata keywords.
+                    "type"
+                    | "format"
+                    | "properties"
+                    | "required"
+                    | "items"
+                    | "additionalProperties"
+                    | "title"
+                    | "description"
+                    | "default"
+                    | "examples"
+                    | "deprecated"
+                    | "readOnly"
+                    | "writeOnly"
+                    | "$schema"
+                    | "$id" => {}
 
                     // Anything else may impose constraints we don't enforce manually.
                     _ => return true,
@@ -166,15 +182,14 @@ impl ParameterValidator {
         for (name, prop) in properties {
             let source_str = prop.get("source").and_then(|s| s.as_str()).ok_or_else(|| {
                 anyhow::anyhow!("Invalid parameter schema")
-                    .context(format!("Parameter '{}' missing required 'source' field", name))
+                    .context(format!("Parameter '{name}' missing required 'source' field"))
                     .to_string()
             })?;
 
             let source = ParameterSource::from_str(source_str).ok_or_else(|| {
                 anyhow::anyhow!("Invalid parameter schema")
                     .context(format!(
-                        "Invalid source '{}' for parameter '{}' (expected: query, path, header, or cookie)",
-                        source_str, name
+                        "Invalid source '{source_str}' for parameter '{name}' (expected: query, path, header, or cookie)"
                     ))
                     .to_string()
             })?;
@@ -182,7 +197,10 @@ impl ParameterValidator {
             let expected_type = prop.get("type").and_then(|t| t.as_str()).map(String::from);
             let format = prop.get("format").and_then(|f| f.as_str()).map(String::from);
 
-            let is_optional = prop.get("optional").and_then(|v| v.as_bool()).unwrap_or(false);
+            let is_optional = prop
+                .get("optional")
+                .and_then(serde_json::Value::as_bool)
+                .unwrap_or(false);
             let required = required_list.contains(&name.as_str()) && !is_optional;
 
             let (lookup_key, error_key) = if source == ParameterSource::Header {
@@ -207,6 +225,7 @@ impl ParameterValidator {
     }
 
     /// Get the underlying JSON Schema
+    #[must_use]
     pub fn schema(&self) -> &Value {
         &self.inner.schema
     }
@@ -217,6 +236,10 @@ impl ParameterValidator {
     /// It performs type coercion (e.g., "123" → 123) based on the schema.
     ///
     /// Returns the validated JSON object that can be directly converted to Python kwargs.
+    ///
+    /// # Errors
+    /// Returns a validation error if parameter validation fails.
+    #[allow(clippy::too_many_lines)]
     pub fn validate_and_extract(
         &self,
         query_params: &Value,
@@ -279,11 +302,11 @@ impl ParameterValidator {
                                             "Input should be a valid boolean, unable to interpret input".to_string()
                                         }
                                         Some("string") => match item_format {
-                                            Some("uuid") => format!("Input should be a valid UUID, {}", e),
-                                            Some("date") => format!("Input should be a valid date, {}", e),
-                                            Some("date-time") => format!("Input should be a valid datetime, {}", e),
-                                            Some("time") => format!("Input should be a valid time, {}", e),
-                                            Some("duration") => format!("Input should be a valid duration, {}", e),
+                                            Some("uuid") => format!("Input should be a valid UUID, {e}"),
+                                            Some("date") => format!("Input should be a valid date, {e}"),
+                                            Some("date-time") => format!("Input should be a valid datetime, {e}"),
+                                            Some("time") => format!("Input should be a valid time, {e}"),
+                                            Some("duration") => format!("Input should be a valid duration, {e}"),
                                             _ => e,
                                         },
                                         _ => e,
@@ -303,6 +326,7 @@ impl ParameterValidator {
                     };
                     let (item_type, item_format) = self.array_item_type_and_format(&param_def.name);
 
+                    #[allow(clippy::option_if_let_else)]
                     let coerced_items = match array_value.as_array() {
                         Some(items) => {
                             let mut out = Vec::with_capacity(items.len());
@@ -332,11 +356,11 @@ impl ParameterValidator {
                                                     Some("number") => "Input should be a valid number, unable to parse string as a number".to_string(),
                                                     Some("boolean") => "Input should be a valid boolean, unable to interpret input".to_string(),
                                                     Some("string") => match item_format {
-                                                        Some("uuid") => format!("Input should be a valid UUID, {}", e),
-                                                        Some("date") => format!("Input should be a valid date, {}", e),
-                                                        Some("date-time") => format!("Input should be a valid datetime, {}", e),
-                                                        Some("time") => format!("Input should be a valid time, {}", e),
-                                                        Some("duration") => format!("Input should be a valid duration, {}", e),
+                                                        Some("uuid") => format!("Input should be a valid UUID, {e}"),
+                                                        Some("date") => format!("Input should be a valid date, {e}"),
+                                                        Some("date-time") => format!("Input should be a valid datetime, {e}"),
+                                                        Some("time") => format!("Input should be a valid time, {e}"),
+                                                        Some("duration") => format!("Input should be a valid duration, {e}"),
                                                         _ => e.clone(),
                                                     },
                                                     _ => e.clone(),
@@ -410,19 +434,19 @@ impl ParameterValidator {
                                     "Input should be a valid boolean, unable to interpret input".to_string(),
                                 ),
                                 (Some("string"), Some("uuid")) => {
-                                    ("uuid_parsing", format!("Input should be a valid UUID, {}", e))
+                                    ("uuid_parsing", format!("Input should be a valid UUID, {e}"))
                                 }
                                 (Some("string"), Some("date")) => {
-                                    ("date_parsing", format!("Input should be a valid date, {}", e))
+                                    ("date_parsing", format!("Input should be a valid date, {e}"))
                                 }
                                 (Some("string"), Some("date-time")) => {
-                                    ("datetime_parsing", format!("Input should be a valid datetime, {}", e))
+                                    ("datetime_parsing", format!("Input should be a valid datetime, {e}"))
                                 }
                                 (Some("string"), Some("time")) => {
-                                    ("time_parsing", format!("Input should be a valid time, {}", e))
+                                    ("time_parsing", format!("Input should be a valid time, {e}"))
                                 }
                                 (Some("string"), Some("duration")) => {
-                                    ("duration_parsing", format!("Input should be a valid duration, {}", e))
+                                    ("duration_parsing", format!("Input should be a valid duration, {e}"))
                                 }
                                 _ => ("type_error", e),
                             };
@@ -445,7 +469,7 @@ impl ParameterValidator {
         let params_json = Value::Object(params_map);
         if let Some(schema_validator) = &self.inner.schema_validator {
             match schema_validator.validate(&params_json) {
-                Ok(_) => Ok(params_json),
+                Ok(()) => Ok(params_json),
                 Err(mut validation_err) => {
                     for error in &mut validation_err.errors {
                         if error.loc.len() >= 2 && error.loc[0] == "body" {
@@ -459,7 +483,7 @@ impl ParameterValidator {
                                 };
                                 error.loc[0] = source_str.to_string();
                                 if param_def.source == ParameterSource::Header {
-                                    error.loc[1] = param_def.error_key.clone();
+                                    error.loc[1].clone_from(&param_def.error_key);
                                 }
                                 if let Some(raw_value) =
                                     self.raw_value_for_error(param_def, raw_query_params, path_params, headers, cookies)
@@ -477,6 +501,7 @@ impl ParameterValidator {
         }
     }
 
+    #[allow(clippy::unused_self)]
     fn raw_value_for_error<'a>(
         &self,
         param_def: &ParameterDef,
@@ -485,6 +510,7 @@ impl ParameterValidator {
         headers: &'a HashMap<String, String>,
         cookies: &'a HashMap<String, String>,
     ) -> Option<&'a str> {
+        #[allow(clippy::too_many_arguments)]
         match param_def.source {
             ParameterSource::Query => raw_query_params
                 .get(&param_def.lookup_key)
@@ -548,11 +574,11 @@ impl ParameterValidator {
             Some("integer") => value
                 .parse::<i64>()
                 .map(|i| json!(i))
-                .map_err(|e| format!("Invalid integer: {}", e)),
+                .map_err(|e| format!("Invalid integer: {e}")),
             Some("number") => value
                 .parse::<f64>()
                 .map(|f| json!(f))
-                .map_err(|e| format!("Invalid number: {}", e)),
+                .map_err(|e| format!("Invalid number: {e}")),
             Some("boolean") => {
                 if value.is_empty() {
                     return Ok(json!(false));
@@ -563,7 +589,7 @@ impl ParameterValidator {
                 } else if value_lower == "false" || value == "0" {
                     Ok(json!(false))
                 } else {
-                    Err(format!("Invalid boolean: {}", value))
+                    Err(format!("Invalid boolean: {value}"))
                 }
             }
             _ => Ok(json!(value)),
@@ -574,7 +600,7 @@ impl ParameterValidator {
     fn validate_date_format(value: &str) -> Result<(), String> {
         jiff::civil::Date::strptime("%Y-%m-%d", value)
             .map(|_| ())
-            .map_err(|e| format!("Invalid date format: {}", e))
+            .map_err(|e| format!("Invalid date format: {e}"))
     }
 
     /// Validate ISO 8601 datetime format
@@ -582,7 +608,7 @@ impl ParameterValidator {
         use std::str::FromStr;
         jiff::Timestamp::from_str(value)
             .map(|_| ())
-            .map_err(|e| format!("Invalid datetime format: {}", e))
+            .map_err(|e| format!("Invalid datetime format: {e}"))
     }
 
     /// Validate ISO 8601 time format: HH:MM:SS or HH:MM:SS.ffffff
@@ -608,7 +634,7 @@ impl ParameterValidator {
         };
 
         let base_time = time_part.split('.').next().unwrap_or(time_part);
-        jiff::civil::Time::strptime("%H:%M:%S", base_time).map_err(|e| format!("Invalid time format: {}", e))?;
+        jiff::civil::Time::strptime("%H:%M:%S", base_time).map_err(|e| format!("Invalid time format: {e}"))?;
 
         if let Some((_, frac)) = time_part.split_once('.')
             && (frac.is_empty() || frac.len() > 9 || !frac.chars().all(|c| c.is_ascii_digit()))
@@ -648,7 +674,7 @@ impl ParameterValidator {
         use std::str::FromStr;
         jiff::Span::from_str(value)
             .map(|_| ())
-            .map_err(|e| format!("Invalid duration format: {}", e))
+            .map_err(|e| format!("Invalid duration format: {e}"))
     }
 
     /// Validate UUID format
@@ -671,7 +697,7 @@ impl ParameterValidator {
             for (name, prop) in properties.iter_mut() {
                 if let Some(obj) = prop.as_object_mut() {
                     obj.remove("source");
-                    if obj.get("optional").and_then(|v| v.as_bool()) == Some(true) {
+                    if obj.get("optional").and_then(serde_json::Value::as_bool) == Some(true) {
                         optional_fields.push(name.clone());
                     }
                     obj.remove("optional");