spikard 0.8.2 → 0.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 812ea62c2af7b3d443a8485aa055c197cdb1b65b04a3cc916ffd7bd6b0dfc81a
-  data.tar.gz: 825b7329c8ce47f3d74ebcc97fdbfa5ebbd5cbc16294b2721362bc1bd62fc7c6
+  metadata.gz: add40ab33a80f54c472f6b888638ec6e3859a05d616a5233d5347c3b07ee414d
+  data.tar.gz: cf1ab4efa6bacd7edc6c23ffebd96382804754811b9e9da7e91300c6eee9af3b
 SHA512:
-  metadata.gz: 8c27c069e2a10c5dc6b43f721f5baf2c56f5361f3fde3362b7ee3242b0deda62d9e4f198853cbba3e3f44c5f7aa0028495623961299fa99cc9bc9518d6f726a6
-  data.tar.gz: 6179700d82a1aff3aa93b87ac1152be28722eda2559a8becd8946d3e462cd32acc73328154c4906b79fab39e0188f0e7d84fefaa0e2aa4cc18358bb0fec6a84e
+  metadata.gz: 4e569ced4b7aba06c0f2c590807517987e8c6dd4a37da90a0c4caf248f99d3413482a418b429e183ac02c6ca1a658c1bb99a00e17104747057ecf21e74b56a13
+  data.tar.gz: 0b87cf1a9c439c58e078d0104b6b86e8264d28b194b9044f03d2cfdc49c11a1b33c5997523ead13bd5a0a720a1600a07908d414e876798c1c3cd4613de07d30d

data/ext/spikard_rb/Cargo.lock

@@ -2515,7 +2515,7 @@ dependencies = [
 
 [[package]]
 name = "spikard-bindings-shared"
-version = "0.7.5"
+version = "0.8.2"
 dependencies = [
  "axum",
  "http",
@@ -2532,7 +2532,7 @@ dependencies = [
 
 [[package]]
 name = "spikard-core"
-version = "0.7.5"
+version = "0.8.2"
 dependencies = [
  "anyhow",
  "base64",
@@ -2556,7 +2556,7 @@ dependencies = [
 
 [[package]]
 name = "spikard-http"
-version = "0.7.5"
+version = "0.8.2"
 dependencies = [
  "anyhow",
  "axum",
@@ -2603,7 +2603,7 @@ dependencies = [
 
 [[package]]
 name = "spikard-rb"
-version = "0.7.5"
+version = "0.8.2"
 dependencies = [
  "async-stream",
  "axum",
@@ -2633,7 +2633,7 @@ dependencies = [
 
 [[package]]
 name = "spikard-rb-ext"
-version = "0.7.5"
+version = "0.8.2"
 dependencies = [
  "magnus",
  "spikard-rb",
@@ -2641,7 +2641,7 @@ dependencies = [
 
 [[package]]
 name = "spikard-rb-macros"
-version = "0.7.5"
+version = "0.8.2"
 dependencies = [
  "proc-macro2",
  "quote",

data/ext/spikard_rb/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "spikard-rb-ext"
-version = "0.8.2"
+version = "0.8.3"
 edition = "2024"
 license = "MIT"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]

data/lib/spikard/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Spikard
-  VERSION = '0.8.2'
+  VERSION = '0.8.3'
 end

data/vendor/crates/spikard-bindings-shared/Cargo.toml

@@ -1,12 +1,20 @@
 [package]
 name = "spikard-bindings-shared"
-version = "0.8.2"
+version = "0.8.3"
 edition = "2024"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
 license = "MIT"
 repository = "https://github.com/Goldziher/spikard"
 homepage = "https://github.com/Goldziher/spikard"
 
+[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 }
+
 [dependencies]
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"

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

@@ -1,6 +1,6 @@
 //! Configuration extraction trait and implementation for language bindings
 //!
-//! This module provides a trait-based abstraction for extracting ServerConfig and related
+//! This module provides a trait-based abstraction for extracting `ServerConfig` and related
 //! configuration structs from language-specific objects (Python dicts, JavaScript objects, etc.)
 //! without duplicating extraction logic across bindings.
 //!
@@ -17,7 +17,7 @@ use std::collections::HashMap;
 /// Trait for reading configuration from language-specific objects
 ///
 /// Bindings implement this trait to provide unified access to configuration values
-/// regardless of the language-specific representation (PyDict, JavaScript Object, etc.).
+/// regardless of the language-specific representation (`PyDict`, JavaScript Object, etc.).
 pub trait ConfigSource {
     /// Get a boolean value from the source
     fn get_bool(&self, key: &str) -> Option<bool>;
@@ -34,7 +34,7 @@ pub trait ConfigSource {
     /// Get a vector of strings from the source
     fn get_vec_string(&self, key: &str) -> Option<Vec<String>>;
 
-    /// Get a nested ConfigSource for nested objects
+    /// Get a nested `ConfigSource` for nested objects
     fn get_nested(&self, key: &str) -> Option<Box<dyn ConfigSource + '_>>;
 
     /// Check if a key exists in the source
@@ -61,11 +61,15 @@ pub trait ConfigSource {
     }
 }
 
-/// Configuration extractor that works with any ConfigSource
+/// Configuration extractor that works with any `ConfigSource`
 pub struct ConfigExtractor;
 
 impl ConfigExtractor {
-    /// Extract a complete ServerConfig from a ConfigSource
+    /// Extract a complete `ServerConfig` from a `ConfigSource`
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if required configuration fields are invalid or missing.
     pub fn extract_server_config(source: &dyn ConfigSource) -> Result<ServerConfig, String> {
         let mut config = ServerConfig::default();
 
@@ -73,10 +77,14 @@ impl ConfigExtractor {
             config.host = host;
         }
 
-        if let Some(port) = source
-            .get_u16("port")
-            .or_else(|| source.get_u32("port").map(|p| p as u16))
-        {
+        if let Some(port) = source.get_u16("port").or_else(|| {
+            source.get_u32("port").map(|p| {
+                #[allow(clippy::cast_possible_truncation)]
+                {
+                    p as u16
+                }
+            })
+        }) {
             config.port = port;
         }
 
@@ -144,7 +152,11 @@ impl ConfigExtractor {
         Ok(config)
     }
 
-    /// Extract CompressionConfig from a ConfigSource
+    /// Extract `CompressionConfig` from a `ConfigSource`
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if required configuration fields are invalid.
     pub fn extract_compression_config(source: &dyn ConfigSource) -> Result<CompressionConfig, String> {
         let gzip = source.get_bool("gzip").unwrap_or(true);
         let brotli = source.get_bool("brotli").unwrap_or(true);
@@ -162,7 +174,11 @@ impl ConfigExtractor {
         })
     }
 
-    /// Extract RateLimitConfig from a ConfigSource
+    /// Extract `RateLimitConfig` from a `ConfigSource`
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if required fields `per_second` or `burst` are missing.
     pub fn extract_rate_limit_config(source: &dyn ConfigSource) -> Result<RateLimitConfig, String> {
         let per_second = source.get_u64("per_second").ok_or("Rate limit requires 'per_second'")?;
 
@@ -177,7 +193,11 @@ impl ConfigExtractor {
         })
     }
 
-    /// Extract JwtConfig from a ConfigSource
+    /// Extract `JwtConfig` from a `ConfigSource`
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the required `secret` field is missing.
     pub fn extract_jwt_config(source: &dyn ConfigSource) -> Result<JwtConfig, String> {
         let secret = source.get_string("secret").ok_or("JWT auth requires 'secret'")?;
 
@@ -198,7 +218,11 @@ impl ConfigExtractor {
         })
     }
 
-    /// Extract ApiKeyConfig from a ConfigSource
+    /// Extract `ApiKeyConfig` from a `ConfigSource`
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the required `keys` field is missing.
     pub fn extract_api_key_config(source: &dyn ConfigSource) -> Result<ApiKeyConfig, String> {
         let keys = source
             .get_vec_string("keys")
@@ -211,7 +235,11 @@ impl ConfigExtractor {
         Ok(ApiKeyConfig { keys, header_name })
     }
 
-    /// Extract static files configuration list from a ConfigSource
+    /// Extract static files configuration list from a `ConfigSource`
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if array elements are invalid or missing required fields.
     pub fn extract_static_files_config(source: &dyn ConfigSource) -> Result<Vec<StaticFilesConfig>, String> {
         let length = source.get_array_length("static_files").unwrap_or(0);
         if length == 0 {
@@ -247,7 +275,11 @@ impl ConfigExtractor {
         Ok(configs)
     }
 
-    /// Extract OpenApiConfig from a ConfigSource
+    /// Extract `OpenApiConfig` from a `ConfigSource`
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if required configuration fields are invalid.
     pub fn extract_openapi_config(source: &dyn ConfigSource) -> Result<OpenApiConfig, String> {
         let enabled = source.get_bool("enabled").unwrap_or(false);
         let title = source.get_string("title").unwrap_or_else(|| "API".to_string());
@@ -279,7 +311,7 @@ impl ConfigExtractor {
 
         let servers = Self::extract_servers_config(source)?;
 
-        let security_schemes = Self::extract_security_schemes_config(source)?;
+        let security_schemes = Self::extract_security_schemes_config(source);
 
         Ok(OpenApiConfig {
             enabled,
@@ -296,7 +328,11 @@ impl ConfigExtractor {
         })
     }
 
-    /// Extract servers list from OpenAPI config
+    /// Extract servers list from `OpenAPI` config
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if array elements are invalid or missing.
     fn extract_servers_config(source: &dyn ConfigSource) -> Result<Vec<ServerInfo>, String> {
         let length = source.get_array_length("servers").unwrap_or(0);
         if length == 0 {
@@ -319,15 +355,17 @@ impl ConfigExtractor {
         Ok(servers)
     }
 
-    /// Extract security schemes from OpenAPI config
-    fn extract_security_schemes_config(
-        _source: &dyn ConfigSource,
-    ) -> Result<HashMap<String, SecuritySchemeInfo>, String> {
+    /// Extract security schemes from `OpenAPI` config
+    fn extract_security_schemes_config(_source: &dyn ConfigSource) -> HashMap<String, SecuritySchemeInfo> {
         // TODO: Implement when bindings support iterating HashMap-like structures
-        Ok(HashMap::new())
+        HashMap::new()
     }
 
-    /// Extract JsonRpcConfig from a ConfigSource
+    /// Extract `JsonRpcConfig` from a `ConfigSource`
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if required configuration fields are invalid.
     pub fn extract_jsonrpc_config(source: &dyn ConfigSource) -> Result<JsonRpcConfig, String> {
         let enabled = source.get_bool("enabled").unwrap_or(true);
         let endpoint_path = source.get_string("endpoint_path").unwrap_or_else(|| "/rpc".to_string());

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

@@ -8,6 +8,10 @@ pub trait FromLanguage: Sized {
     type Error: std::fmt::Display;
 
     /// Convert from a language-specific value
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the value cannot be converted to the expected type.
     fn from_any(value: &(dyn Any + Send + Sync)) -> Result<Self, Self::Error>;
 }
 
@@ -17,6 +21,10 @@ pub trait ToLanguage {
     type Error: std::fmt::Display;
 
     /// Convert to a language-specific value
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the conversion fails.
     fn to_any(&self) -> Result<Box<dyn Any + Send + Sync>, Self::Error>;
 }
 
@@ -26,9 +34,17 @@ pub trait JsonConvertible: Sized {
     type Error: std::fmt::Display;
 
     /// Convert from a JSON value
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the JSON value is not valid for the target type.
     fn from_json(value: serde_json::Value) -> Result<Self, Self::Error>;
 
     /// Convert to a JSON value
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the conversion fails.
     fn to_json(&self) -> Result<serde_json::Value, Self::Error>;
 }
 

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

@@ -33,7 +33,7 @@ pub trait ValueDependencyAdapter: Send + Sync {
 /// Adapter trait for factory dependencies across language bindings
 ///
 /// Language bindings should implement this trait to wrap their
-/// language-specific callable storage (e.g., Py<PyAny>, ThreadsafeFunction, etc.)
+/// language-specific callable storage (e.g., Py<PyAny>, `ThreadsafeFunction`, etc.)
 pub trait FactoryDependencyAdapter: Send + Sync {
     /// Get the dependency key
     fn key(&self) -> &str;

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)
     }

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,7 @@ pub enum HandlerError {
 
 impl From<ValidationError> for HandlerError {
     fn from(err: ValidationError) -> Self {
-        HandlerError::Validation(format!("{:?}", err))
+        Self::Validation(format!("{err:?}"))
     }
 }
 
@@ -54,6 +54,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 +67,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 +89,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 +97,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 +105,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
@@ -119,18 +128,18 @@ impl<L: LanguageHandler + 'static> Handler for HandlerExecutor<L> {
             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)
         })