spikard 0.8.1 → 0.8.3

data/vendor/crates/spikard-core/src/validation/error_mapper.rs

@@ -51,31 +51,35 @@ pub enum ErrorCondition {
 
 impl ErrorCondition {
     /// Determine the error condition from schema path and error message
+    #[must_use]
+    #[allow(clippy::ignored_unit_patterns)]
     pub fn from_schema_error(schema_path_str: &str, error_msg: &str) -> Self {
         match () {
-            _ if schema_path_str.contains("minLength") => Self::StringTooShort { min_length: None },
-            _ if schema_path_str.contains("maxLength") => Self::StringTooLong { max_length: None },
-            _ if schema_path_str.contains("exclusiveMinimum")
+            () if schema_path_str.contains("minLength") => Self::StringTooShort { min_length: None },
+            () if schema_path_str.contains("maxLength") => Self::StringTooLong { max_length: None },
+            () if schema_path_str.contains("exclusiveMinimum")
                 || (error_msg.contains("less than or equal to") && error_msg.contains("minimum")) =>
             {
                 Self::GreaterThan { value: None }
             }
-            _ if schema_path_str.contains("minimum") || error_msg.contains("less than the minimum") => {
+            () if schema_path_str.contains("minimum") || error_msg.contains("less than the minimum") => {
                 Self::GreaterThanEqual { value: None }
             }
-            _ if schema_path_str.contains("exclusiveMaximum")
+            () if schema_path_str.contains("exclusiveMaximum")
                 || (error_msg.contains("greater than or equal to") && error_msg.contains("maximum")) =>
             {
                 Self::LessThan { value: None }
             }
-            _ if schema_path_str.contains("maximum") || error_msg.contains("greater than the maximum") => {
+            () if schema_path_str.contains("maximum") || error_msg.contains("greater than the maximum") => {
                 Self::LessThanEqual { value: None }
             }
-            _ if schema_path_str.contains("enum") || error_msg.contains("is not one of") => Self::Enum { values: None },
-            _ if schema_path_str.contains("pattern") || error_msg.contains("does not match") => {
+            () if schema_path_str.contains("enum") || error_msg.contains("is not one of") => {
+                Self::Enum { values: None }
+            }
+            () if schema_path_str.contains("pattern") || error_msg.contains("does not match") => {
                 Self::StringPatternMismatch { pattern: None }
             }
-            _ if schema_path_str.contains("format") => {
+            () if schema_path_str.contains("format") => {
                 if error_msg.contains("email") {
                     Self::EmailFormat
                 } else if error_msg.contains("uuid") {
@@ -104,7 +108,8 @@ impl ErrorCondition {
     }
 
     /// Get the error type code for this condition
-    pub fn error_type(&self) -> &'static str {
+    #[must_use]
+    pub const fn error_type(&self) -> &'static str {
         match self {
             Self::StringTooShort { .. } => "string_too_short",
             Self::StringTooLong { .. } => "string_too_long",
@@ -113,23 +118,22 @@ impl ErrorCondition {
             Self::LessThan { .. } => "less_than",
             Self::LessThanEqual { .. } => "less_than_equal",
             Self::Enum { .. } => "enum",
-            Self::StringPatternMismatch { .. } => "string_pattern_mismatch",
-            Self::EmailFormat => "string_pattern_mismatch",
+            Self::StringPatternMismatch { .. } | Self::EmailFormat => "string_pattern_mismatch",
             Self::UuidFormat => "uuid_parsing",
             Self::DatetimeFormat => "datetime_parsing",
             Self::DateFormat => "date_parsing",
             Self::FormatError => "format_error",
             Self::TypeMismatch { .. } => "type_error",
             Self::Missing => "missing",
-            Self::AdditionalProperties { .. } => "validation_error",
+            Self::AdditionalProperties { .. } | Self::ValidationError => "validation_error",
             Self::TooFewItems { .. } => "too_short",
             Self::TooManyItems => "too_long",
-            Self::ValidationError => "validation_error",
         }
     }
 
     /// Get default message for this error condition
-    pub fn default_message(&self) -> &'static str {
+    #[must_use]
+    pub const fn default_message(&self) -> &'static str {
         match self {
             Self::StringTooShort { .. } => "String is too short",
             Self::StringTooLong { .. } => "String is too long",
@@ -159,6 +163,16 @@ pub struct ErrorMapper;
 
 impl ErrorMapper {
     /// Map an error condition to its type, message, and context
+    ///
+    /// # Panics
+    /// Panics if accessing `.last()` on an empty vector for enum values extraction.
+    #[must_use]
+    #[allow(
+        clippy::too_many_lines,
+        clippy::option_if_let_else,
+        clippy::redundant_closure_for_method_calls,
+        clippy::uninlined_format_args
+    )]
     pub fn map_error(
         condition: &ErrorCondition,
         schema: &Value,

data/vendor/crates/spikard-core/src/validation/mod.rs

@@ -18,6 +18,9 @@ pub struct SchemaValidator {
 
 impl SchemaValidator {
     /// Create a new validator from a JSON Schema
+    ///
+    /// # Errors
+    /// Returns an error if the schema is invalid or compilation fails.
     pub fn new(schema: Value) -> Result<Self, String> {
         let compiled = jsonschema::options()
             .with_draft(jsonschema::Draft::Draft202012)
@@ -26,7 +29,7 @@ impl SchemaValidator {
             .build(&schema)
             .map_err(|e| {
                 anyhow::anyhow!("Invalid JSON Schema")
-                    .context(format!("Schema compilation failed: {}", e))
+                    .context(format!("Schema compilation failed: {e}"))
                     .to_string()
             })?;
 
@@ -37,16 +40,17 @@ impl SchemaValidator {
     }
 
     /// Get the underlying JSON Schema
-    pub fn schema(&self) -> &Value {
+    #[must_use]
+    pub const fn schema(&self) -> &Value {
         &self.schema
     }
 
-    /// Pre-process data to convert file objects to strings for format: "binary" validation
+    /// Pre-process data to convert file objects to strings for format: `binary` validation
     ///
     /// Files uploaded via multipart are converted to objects like:
-    /// {"filename": "...", "size": N, "content": "...", "content_type": "..."}
+    /// `{"filename": "...", "size": N, "content": "...", "content_type": "..."}`
     ///
-    /// But schemas define them as: {"type": "string", "format": "binary"}
+    /// But schemas define them as: `{"type": "string", "format": "binary"}`
     ///
     /// This method recursively processes the data and converts file objects to their content strings
     /// so that validation passes, while preserving the original structure for handlers to use.
@@ -54,7 +58,7 @@ impl SchemaValidator {
         self.preprocess_value_with_schema(data, &self.schema)
     }
 
-    #[allow(clippy::only_used_in_recursion)]
+    #[allow(clippy::only_used_in_recursion, clippy::self_only_used_in_recursion)]
     fn preprocess_value_with_schema(&self, data: &Value, schema: &Value) -> Value {
         if let Some(schema_obj) = schema.as_object() {
             let is_string_type = schema_obj.get("type").and_then(|t| t.as_str()) == Some("string");
@@ -110,6 +114,13 @@ impl SchemaValidator {
     }
 
     /// Validate JSON data against the schema
+    ///
+    /// # Errors
+    /// Returns a `ValidationError` if the data does not conform to the schema.
+    ///
+    /// # Too Many Lines
+    /// This function is complex due to error mapping logic.
+    #[allow(clippy::option_if_let_else, clippy::uninlined_format_args, clippy::too_many_lines)]
     pub fn validate(&self, data: &Value) -> Result<(), ValidationError> {
         let processed_data = self.preprocess_binary_fields(data);
 
@@ -131,41 +142,39 @@ impl SchemaValidator {
                         if let Some(end) = error_msg[start + 1..].find('"') {
                             error_msg[start + 1..start + 1 + end].to_string()
                         } else {
-                            "".to_string()
+                            String::new()
                         }
                     } else {
-                        "".to_string()
+                        String::new()
                     };
 
-                    if !instance_path.is_empty() && instance_path.starts_with('/') && instance_path.len() > 1 {
+                    if instance_path.starts_with('/') && instance_path.len() > 1 {
                         let base_path = &instance_path[1..];
-                        if !field_name.is_empty() {
-                            format!("{}/{}", base_path, field_name)
-                        } else {
+                        if field_name.is_empty() {
                             base_path.to_string()
+                        } else {
+                            format!("{base_path}/{field_name}")
                         }
-                    } else if !field_name.is_empty() {
-                        field_name
-                    } else {
+                    } else if field_name.is_empty() {
                         "body".to_string()
+                    } else {
+                        field_name
                     }
                 } else if schema_path_str.contains("/additionalProperties") {
                     if let Some(start) = error_msg.find('(') {
                         if let Some(quote_start) = error_msg[start..].find('\'') {
                             let abs_start = start + quote_start + 1;
-                            if let Some(quote_end) = error_msg[abs_start..].find('\'') {
-                                let property_name = error_msg[abs_start..abs_start + quote_end].to_string();
-                                if !instance_path.is_empty()
-                                    && instance_path.starts_with('/')
-                                    && instance_path.len() > 1
-                                {
-                                    format!("{}/{}", &instance_path[1..], property_name)
-                                } else {
-                                    property_name
-                                }
-                            } else {
-                                instance_path[1..].to_string()
-                            }
+                            error_msg[abs_start..].find('\'').map_or_else(
+                                || instance_path[1..].to_string(),
+                                |quote_end| {
+                                    let property_name = error_msg[abs_start..abs_start + quote_end].to_string();
+                                    if instance_path.starts_with('/') && instance_path.len() > 1 {
+                                        format!("{}/{property_name}", &instance_path[1..])
+                                    } else {
+                                        property_name
+                                    }
+                                },
+                            )
                         } else {
                             instance_path[1..].to_string()
                         }
@@ -184,7 +193,7 @@ impl SchemaValidator {
 
                 let loc_parts: Vec<String> = if param_name.contains('/') {
                     let mut parts = vec!["body".to_string()];
-                    parts.extend(param_name.split('/').map(|s| s.to_string()));
+                    parts.extend(param_name.split('/').map(ToString::to_string));
                     parts
                 } else if param_name == "body" {
                     vec!["body".to_string()]
@@ -201,7 +210,7 @@ impl SchemaValidator {
                 let schema_prop_path = if param_name.contains('/') {
                     format!("/properties/{}", param_name.replace('/', "/properties/"))
                 } else {
-                    format!("/properties/{}", param_name)
+                    format!("/properties/{param_name}")
                 };
 
                 let mut error_condition = ErrorCondition::from_schema_error(schema_path_str, &error_msg);
@@ -210,13 +219,14 @@ impl SchemaValidator {
                     ErrorCondition::TypeMismatch { .. } => {
                         let expected_type = self
                             .schema
-                            .pointer(&format!("{}/type", schema_prop_path))
+                            .pointer(&format!("{schema_prop_path}/type"))
                             .and_then(|v| v.as_str())
                             .unwrap_or("unknown")
                             .to_string();
                         ErrorCondition::TypeMismatch { expected_type }
                     }
                     ErrorCondition::AdditionalProperties { .. } => {
+                        #[allow(clippy::redundant_clone)]
                         let unexpected_field = if param_name.contains('/') {
                             param_name.split('/').next_back().unwrap_or(&param_name).to_string()
                         } else {
@@ -268,12 +278,15 @@ impl SchemaValidator {
     }
 
     /// Validate and parse JSON bytes
+    ///
+    /// # Errors
+    /// Returns a validation error if the JSON is invalid or fails validation against the schema.
     pub fn validate_json(&self, json_bytes: &[u8]) -> Result<Value, ValidationError> {
         let value: Value = serde_json::from_slice(json_bytes).map_err(|e| ValidationError {
             errors: vec![ValidationErrorDetail {
                 error_type: "json_parse_error".to_string(),
                 loc: vec!["body".to_string()],
-                msg: format!("Invalid JSON: {}", e),
+                msg: format!("Invalid JSON: {e}"),
                 input: Value::Null,
                 ctx: None,
             }],

data/vendor/crates/spikard-http/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "spikard-http"
-version = "0.8.1"
+version = "0.8.3"
 edition = "2024"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
 license = "MIT"
@@ -55,6 +55,13 @@ prost = "0.14"
 prost-types = "0.14"
 h2 = "0.4"
 
+[lints.rust]
+unexpected_cfgs = { level = "allow", check-cfg = ['cfg(tarpaulin_include)'] }
+
+[lints.clippy]
+all = { level = "deny", priority = 0 }
+pedantic = { level = "deny", priority = 0 }
+nursery = { level = "deny", priority = 0 }
 
 [features]
 default = []

data/vendor/crates/spikard-http/src/grpc/mod.rs

@@ -48,7 +48,7 @@ pub mod streaming;
 
 // Re-export main types
 pub use handler::{GrpcHandler, GrpcHandlerResult, GrpcRequestData, GrpcResponseData};
-pub use service::{copy_metadata, GenericGrpcService, is_grpc_request, parse_grpc_path};
+pub use service::{GenericGrpcService, copy_metadata, is_grpc_request, parse_grpc_path};
 pub use streaming::{MessageStream, StreamingRequest, StreamingResponse};
 
 use serde::{Deserialize, Serialize};

data/vendor/crates/spikard-http/src/grpc/service.rs

@@ -200,7 +200,9 @@ mod tests {
         let service = GenericGrpcService::new(handler);
 
         let request = Request::new(Bytes::from("test payload"));
-        let result = service.handle_unary("test.TestService".to_string(), "TestMethod".to_string(), request).await;
+        let result = service
+            .handle_unary("test.TestService".to_string(), "TestMethod".to_string(), request)
+            .await;
 
         assert!(result.is_ok());
         let response = result.unwrap();
@@ -217,7 +219,9 @@ mod tests {
             .metadata_mut()
             .insert("custom-header", "custom-value".parse().unwrap());
 
-        let result = service.handle_unary("test.TestService".to_string(), "TestMethod".to_string(), request).await;
+        let result = service
+            .handle_unary("test.TestService".to_string(), "TestMethod".to_string(), request)
+            .await;
 
         assert!(result.is_ok());
     }
@@ -266,10 +270,7 @@ mod tests {
     #[test]
     fn test_is_grpc_request_valid() {
         let mut headers = axum::http::HeaderMap::new();
-        headers.insert(
-            axum::http::header::CONTENT_TYPE,
-            "application/grpc".parse().unwrap(),
-        );
+        headers.insert(axum::http::header::CONTENT_TYPE, "application/grpc".parse().unwrap());
         assert!(is_grpc_request(&headers));
     }
 
@@ -286,10 +287,7 @@ mod tests {
     #[test]
     fn test_is_grpc_request_not_grpc() {
         let mut headers = axum::http::HeaderMap::new();
-        headers.insert(
-            axum::http::header::CONTENT_TYPE,
-            "application/json".parse().unwrap(),
-        );
+        headers.insert(axum::http::header::CONTENT_TYPE, "application/json".parse().unwrap());
         assert!(!is_grpc_request(&headers));
     }
 
@@ -382,7 +380,9 @@ mod tests {
         let service = GenericGrpcService::new(handler);
 
         let request = Request::new(Bytes::new());
-        let result = service.handle_unary("test.ErrorService".to_string(), "ErrorMethod".to_string(), request).await;
+        let result = service
+            .handle_unary("test.ErrorService".to_string(), "ErrorMethod".to_string(), request)
+            .await;
 
         assert!(result.is_err());
         let status = result.unwrap_err();

data/vendor/crates/spikard-http/src/grpc/streaming.rs

@@ -193,7 +193,11 @@ mod tests {
 
     #[tokio::test]
     async fn test_from_tonic_stream() {
-        let messages = vec![Ok(Bytes::from("a")), Ok(Bytes::from("b")), Err(Status::cancelled("done"))];
+        let messages = vec![
+            Ok(Bytes::from("a")),
+            Ok(Bytes::from("b")),
+            Err(Status::cancelled("done")),
+        ];
 
         let tonic_stream = futures_util::stream::iter(messages);
         let mut stream = from_tonic_stream(tonic_stream);

data/vendor/crates/spikard-http/src/server/grpc_routing.rs

@@ -69,10 +69,7 @@ pub async fn route_grpc_request(
     let handler = match registry.get(&service_name) {
         Some(h) => h,
         None => {
-            return Err((
-                StatusCode::NOT_FOUND,
-                format!("Service not found: {}", service_name),
-            ));
+            return Err((StatusCode::NOT_FOUND, format!("Service not found: {}", service_name)));
         }
     };
 
@@ -94,7 +91,10 @@ pub async fn route_grpc_request(
             // Try to parse as ASCII metadata
             if let Ok(metadata_value) = value_str.parse::<tonic::metadata::MetadataValue<tonic::metadata::Ascii>>() {
                 // Use key.as_str() directly instead of creating String
-                if let Ok(metadata_key) = key.as_str().parse::<tonic::metadata::MetadataKey<tonic::metadata::Ascii>>() {
+                if let Ok(metadata_key) = key
+                    .as_str()
+                    .parse::<tonic::metadata::MetadataKey<tonic::metadata::Ascii>>()
+                {
                     tonic_request.metadata_mut().insert(metadata_key, metadata_value);
                 }
             }
@@ -132,9 +132,12 @@ pub async fn route_grpc_request(
     response = response.header("grpc-status", "0");
 
     // Convert bytes::Bytes to Body
-    let response = response
-        .body(Body::from(payload))
-        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to build response: {}", e)))?;
+    let response = response.body(Body::from(payload)).map_err(|e| {
+        (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Failed to build response: {}", e),
+        )
+    })?;
 
     Ok(response)
 }
@@ -268,21 +271,57 @@ mod tests {
     fn test_grpc_status_to_http_mappings() {
         // Test all gRPC status codes map correctly
         assert_eq!(grpc_status_to_http(tonic::Code::Ok), StatusCode::OK);
-        assert_eq!(grpc_status_to_http(tonic::Code::Cancelled), StatusCode::from_u16(499).unwrap());
-        assert_eq!(grpc_status_to_http(tonic::Code::Unknown), StatusCode::INTERNAL_SERVER_ERROR);
-        assert_eq!(grpc_status_to_http(tonic::Code::InvalidArgument), StatusCode::BAD_REQUEST);
-        assert_eq!(grpc_status_to_http(tonic::Code::DeadlineExceeded), StatusCode::GATEWAY_TIMEOUT);
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::Cancelled),
+            StatusCode::from_u16(499).unwrap()
+        );
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::Unknown),
+            StatusCode::INTERNAL_SERVER_ERROR
+        );
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::InvalidArgument),
+            StatusCode::BAD_REQUEST
+        );
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::DeadlineExceeded),
+            StatusCode::GATEWAY_TIMEOUT
+        );
         assert_eq!(grpc_status_to_http(tonic::Code::NotFound), StatusCode::NOT_FOUND);
         assert_eq!(grpc_status_to_http(tonic::Code::AlreadyExists), StatusCode::CONFLICT);
-        assert_eq!(grpc_status_to_http(tonic::Code::PermissionDenied), StatusCode::FORBIDDEN);
-        assert_eq!(grpc_status_to_http(tonic::Code::ResourceExhausted), StatusCode::TOO_MANY_REQUESTS);
-        assert_eq!(grpc_status_to_http(tonic::Code::FailedPrecondition), StatusCode::BAD_REQUEST);
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::PermissionDenied),
+            StatusCode::FORBIDDEN
+        );
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::ResourceExhausted),
+            StatusCode::TOO_MANY_REQUESTS
+        );
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::FailedPrecondition),
+            StatusCode::BAD_REQUEST
+        );
         assert_eq!(grpc_status_to_http(tonic::Code::Aborted), StatusCode::CONFLICT);
         assert_eq!(grpc_status_to_http(tonic::Code::OutOfRange), StatusCode::BAD_REQUEST);
-        assert_eq!(grpc_status_to_http(tonic::Code::Unimplemented), StatusCode::NOT_IMPLEMENTED);
-        assert_eq!(grpc_status_to_http(tonic::Code::Internal), StatusCode::INTERNAL_SERVER_ERROR);
-        assert_eq!(grpc_status_to_http(tonic::Code::Unavailable), StatusCode::SERVICE_UNAVAILABLE);
-        assert_eq!(grpc_status_to_http(tonic::Code::DataLoss), StatusCode::INTERNAL_SERVER_ERROR);
-        assert_eq!(grpc_status_to_http(tonic::Code::Unauthenticated), StatusCode::UNAUTHORIZED);
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::Unimplemented),
+            StatusCode::NOT_IMPLEMENTED
+        );
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::Internal),
+            StatusCode::INTERNAL_SERVER_ERROR
+        );
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::Unavailable),
+            StatusCode::SERVICE_UNAVAILABLE
+        );
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::DataLoss),
+            StatusCode::INTERNAL_SERVER_ERROR
+        );
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::Unauthenticated),
+            StatusCode::UNAUTHORIZED
+        );
     }
 }