spikard 0.8.2 → 0.10.1

data/vendor/crates/spikard-core/src/bindings/response.rs

@@ -15,6 +15,8 @@ pub struct RawResponse {
 
 impl RawResponse {
     /// Construct a new response.
+    #[must_use]
+    #[allow(clippy::missing_const_for_fn)]
     pub fn new(status: u16, headers: HashMap<String, String>, body: Vec<u8>) -> Self {
         Self { status, headers, body }
     }
@@ -35,19 +37,13 @@ impl RawResponse {
             return;
         }
 
-        let accept_encoding = header_value(request_headers, "Accept-Encoding").map(|value| value.to_ascii_lowercase());
-        let accepts_brotli = accept_encoding
-            .as_ref()
-            .map(|value| value.contains("br"))
-            .unwrap_or(false);
+        let accept_encoding = header_value(request_headers, "Accept-Encoding").map(str::to_ascii_lowercase);
+        let accepts_brotli = accept_encoding.as_ref().is_some_and(|value| value.contains("br"));
         if compression.brotli && accepts_brotli && self.try_compress_brotli(compression) {
             return;
         }
 
-        let accepts_gzip = accept_encoding
-            .as_ref()
-            .map(|value| value.contains("gzip"))
-            .unwrap_or(false);
+        let accepts_gzip = accept_encoding.as_ref().is_some_and(|value| value.contains("gzip"));
         if compression.gzip && accepts_gzip {
             self.try_compress_gzip(compression);
         }
@@ -110,6 +106,7 @@ pub struct StaticAsset {
 
 impl StaticAsset {
     /// Build a response snapshot if the incoming request targets this asset.
+    #[must_use]
     pub fn serve(&self, method: &str, normalized_path: &str) -> Option<RawResponse> {
         if !method.eq_ignore_ascii_case("GET") && !method.eq_ignore_ascii_case("HEAD") {
             return None;

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

@@ -1,8 +1,8 @@
 //! Debug logging utilities for spikard-http
 //!
 //! This module provides debug logging that can be enabled via:
-//! - Building in debug mode (cfg(debug_assertions))
-//! - Setting SPIKARD_DEBUG=1 environment variable
+//! - Building in debug mode (`cfg(debug_assertions)`)
+//! - Setting `SPIKARD_DEBUG=1` environment variable
 
 use std::sync::atomic::{AtomicBool, Ordering};
 

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

@@ -365,7 +365,7 @@ impl std::fmt::Debug for DependencyContainer {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("DependencyContainer")
             .field("dependencies", &self.dependencies.keys())
-            .finish()
+            .finish_non_exhaustive()
     }
 }
 
@@ -696,7 +696,7 @@ mod tests {
         let dep = ValueDependency::new("test", 42i32);
         container.register("test".to_string(), Arc::new(dep)).unwrap();
 
-        let debug_str = format!("{:?}", container);
+        let debug_str = format!("{container:?}");
         assert!(debug_str.contains("DependencyContainer"));
     }
 }

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

@@ -33,7 +33,7 @@ pub enum DependencyError {
     /// ```
     #[error("Circular dependency detected: {cycle:?}")]
     CircularDependency {
-        /// The cycle of dependencies (e.g., ["A", "B", "C", "A"])
+        /// The cycle of dependencies (e.g., `["A", "B", "C", "A"]`)
         cycle: Vec<String>,
     },
 

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

@@ -134,7 +134,7 @@ impl std::fmt::Debug for FactoryDependency {
             .field("dependencies", &self.dependencies)
             .field("cacheable", &self.cacheable)
             .field("singleton", &self.singleton)
-            .finish()
+            .finish_non_exhaustive()
     }
 }
 
@@ -209,6 +209,7 @@ impl FactoryDependencyBuilder {
     ///     })
     ///     .build();
     /// ```
+    #[must_use]
     pub fn factory<F>(mut self, factory: F) -> Self
     where
         F: Fn(
@@ -245,6 +246,7 @@ impl FactoryDependencyBuilder {
     ///     })
     ///     .build();
     /// ```
+    #[must_use]
     pub fn depends_on(mut self, dependencies: Vec<String>) -> Self {
         self.dependencies = dependencies;
         self
@@ -272,7 +274,8 @@ impl FactoryDependencyBuilder {
     ///     .cacheable(true)  // Same ID for all uses in one request
     ///     .build();
     /// ```
-    pub fn cacheable(mut self, cacheable: bool) -> Self {
+    #[must_use]
+    pub const fn cacheable(mut self, cacheable: bool) -> Self {
         self.cacheable = cacheable;
         self
     }
@@ -300,7 +303,8 @@ impl FactoryDependencyBuilder {
     ///     .singleton(true)  // Share across all requests
     ///     .build();
     /// ```
-    pub fn singleton(mut self, singleton: bool) -> Self {
+    #[must_use]
+    pub const fn singleton(mut self, singleton: bool) -> Self {
         self.singleton = singleton;
         self
     }
@@ -436,7 +440,7 @@ mod tests {
                     let config: Option<Arc<String>> = resolved.get("config");
                     let config_value = config.map(|c| (*c).clone()).unwrap_or_default();
 
-                    Ok(Arc::new(format!("Service using {}", config_value)) as Arc<dyn Any + Send + Sync>)
+                    Ok(Arc::new(format!("Service using {config_value}")) as Arc<dyn Any + Send + Sync>)
                 })
             })
             .build();
@@ -520,7 +524,7 @@ mod tests {
             .singleton(false)
             .build();
 
-        let debug_str = format!("{:?}", factory);
+        let debug_str = format!("{factory:?}");
         assert!(debug_str.contains("FactoryDependency"));
         assert!(debug_str.contains("test"));
         assert!(debug_str.contains("dep1"));

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

@@ -133,6 +133,7 @@ impl DependencyGraph {
     /// // Adding c -> [] would not
     /// assert!(!graph.has_cycle_with("c", &[]));
     /// ```
+    #[must_use]
     pub fn has_cycle_with(&self, new_key: &str, new_deps: &[String]) -> bool {
         let mut temp_graph = self.graph.clone();
         temp_graph.insert(new_key.to_string(), new_deps.to_vec());

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

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

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

@@ -134,6 +134,7 @@ impl<T: Clone + Send + Sync + 'static> std::fmt::Debug for ValueDependency<T> {
         f.debug_struct("ValueDependency")
             .field("key", &self.key)
             .field("value_type", &std::any::type_name::<T>())
+            .field("value", &"<T>")
             .finish()
     }
 }
@@ -274,7 +275,7 @@ mod tests {
     #[test]
     fn test_debug() {
         let dep = ValueDependency::new("test", 42i32);
-        let debug_str = format!("{:?}", dep);
+        let debug_str = format!("{dep:?}");
         assert!(debug_str.contains("ValueDependency"));
         assert!(debug_str.contains("test"));
     }

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

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

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

@@ -1,5 +1,6 @@
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
+use std::sync::OnceLock;
 
 /// HTTP method
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
@@ -15,16 +16,17 @@ pub enum Method {
 }
 
 impl Method {
-    pub fn as_str(&self) -> &'static str {
+    #[must_use]
+    pub const fn as_str(&self) -> &'static str {
         match self {
-            Method::Get => "GET",
-            Method::Post => "POST",
-            Method::Put => "PUT",
-            Method::Patch => "PATCH",
-            Method::Delete => "DELETE",
-            Method::Head => "HEAD",
-            Method::Options => "OPTIONS",
-            Method::Trace => "TRACE",
+            Self::Get => "GET",
+            Self::Post => "POST",
+            Self::Put => "PUT",
+            Self::Patch => "PATCH",
+            Self::Delete => "DELETE",
+            Self::Head => "HEAD",
+            Self::Options => "OPTIONS",
+            Self::Trace => "TRACE",
         }
     }
 }
@@ -40,15 +42,15 @@ impl std::str::FromStr for Method {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s.to_uppercase().as_str() {
-            "GET" => Ok(Method::Get),
-            "POST" => Ok(Method::Post),
-            "PUT" => Ok(Method::Put),
-            "PATCH" => Ok(Method::Patch),
-            "DELETE" => Ok(Method::Delete),
-            "HEAD" => Ok(Method::Head),
-            "OPTIONS" => Ok(Method::Options),
-            "TRACE" => Ok(Method::Trace),
-            _ => Err(format!("Unknown HTTP method: {}", s)),
+            "GET" => Ok(Self::Get),
+            "POST" => Ok(Self::Post),
+            "PUT" => Ok(Self::Put),
+            "PATCH" => Ok(Self::Patch),
+            "DELETE" => Ok(Self::Delete),
+            "HEAD" => Ok(Self::Head),
+            "OPTIONS" => Ok(Self::Options),
+            "TRACE" => Ok(Self::Trace),
+            _ => Err(format!("Unknown HTTP method: {s}")),
         }
     }
 }
@@ -66,6 +68,73 @@ pub struct CorsConfig {
     pub max_age: Option<u32>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub allow_credentials: Option<bool>,
+
+    // Optimized caches (lazy-initialized on first use)
+    #[serde(skip)]
+    #[doc(hidden)]
+    pub methods_joined_cache: OnceLock<String>,
+    #[serde(skip)]
+    #[doc(hidden)]
+    pub headers_joined_cache: OnceLock<String>,
+}
+
+impl CorsConfig {
+    /// Get the cached joined methods string for preflight responses
+    pub fn allowed_methods_joined(&self) -> &str {
+        self.methods_joined_cache
+            .get_or_init(|| self.allowed_methods.join(", "))
+    }
+
+    /// Get the cached joined headers string for preflight responses
+    pub fn allowed_headers_joined(&self) -> &str {
+        self.headers_joined_cache
+            .get_or_init(|| self.allowed_headers.join(", "))
+    }
+
+    /// Check if an origin is allowed (O(1) with wildcard, O(n) for exact match)
+    pub fn is_origin_allowed(&self, origin: &str) -> bool {
+        if origin.is_empty() {
+            return false;
+        }
+        self.allowed_origins.iter().any(|o| o == "*" || o == origin)
+    }
+
+    /// Check if a method is allowed (O(1) with wildcard, O(n) for exact match)
+    pub fn is_method_allowed(&self, method: &str) -> bool {
+        self.allowed_methods
+            .iter()
+            .any(|m| m == "*" || m.eq_ignore_ascii_case(method))
+    }
+
+    /// Check if all requested headers are allowed (O(n) where n = num requested headers)
+    pub fn are_headers_allowed(&self, requested: &[&str]) -> bool {
+        // Check if wildcard is set
+        if self.allowed_headers.iter().any(|h| h == "*") {
+            return true;
+        }
+
+        // Check each requested header
+        requested.iter().all(|req_header| {
+            self.allowed_headers
+                .iter()
+                .any(|h| h.to_lowercase() == req_header.to_lowercase())
+        })
+    }
+}
+
+impl Default for CorsConfig {
+    fn default() -> Self {
+        Self {
+            allowed_origins: vec!["*".to_string()],
+            allowed_methods: vec!["*".to_string()],
+            allowed_headers: vec![],
+            expose_headers: None,
+            max_age: None,
+            allow_credentials: None,
+            methods_joined_cache: OnceLock::new(),
+            headers_joined_cache: OnceLock::new(),
+        }
+    }
 }
 
 /// Route metadata extracted from bindings
@@ -92,6 +161,11 @@ pub struct RouteMetadata {
     /// JSON-RPC method metadata (if this route is exposed as a JSON-RPC method)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub jsonrpc_method: Option<Value>,
+    /// Optional static response configuration: `{"status": 200, "body": "OK", "content_type": "text/plain"}`
+    /// When present, the handler is replaced by a `StaticResponseHandler` that bypasses the full
+    /// middleware pipeline for maximum throughput.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub static_response: Option<Value>,
 }
 
 /// Compression configuration shared across runtimes
@@ -385,6 +459,7 @@ mod tests {
             expose_headers: None,
             max_age: None,
             allow_credentials: None,
+            ..Default::default()
         };
         assert_eq!(cors.allowed_origins.len(), 1);
         assert_eq!(cors.allowed_methods.len(), 2);
@@ -407,6 +482,7 @@ mod tests {
             #[cfg(feature = "di")]
             handler_dependencies: None,
             jsonrpc_method: None,
+            static_response: None,
         };
         assert_eq!(metadata.method, "GET");
         assert_eq!(metadata.path, "/api/users");