spikard 0.8.1 → 0.8.3

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");

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

@@ -82,7 +82,8 @@ impl ProblemDetails {
     /// Standard type URI for bad request (400)
     pub const TYPE_BAD_REQUEST: &'static str = "https://spikard.dev/errors/bad-request";
 
-    /// Create a new ProblemDetails with required fields
+    /// Create a new `ProblemDetails` with required fields
+    #[must_use]
     pub fn new(type_uri: impl Into<String>, title: impl Into<String>, status: StatusCode) -> Self {
         Self {
             type_uri: type_uri.into(),
@@ -95,24 +96,29 @@ impl ProblemDetails {
     }
 
     /// Set the detail field
+    #[must_use]
     pub fn with_detail(mut self, detail: impl Into<String>) -> Self {
         self.detail = Some(detail.into());
         self
     }
 
     /// Set the instance field
+    #[must_use]
     pub fn with_instance(mut self, instance: impl Into<String>) -> Self {
         self.instance = Some(instance.into());
         self
     }
 
     /// Add an extension field
+    #[must_use]
     pub fn with_extension(mut self, key: impl Into<String>, value: Value) -> Self {
         self.extensions.insert(key.into(), value);
         self
     }
 
     /// Add all extensions from a JSON object
+    #[must_use]
+    #[allow(clippy::needless_pass_by_value)]
     pub fn with_extensions(mut self, extensions: Value) -> Self {
         if let Some(obj) = extensions.as_object() {
             for (key, value) in obj {
@@ -122,20 +128,21 @@ impl ProblemDetails {
         self
     }
 
-    /// Create a validation error Problem Details from ValidationError
+    /// Create a validation error Problem Details from `ValidationError`
     ///
     /// This converts the FastAPI-style validation errors to RFC 9457 format:
-    /// - `type`: "https://spikard.dev/errors/validation-error"
+    /// - `type`: <https://spikard.dev/errors/validation-error>
     /// - `title`: "Request Validation Failed"
     /// - `status`: 422
     /// - `detail`: Summary of error count
     /// - `errors`: Array of validation error details (as extension field)
+    #[must_use]
     pub fn from_validation_error(error: &ValidationError) -> Self {
         let error_count = error.errors.len();
         let detail = if error_count == 1 {
             "1 validation error in request".to_string()
         } else {
-            format!("{} validation errors in request", error_count)
+            format!("{error_count} validation errors in request")
         };
 
         let errors_json = serde_json::to_value(&error.errors).unwrap_or_else(|_| serde_json::Value::Array(vec![]));
@@ -201,16 +208,23 @@ impl ProblemDetails {
     }
 
     /// Get the HTTP status code
+    #[must_use]
     pub fn status_code(&self) -> StatusCode {
         StatusCode::from_u16(self.status).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR)
     }
 
     /// Serialize to JSON string
+    ///
+    /// # Errors
+    /// Returns an error if the serialization fails.
     pub fn to_json(&self) -> Result<String, serde_json::Error> {
         serde_json::to_string(self)
     }
 
     /// Serialize to pretty JSON string
+    ///
+    /// # Errors
+    /// Returns an error if the serialization fails.
     pub fn to_json_pretty(&self) -> Result<String, serde_json::Error> {
         serde_json::to_string_pretty(self)
     }

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

@@ -17,19 +17,19 @@ use bytes::Bytes;
 ///
 /// This is the language-agnostic representation passed to handlers.
 ///
-/// Uses Arc for HashMaps to enable cheap cloning without duplicating data.
-/// When RequestData is cloned, only the Arc pointers are cloned, not the underlying data.
+/// Uses `Arc` for `HashMap`s to enable cheap cloning without duplicating data.
+/// When `RequestData` is cloned, only the `Arc` pointers are cloned, not the underlying data.
 ///
-/// Performance optimization: raw_body stores the unparsed request body bytes.
-/// Language bindings should use raw_body when possible to avoid double-parsing.
-/// The body field is lazily parsed only when needed for validation.
+/// Performance optimization: `raw_body` stores the unparsed request body bytes.
+/// Language bindings should use `raw_body` when possible to avoid double-parsing.
+/// The `body` field is lazily parsed only when needed for validation.
 #[derive(Debug, Clone)]
 pub struct RequestData {
     /// Path parameters extracted from the URL path
     pub path_params: Arc<HashMap<String, String>>,
     /// Query parameters parsed as JSON
     pub query_params: Value,
-    /// Validated parameters produced by ParameterValidator (query/path/header/cookie combined).
+    /// Validated parameters produced by `ParameterValidator` (query/path/header/cookie combined).
     pub validated_params: Option<Value>,
     /// Raw query parameters as key-value pairs
     pub raw_query_params: Arc<HashMap<String, Vec<String>>>,
@@ -66,7 +66,7 @@ impl Serialize for RequestData {
         state.serialize_field("raw_query_params", &*self.raw_query_params)?;
         state.serialize_field("body", &self.body)?;
         #[cfg(feature = "di")]
-        state.serialize_field("raw_body", &self.raw_body.as_ref().map(|b| b.as_ref()))?;
+        state.serialize_field("raw_body", &self.raw_body.as_ref().map(AsRef::as_ref))?;
         #[cfg(not(feature = "di"))]
         state.serialize_field("raw_body", &self.raw_body)?;
         state.serialize_field("headers", &*self.headers)?;
@@ -78,6 +78,7 @@ impl Serialize for RequestData {
 }
 
 impl<'de> Deserialize<'de> for RequestData {
+    #[allow(clippy::too_many_lines)]
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
@@ -933,7 +934,7 @@ mod tests {
             "float": 3.2,
             "negative": -100,
             "zero": 0,
-            "large": 9223372036854775807i64
+            "large": 9_223_372_036_854_775_807i64
         });
 
         let data = create_request_data(

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

@@ -70,8 +70,8 @@ pub struct JsonRpcMethodInfo {
 
 /// Route definition with compiled validators
 ///
-/// Validators are Arc-wrapped to enable cheap cloning across route instances
-/// and to support schema deduplication via SchemaRegistry.
+/// Validators are `Arc`-wrapped to enable cheap cloning across route instances
+/// and to support schema deduplication via `SchemaRegistry`.
 ///
 /// The `jsonrpc_method` field is optional and has zero overhead when None,
 /// enabling routes to optionally expose themselves as JSON-RPC methods.
@@ -102,10 +102,14 @@ impl Route {
     ///
     /// Auto-generates parameter schema from type hints in the path if no explicit schema provided.
     /// Type hints like `/items/{id:uuid}` generate appropriate JSON Schema validation.
-    /// Explicit parameter_schema overrides auto-generated schemas.
+    /// Explicit `parameter_schema` overrides auto-generated schemas.
+    ///
+    /// # Errors
+    /// Returns an error if the schema compilation fails or metadata is invalid.
     ///
     /// The schema registry ensures each unique schema is compiled only once, improving
     /// startup performance and memory usage for applications with many routes.
+    #[allow(clippy::items_after_statements)]
     pub fn from_metadata(metadata: RouteMetadata, registry: &SchemaRegistry) -> Result<Self, String> {
         let method = metadata.method.parse()?;
 
@@ -135,7 +139,10 @@ impl Route {
                 if is_empty_schema(&explicit_schema) {
                     Some(auto_schema)
                 } else {
-                    Some(crate::type_hints::merge_parameter_schemas(auto_schema, explicit_schema))
+                    Some(crate::type_hints::merge_parameter_schemas(
+                        &auto_schema,
+                        &explicit_schema,
+                    ))
                 }
             }
             (Some(auto_schema), None) => Some(auto_schema),
@@ -187,17 +194,20 @@ impl Route {
     ///         tags: vec!["users".to_string()],
     ///     });
     /// ```
+    #[must_use]
     pub fn with_jsonrpc_method(mut self, info: JsonRpcMethodInfo) -> Self {
         self.jsonrpc_method = Some(info);
         self
     }
 
     /// Check if this route has JSON-RPC metadata
-    pub fn is_jsonrpc_method(&self) -> bool {
+    #[must_use]
+    pub const fn is_jsonrpc_method(&self) -> bool {
         self.jsonrpc_method.is_some()
     }
 
     /// Get the JSON-RPC method name if present
+    #[must_use]
     pub fn jsonrpc_method_name(&self) -> Option<&str> {
         self.jsonrpc_method.as_ref().map(|m| m.method_name.as_str())
     }
@@ -210,6 +220,7 @@ pub struct Router {
 
 impl Router {
     /// Create a new router
+    #[must_use]
     pub fn new() -> Self {
         Self { routes: HashMap::new() }
     }
@@ -221,18 +232,21 @@ impl Router {
     }
 
     /// Find a route by method and path
+    #[must_use]
     pub fn find_route(&self, method: &Method, path: &str) -> Option<&Route> {
         self.routes.get(path)?.get(method)
     }
 
     /// Get all routes
+    #[must_use]
     pub fn routes(&self) -> Vec<&Route> {
         self.routes.values().flat_map(|methods| methods.values()).collect()
     }
 
     /// Get route count
+    #[must_use]
     pub fn route_count(&self) -> usize {
-        self.routes.values().map(|m| m.len()).sum()
+        self.routes.values().map(std::collections::HashMap::len).sum()
     }
 }
 

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

@@ -1,9 +1,9 @@
-//! Schema registry for deduplication and OpenAPI generation
+//! Schema registry for deduplication and `OpenAPI` generation
 //!
 //! This module provides a global registry that compiles JSON schemas once at application
 //! startup and reuses them across all routes. This enables:
 //! - Schema deduplication (same schema used by multiple routes)
-//! - OpenAPI spec generation (access to all schemas)
+//! - `OpenAPI` spec generation (access to all schemas)
 //! - Memory efficiency (one compiled validator per unique schema)
 
 use crate::validation::SchemaValidator;
@@ -14,7 +14,7 @@ use std::sync::{Arc, RwLock};
 /// Global schema registry for compiled validators
 ///
 /// Thread-safe registry that ensures each unique schema is compiled exactly once.
-/// Uses RwLock for concurrent read access with occasional writes during startup.
+/// Uses `RwLock` for concurrent read access with occasional writes during startup.
 pub struct SchemaRegistry {
     /// Map from schema JSON string to compiled validator
     schemas: RwLock<HashMap<String, Arc<SchemaValidator>>>,
@@ -22,13 +22,14 @@ pub struct SchemaRegistry {
 
 impl SchemaRegistry {
     /// Create a new empty schema registry
+    #[must_use]
     pub fn new() -> Self {
         Self {
             schemas: RwLock::new(HashMap::new()),
         }
     }
 
-    /// Get or compile a schema, returning Arc to the compiled validator
+    /// Get or compile a schema, returning `Arc` to the compiled validator
     ///
     /// This method is thread-safe and uses a double-check pattern:
     /// 1. Fast path: Read lock to check if schema exists
@@ -38,9 +39,15 @@ impl SchemaRegistry {
     /// * `schema` - The JSON schema to compile
     ///
     /// # Returns
-    /// Arc-wrapped compiled validator that can be cheaply cloned
+    /// `Arc`-wrapped compiled validator that can be cheaply cloned
+    ///
+    /// # Errors
+    /// Returns an error if schema serialization or compilation fails.
+    ///
+    /// # Panics
+    /// Panics if the read or write lock is poisoned.
     pub fn get_or_compile(&self, schema: &Value) -> Result<Arc<SchemaValidator>, String> {
-        let key = serde_json::to_string(schema).map_err(|e| format!("Failed to serialize schema: {}", e))?;
+        let key = serde_json::to_string(schema).map_err(|e| format!("Failed to serialize schema: {e}"))?;
 
         {
             let schemas = self.schemas.read().unwrap();
@@ -62,10 +69,14 @@ impl SchemaRegistry {
         Ok(validator)
     }
 
-    /// Get all registered schemas (for OpenAPI generation)
+    /// Get all registered schemas (for `OpenAPI` generation)
     ///
     /// Returns a snapshot of all compiled validators.
-    /// Useful for generating OpenAPI specifications from runtime schema information.
+    /// Useful for generating `OpenAPI` specifications from runtime schema information.
+    ///
+    /// # Panics
+    /// Panics if the read lock is poisoned.
+    #[must_use]
     pub fn all_schemas(&self) -> Vec<Arc<SchemaValidator>> {
         let schemas = self.schemas.read().unwrap();
         schemas.values().cloned().collect()
@@ -74,6 +85,10 @@ impl SchemaRegistry {
     /// Get the number of unique schemas registered
     ///
     /// Useful for diagnostics and understanding schema deduplication effectiveness.
+    ///
+    /// # Panics
+    /// Panics if the read lock is poisoned.
+    #[must_use]
     pub fn schema_count(&self) -> usize {
         let schemas = self.schemas.read().unwrap();
         schemas.len()

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

@@ -39,6 +39,10 @@ fn path_type_regex() -> &'static Regex {
 /// assert_eq!(hints.get("id"), Some(&"uuid".to_string()));
 /// assert_eq!(hints.get("tag_id"), Some(&"int".to_string()));
 /// ```
+///
+/// # Panics
+/// Panics if regex capture groups don't contain expected indices.
+#[must_use]
 pub fn parse_type_hints(route_path: &str) -> HashMap<String, String> {
     let mut hints = HashMap::new();
     let re = type_hint_regex();
@@ -66,6 +70,7 @@ pub fn parse_type_hints(route_path: &str) -> HashMap<String, String> {
 /// assert_eq!(strip_type_hints("/items/{id:uuid}"), "/items/{id}");
 /// assert_eq!(strip_type_hints("/files/{path:path}"), "/files/{*path}");
 /// ```
+#[must_use]
 pub fn strip_type_hints(route_path: &str) -> String {
     let path_re = path_type_regex();
     let route_path = path_re.replace_all(route_path, "{*$1}");
@@ -86,6 +91,8 @@ pub fn strip_type_hints(route_path: &str) -> String {
 /// - `date` → `{"type": "string", "format": "date"}`
 /// - `datetime` → `{"type": "string", "format": "date-time"}`
 /// - `path` → `{"type": "string"}` (wildcard capture)
+#[must_use]
+#[allow(clippy::match_same_arms)]
 pub fn type_hint_to_schema(type_hint: &str) -> Value {
     match type_hint {
         "uuid" => json!({
@@ -95,7 +102,7 @@ pub fn type_hint_to_schema(type_hint: &str) -> Value {
         "int" | "integer" => json!({
             "type": "integer"
         }),
-        "str" | "string" => json!({
+        "str" | "string" | "path" => json!({
             "type": "string"
         }),
         "float" | "number" => json!({
@@ -112,9 +119,6 @@ pub fn type_hint_to_schema(type_hint: &str) -> Value {
             "type": "string",
             "format": "date-time"
         }),
-        "path" => json!({
-            "type": "string"
-        }),
         _ => json!({
             "type": "string"
         }),
@@ -145,6 +149,7 @@ pub fn type_hint_to_schema(type_hint: &str) -> Value {
 ///     "required": ["id"]
 /// })));
 /// ```
+#[must_use]
 pub fn auto_generate_parameter_schema(route_path: &str) -> Option<Value> {
     let type_hints = parse_type_hints(route_path);
 
@@ -204,7 +209,8 @@ pub fn auto_generate_parameter_schema(route_path: &str) -> Option<Value> {
 /// let merged = merge_parameter_schemas(auto_schema, explicit_schema);
 /// // Result: auto-generated id + explicit count with constraints
 /// ```
-pub fn merge_parameter_schemas(auto_schema: Value, explicit_schema: Value) -> Value {
+#[must_use]
+pub fn merge_parameter_schemas(auto_schema: &Value, explicit_schema: &Value) -> Value {
     let mut result = auto_schema.clone();
 
     let auto_props = result.get_mut("properties").and_then(|v| v.as_object_mut());