spikard 0.8.2 → 0.10.1

data/vendor/crates/spikard-bindings-shared/src/error_response.rs

@@ -15,7 +15,7 @@ pub struct ErrorResponseBuilder;
 impl ErrorResponseBuilder {
     /// Create a structured error response with status code and error details
     ///
-    /// Returns a tuple of (StatusCode, JSON body as String)
+    /// Returns a tuple of (`StatusCode`, JSON body as String)
     ///
     /// # Arguments
     /// * `status` - HTTP status code
@@ -42,7 +42,7 @@ impl ErrorResponseBuilder {
 
     /// Create an error response with additional details
     ///
-    /// Returns a tuple of (StatusCode, JSON body as String)
+    /// Returns a tuple of (`StatusCode`, JSON body as String)
     ///
     /// # Arguments
     /// * `status` - HTTP status code
@@ -79,17 +79,18 @@ impl ErrorResponseBuilder {
         (status, body)
     }
 
-    /// Create an error response from a StructuredError
+    /// Create an error response from a `StructuredError`
     ///
-    /// Returns a tuple of (StatusCode, JSON body as String)
+    /// Returns a tuple of (`StatusCode`, JSON body as String)
     ///
     /// # Arguments
     /// * `error` - The structured error
     ///
     /// # Note
-    /// Uses INTERNAL_SERVER_ERROR as the default status code. Override with
+    /// Uses `INTERNAL_SERVER_ERROR` as the default status code. Override with
     /// `structured_error()` or `with_details()` for specific status codes.
-    pub fn from_structured_error(error: StructuredError) -> (StatusCode, String) {
+    #[must_use]
+    pub fn from_structured_error(error: &StructuredError) -> (StatusCode, String) {
         let status = StatusCode::INTERNAL_SERVER_ERROR;
         let body = serde_json::to_string(&error)
             .unwrap_or_else(|_| r#"{"error":"serialization_failed","code":"internal_error","details":{}}"#.to_string());
@@ -98,8 +99,8 @@ impl ErrorResponseBuilder {
 
     /// Create a validation error response
     ///
-    /// Converts ValidationError to RFC 9457 Problem Details format.
-    /// Returns (StatusCode::UNPROCESSABLE_ENTITY, JSON body)
+    /// Converts `ValidationError` to RFC 9457 Problem Details format.
+    /// Returns (`StatusCode::UNPROCESSABLE_ENTITY`, JSON body)
     ///
     /// # Arguments
     /// * `validation_error` - The validation error containing one or more details
@@ -124,6 +125,7 @@ impl ErrorResponseBuilder {
     ///
     /// let (status, body) = ErrorResponseBuilder::validation_error(&validation_error);
     /// ```
+    #[must_use]
     pub fn validation_error(validation_error: &ValidationError) -> (StatusCode, String) {
         let problem = ProblemDetails::from_validation_error(validation_error);
         let status = problem.status_code();
@@ -136,7 +138,7 @@ impl ErrorResponseBuilder {
 
     /// Create an RFC 9457 Problem Details response
     ///
-    /// Returns a tuple of (StatusCode, JSON body as String)
+    /// Returns a tuple of (`StatusCode`, JSON body as String)
     ///
     /// # Arguments
     /// * `problem` - The Problem Details object
@@ -150,6 +152,7 @@ impl ErrorResponseBuilder {
     /// let problem = ProblemDetails::not_found("User with id 123 not found");
     /// let (status, body) = ErrorResponseBuilder::problem_details_response(&problem);
     /// ```
+    #[must_use]
     pub fn problem_details_response(problem: &ProblemDetails) -> (StatusCode, String) {
         let status = problem.status_code();
         let body = serde_json::to_string(problem).unwrap_or_else(|_| {
@@ -161,70 +164,70 @@ impl ErrorResponseBuilder {
 
     /// Create a generic bad request error
     ///
-    /// Returns (StatusCode::BAD_REQUEST, JSON body)
+    /// Returns (`StatusCode::BAD_REQUEST`, JSON body)
     pub fn bad_request(message: impl Into<String>) -> (StatusCode, String) {
         Self::structured_error(StatusCode::BAD_REQUEST, "bad_request", message)
     }
 
     /// Create a generic internal server error
     ///
-    /// Returns (StatusCode::INTERNAL_SERVER_ERROR, JSON body)
+    /// Returns (`StatusCode::INTERNAL_SERVER_ERROR`, JSON body)
     pub fn internal_error(message: impl Into<String>) -> (StatusCode, String) {
         Self::structured_error(StatusCode::INTERNAL_SERVER_ERROR, "internal_error", message)
     }
 
     /// Create an unauthorized error
     ///
-    /// Returns (StatusCode::UNAUTHORIZED, JSON body)
+    /// Returns (`StatusCode::UNAUTHORIZED`, JSON body)
     pub fn unauthorized(message: impl Into<String>) -> (StatusCode, String) {
         Self::structured_error(StatusCode::UNAUTHORIZED, "unauthorized", message)
     }
 
     /// Create a forbidden error
     ///
-    /// Returns (StatusCode::FORBIDDEN, JSON body)
+    /// Returns (`StatusCode::FORBIDDEN`, JSON body)
     pub fn forbidden(message: impl Into<String>) -> (StatusCode, String) {
         Self::structured_error(StatusCode::FORBIDDEN, "forbidden", message)
     }
 
     /// Create a not found error
     ///
-    /// Returns (StatusCode::NOT_FOUND, JSON body)
+    /// Returns (`StatusCode::NOT_FOUND`, JSON body)
     pub fn not_found(message: impl Into<String>) -> (StatusCode, String) {
         Self::structured_error(StatusCode::NOT_FOUND, "not_found", message)
     }
 
     /// Create a method not allowed error
     ///
-    /// Returns (StatusCode::METHOD_NOT_ALLOWED, JSON body)
+    /// Returns (`StatusCode::METHOD_NOT_ALLOWED`, JSON body)
     pub fn method_not_allowed(message: impl Into<String>) -> (StatusCode, String) {
         Self::structured_error(StatusCode::METHOD_NOT_ALLOWED, "method_not_allowed", message)
     }
 
     /// Create an unprocessable entity error (validation failed)
     ///
-    /// Returns (StatusCode::UNPROCESSABLE_ENTITY, JSON body)
+    /// Returns (`StatusCode::UNPROCESSABLE_ENTITY`, JSON body)
     pub fn unprocessable_entity(message: impl Into<String>) -> (StatusCode, String) {
         Self::structured_error(StatusCode::UNPROCESSABLE_ENTITY, "unprocessable_entity", message)
     }
 
     /// Create a conflict error
     ///
-    /// Returns (StatusCode::CONFLICT, JSON body)
+    /// Returns (`StatusCode::CONFLICT`, JSON body)
     pub fn conflict(message: impl Into<String>) -> (StatusCode, String) {
         Self::structured_error(StatusCode::CONFLICT, "conflict", message)
     }
 
     /// Create a service unavailable error
     ///
-    /// Returns (StatusCode::SERVICE_UNAVAILABLE, JSON body)
+    /// Returns (`StatusCode::SERVICE_UNAVAILABLE`, JSON body)
     pub fn service_unavailable(message: impl Into<String>) -> (StatusCode, String) {
         Self::structured_error(StatusCode::SERVICE_UNAVAILABLE, "service_unavailable", message)
     }
 
     /// Create a request timeout error
     ///
-    /// Returns (StatusCode::REQUEST_TIMEOUT, JSON body)
+    /// Returns (`StatusCode::REQUEST_TIMEOUT`, JSON body)
     pub fn request_timeout(message: impl Into<String>) -> (StatusCode, String) {
         Self::structured_error(StatusCode::REQUEST_TIMEOUT, "request_timeout", message)
     }
@@ -257,7 +260,7 @@ mod tests {
             StatusCode::BAD_REQUEST,
             "validation_error",
             "Invalid email format",
-            details.clone(),
+            details,
         );
         assert_eq!(status, StatusCode::BAD_REQUEST);
         let parsed: Value = serde_json::from_str(&body).unwrap();
@@ -270,7 +273,7 @@ mod tests {
     #[test]
     fn test_from_structured_error() {
         let error = StructuredError::simple("test_error", "Something went wrong");
-        let (status, body) = ErrorResponseBuilder::from_structured_error(error);
+        let (status, body) = ErrorResponseBuilder::from_structured_error(&error);
         assert_eq!(status, StatusCode::INTERNAL_SERVER_ERROR);
         let parsed: Value = serde_json::from_str(&body).unwrap();
         assert_eq!(parsed["code"], "test_error");
@@ -284,7 +287,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,
             }],
         };

data/vendor/crates/spikard-bindings-shared/src/grpc_metadata.rs

@@ -6,20 +6,20 @@
 use std::collections::HashMap;
 use tonic::metadata::{MetadataKey, MetadataMap, MetadataValue};
 
-/// Extract metadata from gRPC MetadataMap to a simple HashMap.
+/// Extract metadata from gRPC `MetadataMap` to a simple `HashMap`.
 ///
-/// This function converts gRPC metadata to a language-agnostic HashMap format
+/// This function converts gRPC metadata to a language-agnostic `HashMap` format
 /// that can be easily passed to language bindings. Only ASCII metadata is
 /// included; binary metadata is skipped with optional logging.
 ///
 /// # Arguments
 ///
-/// * `metadata` - The gRPC MetadataMap to extract from
+/// * `metadata` - The gRPC `MetadataMap` to extract from
 /// * `log_binary_skip` - Whether to log when binary metadata is skipped
 ///
 /// # Returns
 ///
-/// A HashMap containing all ASCII metadata key-value pairs
+/// A `HashMap` containing all ASCII metadata key-value pairs
 ///
 /// # Examples
 ///
@@ -55,19 +55,19 @@ pub fn extract_metadata_to_hashmap(metadata: &MetadataMap, log_binary_skip: bool
     map
 }
 
-/// Convert a HashMap to gRPC MetadataMap.
+/// Convert a `HashMap` to gRPC `MetadataMap`.
 ///
-/// This function converts a language-agnostic HashMap into a gRPC MetadataMap
+/// This function converts a language-agnostic `HashMap` into a gRPC `MetadataMap`
 /// that can be used in responses. All keys and values are validated and errors
 /// are returned if any are invalid.
 ///
 /// # Arguments
 ///
-/// * `map` - The HashMap to convert
+/// * `map` - The `HashMap` to convert
 ///
 /// # Returns
 ///
-/// A Result containing the MetadataMap or an error message
+/// A Result containing the `MetadataMap` or an error message
 ///
 /// # Errors
 ///
@@ -87,15 +87,17 @@ pub fn extract_metadata_to_hashmap(metadata: &MetadataMap, log_binary_skip: bool
 /// let metadata = hashmap_to_metadata(&map).unwrap();
 /// assert!(metadata.contains_key("content-type"));
 /// ```
-pub fn hashmap_to_metadata(map: &HashMap<String, String>) -> Result<MetadataMap, String> {
+pub fn hashmap_to_metadata<S: std::hash::BuildHasher>(
+    map: &std::collections::HashMap<String, String, S>,
+) -> Result<MetadataMap, String> {
     let mut metadata = MetadataMap::new();
 
     for (key, value) in map {
-        let metadata_key = MetadataKey::from_bytes(key.as_bytes())
-            .map_err(|err| format!("Invalid metadata key '{}': {}", key, err))?;
+        let metadata_key =
+            MetadataKey::from_bytes(key.as_bytes()).map_err(|err| format!("Invalid metadata key '{key}': {err}"))?;
 
         let metadata_value =
-            MetadataValue::try_from(value).map_err(|err| format!("Invalid metadata value for '{}': {}", key, err))?;
+            MetadataValue::try_from(value).map_err(|err| format!("Invalid metadata value for '{key}': {err}"))?;
 
         metadata.insert(metadata_key, metadata_value);
     }

data/vendor/crates/spikard-bindings-shared/src/handler_base.rs

@@ -33,7 +33,9 @@ pub enum HandlerError {
 
 impl From<ValidationError> for HandlerError {
     fn from(err: ValidationError) -> Self {
-        HandlerError::Validation(format!("{:?}", err))
+        // PERFORMANCE: Avoid format! allocation for debug representation.
+        // Most callers just need the error type, not the full debug output.
+        Self::Validation(err.to_string())
     }
 }
 
@@ -54,6 +56,10 @@ pub trait LanguageHandler: Send + Sync {
     type Output: Send;
 
     /// Prepare request data for passing to the language handler
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if request preparation fails.
     fn prepare_request(&self, request_data: &RequestData) -> Result<Self::Input, HandlerError>;
 
     /// Invoke the language-specific handler with the prepared input
@@ -63,6 +69,10 @@ pub trait LanguageHandler: Send + Sync {
     ) -> Pin<Box<dyn Future<Output = Result<Self::Output, HandlerError>> + Send + '_>>;
 
     /// Interpret the handler's output and convert it to an HTTP response
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if response interpretation fails.
     fn interpret_response(&self, output: Self::Output) -> Result<Response<Body>, HandlerError>;
 }
 
@@ -81,7 +91,7 @@ pub struct HandlerExecutor<L: LanguageHandler> {
 
 impl<L: LanguageHandler> HandlerExecutor<L> {
     /// Create a new handler executor
-    pub fn new(language_handler: Arc<L>, request_validator: Option<Arc<SchemaValidator>>) -> Self {
+    pub const fn new(language_handler: Arc<L>, request_validator: Option<Arc<SchemaValidator>>) -> Self {
         Self {
             language_handler,
             request_validator,
@@ -89,7 +99,7 @@ impl<L: LanguageHandler> HandlerExecutor<L> {
     }
 
     /// Create a handler executor with only a language handler
-    pub fn with_handler(language_handler: Arc<L>) -> Self {
+    pub const fn with_handler(language_handler: Arc<L>) -> Self {
         Self {
             language_handler,
             request_validator: None,
@@ -97,6 +107,7 @@ impl<L: LanguageHandler> HandlerExecutor<L> {
     }
 
     /// Add request validation to this executor
+    #[must_use]
     pub fn with_request_validator(mut self, validator: Arc<SchemaValidator>) -> Self {
         self.request_validator = Some(validator);
         self
@@ -116,21 +127,24 @@ impl<L: LanguageHandler + 'static> Handler for HandlerExecutor<L> {
                 return Err(ErrorResponseBuilder::validation_error(&validation_err));
             }
 
+            // PERFORMANCE: Avoid format! allocations in the hot path. ErrorResponseBuilder
+            // can accept &dyn Display or construct error messages directly, reducing
+            // string allocation overhead in typical error handling paths.
             let input = self
                 .language_handler
                 .prepare_request(&request_data)
-                .map_err(|e| ErrorResponseBuilder::internal_error(format!("Failed to prepare request: {}", e)))?;
+                .map_err(|e| ErrorResponseBuilder::internal_error(format!("Failed to prepare request: {e}")))?;
 
             let output = self
                 .language_handler
                 .invoke_handler(input)
                 .await
-                .map_err(|e| ErrorResponseBuilder::internal_error(format!("Handler execution failed: {}", e)))?;
+                .map_err(|e| ErrorResponseBuilder::internal_error(format!("Handler execution failed: {e}")))?;
 
             let response = self
                 .language_handler
                 .interpret_response(output)
-                .map_err(|e| ErrorResponseBuilder::internal_error(format!("Failed to interpret response: {}", e)))?;
+                .map_err(|e| ErrorResponseBuilder::internal_error(format!("Failed to interpret response: {e}")))?;
 
             Ok(response)
         })
@@ -172,10 +186,10 @@ mod tests {
         let request = Request::builder().body(Body::empty()).unwrap();
         let request_data = RequestData {
             path_params: Arc::new(std::collections::HashMap::new()),
-            query_params: json!({}),
+            query_params: Arc::new(json!({})),
             validated_params: None,
             raw_query_params: Arc::new(std::collections::HashMap::new()),
-            body: json!({}),
+            body: Arc::new(json!({})),
             raw_body: None,
             headers: Arc::new(std::collections::HashMap::new()),
             cookies: Arc::new(std::collections::HashMap::new()),
@@ -196,10 +210,10 @@ mod tests {
         let request = Request::builder().body(Body::empty()).unwrap();
         let request_data = RequestData {
             path_params: Arc::new(std::collections::HashMap::new()),
-            query_params: json!({}),
+            query_params: Arc::new(json!({})),
             validated_params: None,
             raw_query_params: Arc::new(std::collections::HashMap::new()),
-            body: json!({}),
+            body: Arc::new(json!({})),
             raw_body: None,
             headers: Arc::new(std::collections::HashMap::new()),
             cookies: Arc::new(std::collections::HashMap::new()),