spikard 0.8.1 → 0.8.3

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
     }

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

@@ -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();

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

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

@@ -15,16 +15,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 +41,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}")),
         }
     }
 }

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

@@ -29,10 +29,10 @@ pub trait NativeLifecycleHook<Req, Resp>: Send + Sync {
     fn name(&self) -> &str;
 
     /// Execute hook with a request
-    fn execute_request<'a>(&'a self, req: Req) -> RequestHookFutureSend<'a, Req, Resp>;
+    fn execute_request<'a>(&self, req: Req) -> RequestHookFutureSend<'a, Req, Resp>;
 
     /// Execute hook with a response
-    fn execute_response<'a>(&'a self, resp: Resp) -> ResponseHookFutureSend<'a, Resp>;
+    fn execute_response<'a>(&self, resp: Resp) -> ResponseHookFutureSend<'a, Resp>;
 }
 
 /// Trait for lifecycle hooks on local (wasm) targets (no Send requirements).
@@ -41,10 +41,10 @@ pub trait LocalLifecycleHook<Req, Resp> {
     fn name(&self) -> &str;
 
     /// Execute hook with a request
-    fn execute_request<'a>(&'a self, req: Req) -> RequestHookFutureLocal<'a, Req, Resp>;
+    fn execute_request<'a>(&self, req: Req) -> RequestHookFutureLocal<'a, Req, Resp>;
 
     /// Execute hook with a response
-    fn execute_response<'a>(&'a self, resp: Resp) -> ResponseHookFutureLocal<'a, Resp>;
+    fn execute_response<'a>(&self, resp: Resp) -> ResponseHookFutureLocal<'a, Resp>;
 }
 
 #[cfg(target_arch = "wasm32")]
@@ -97,17 +97,19 @@ impl<Req, Resp> std::fmt::Debug for LifecycleHooks<Req, Resp> {
 
 impl<Req, Resp> LifecycleHooks<Req, Resp> {
     /// Create a new empty hooks container
+    #[must_use]
     pub fn new() -> Self {
         Self::default()
     }
 
     /// Builder constructor for ergonomic hook registration
+    #[must_use]
     pub fn builder() -> LifecycleHooksBuilder<Req, Resp> {
         LifecycleHooksBuilder::new()
     }
 
     /// Check if any hooks are registered
-    #[inline(always)]
+    #[must_use]
     pub fn is_empty(&self) -> bool {
         self.on_request.is_empty()
             && self.pre_validation.is_empty()
@@ -136,6 +138,8 @@ impl<Req, Resp> LifecycleHooks<Req, Resp> {
         self.on_error.push(hook);
     }
 
+    /// # Errors
+    /// Returns an error string if a hook execution fails.
     pub async fn execute_on_request(&self, mut req: Req) -> Result<HookResult<Req, Resp>, String> {
         if self.on_request.is_empty() {
             return Ok(HookResult::Continue(req));
@@ -151,6 +155,8 @@ impl<Req, Resp> LifecycleHooks<Req, Resp> {
         Ok(HookResult::Continue(req))
     }
 
+    /// # Errors
+    /// Returns an error string if a hook execution fails.
     pub async fn execute_pre_validation(&self, mut req: Req) -> Result<HookResult<Req, Resp>, String> {
         if self.pre_validation.is_empty() {
             return Ok(HookResult::Continue(req));
@@ -166,6 +172,8 @@ impl<Req, Resp> LifecycleHooks<Req, Resp> {
         Ok(HookResult::Continue(req))
     }
 
+    /// # Errors
+    /// Returns an error string if a hook execution fails.
     pub async fn execute_pre_handler(&self, mut req: Req) -> Result<HookResult<Req, Resp>, String> {
         if self.pre_handler.is_empty() {
             return Ok(HookResult::Continue(req));
@@ -181,6 +189,8 @@ impl<Req, Resp> LifecycleHooks<Req, Resp> {
         Ok(HookResult::Continue(req))
     }
 
+    /// # Errors
+    /// Returns an error string if a hook execution fails.
     pub async fn execute_on_response(&self, mut resp: Resp) -> Result<Resp, String> {
         if self.on_response.is_empty() {
             return Ok(resp);
@@ -188,14 +198,15 @@ impl<Req, Resp> LifecycleHooks<Req, Resp> {
 
         for hook in &self.on_response {
             match hook.execute_response(resp).await? {
-                HookResult::Continue(r) => resp = r,
-                HookResult::ShortCircuit(r) => resp = r,
+                HookResult::Continue(r) | HookResult::ShortCircuit(r) => resp = r,
             }
         }
 
         Ok(resp)
     }
 
+    /// # Errors
+    /// Returns an error string if a hook execution fails.
     pub async fn execute_on_error(&self, mut resp: Resp) -> Result<Resp, String> {
         if self.on_error.is_empty() {
             return Ok(resp);
@@ -203,8 +214,7 @@ impl<Req, Resp> LifecycleHooks<Req, Resp> {
 
         for hook in &self.on_error {
             match hook.execute_response(resp).await? {
-                HookResult::Continue(r) => resp = r,
-                HookResult::ShortCircuit(r) => resp = r,
+                HookResult::Continue(r) | HookResult::ShortCircuit(r) => resp = r,
             }
         }
 
@@ -237,11 +247,11 @@ where
         &self.name
     }
 
-    fn execute_request<'a>(&'a self, req: Req) -> RequestHookFutureSend<'a, Req, Resp> {
+    fn execute_request<'a>(&self, req: Req) -> RequestHookFutureSend<'a, Req, Resp> {
         Box::pin((self.func)(req))
     }
 
-    fn execute_response<'a>(&'a self, _resp: Resp) -> ResponseHookFutureSend<'a, Resp> {
+    fn execute_response<'a>(&self, _resp: Resp) -> ResponseHookFutureSend<'a, Resp> {
         Box::pin(async move { Err("Request hook called with response - this is a bug".to_string()) })
     }
 }
@@ -258,11 +268,11 @@ where
         &self.name
     }
 
-    fn execute_request<'a>(&'a self, req: Req) -> RequestHookFutureLocal<'a, Req, Resp> {
+    fn execute_request<'a>(&self, req: Req) -> RequestHookFutureLocal<'a, Req, Resp> {
         Box::pin((self.func)(req))
     }
 
-    fn execute_response<'a>(&'a self, _resp: Resp) -> ResponseHookFutureLocal<'a, Resp> {
+    fn execute_response<'a>(&self, _resp: Resp) -> ResponseHookFutureLocal<'a, Resp> {
         Box::pin(async move { Err("Request hook called with response - this is a bug".to_string()) })
     }
 }
@@ -279,11 +289,11 @@ where
         &self.name
     }
 
-    fn execute_request<'a>(&'a self, _req: Req) -> RequestHookFutureSend<'a, Req, Resp> {
+    fn execute_request<'a>(&self, _req: Req) -> RequestHookFutureSend<'a, Req, Resp> {
         Box::pin(async move { Err("Response hook called with request - this is a bug".to_string()) })
     }
 
-    fn execute_response<'a>(&'a self, resp: Resp) -> ResponseHookFutureSend<'a, Resp> {
+    fn execute_response<'a>(&self, resp: Resp) -> ResponseHookFutureSend<'a, Resp> {
         Box::pin((self.func)(resp))
     }
 }
@@ -300,52 +310,66 @@ where
         &self.name
     }
 
-    fn execute_request<'a>(&'a self, _req: Req) -> RequestHookFutureLocal<'a, Req, Resp> {
+    fn execute_request<'a>(&self, _req: Req) -> RequestHookFutureLocal<'a, Req, Resp> {
         Box::pin(async move { Err("Response hook called with request - this is a bug".to_string()) })
     }
 
-    fn execute_response<'a>(&'a self, resp: Resp) -> ResponseHookFutureLocal<'a, Resp> {
+    fn execute_response<'a>(&self, resp: Resp) -> ResponseHookFutureLocal<'a, Resp> {
         Box::pin((self.func)(resp))
     }
 }
 
-/// Builder Pattern for LifecycleHooks
+/// Builder pattern for `LifecycleHooks`
 pub struct LifecycleHooksBuilder<Req, Resp> {
     hooks: LifecycleHooks<Req, Resp>,
 }
 
 impl<Req, Resp> LifecycleHooksBuilder<Req, Resp> {
+    /// Create a new builder
+    #[must_use]
     pub fn new() -> Self {
         Self {
             hooks: LifecycleHooks::default(),
         }
     }
 
+    /// Add an `on_request` hook
+    #[must_use]
     pub fn on_request(mut self, hook: Arc<CoreHook<Req, Resp>>) -> Self {
         self.hooks.add_on_request(hook);
         self
     }
 
+    /// Add a `pre_validation` hook
+    #[must_use]
     pub fn pre_validation(mut self, hook: Arc<CoreHook<Req, Resp>>) -> Self {
         self.hooks.add_pre_validation(hook);
         self
     }
 
+    /// Add a `pre_handler` hook
+    #[must_use]
     pub fn pre_handler(mut self, hook: Arc<CoreHook<Req, Resp>>) -> Self {
         self.hooks.add_pre_handler(hook);
         self
     }
 
+    /// Add an `on_response` hook
+    #[must_use]
     pub fn on_response(mut self, hook: Arc<CoreHook<Req, Resp>>) -> Self {
         self.hooks.add_on_response(hook);
         self
     }
 
+    /// Add an `on_error` hook
+    #[must_use]
     pub fn on_error(mut self, hook: Arc<CoreHook<Req, Resp>>) -> Self {
         self.hooks.add_on_error(hook);
         self
     }
 
+    /// Build the `LifecycleHooks` instance
+    #[must_use]
     pub fn build(self) -> LifecycleHooks<Req, Resp> {
         self.hooks
     }

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

@@ -181,11 +181,7 @@ pub fn parse_parameter_schema(schema: &Value) -> Result<Vec<ParameterMetadata>,
     let required: Vec<String> = schema
         .get("required")
         .and_then(|r| r.as_array())
-        .map(|arr| {
-            arr.iter()
-                .filter_map(|v| v.as_str().map(String::from))
-                .collect()
-        })
+        .map(|arr| arr.iter().filter_map(|v| v.as_str().map(String::from)).collect())
         .unwrap_or_default();
 
     for (param_name, param_schema) in props {
@@ -197,10 +193,7 @@ pub fn parse_parameter_schema(schema: &Value) -> Result<Vec<ParameterMetadata>,
             .and_then(|s| s.parse().ok())
             .unwrap_or(ParameterSource::Query);
 
-        let schema_type = param_schema
-            .get("type")
-            .and_then(|t| t.as_str())
-            .map(String::from);
+        let schema_type = param_schema.get("type").and_then(|t| t.as_str()).map(String::from);
 
         params.push(ParameterMetadata {
             name: param_name.clone(),
@@ -242,11 +235,7 @@ pub fn validate_metadata(metadata: &ExtractedRouteMetadata) -> Result<(), Vec<St
         }
     }
 
-    if errors.is_empty() {
-        Ok(())
-    } else {
-        Err(errors)
-    }
+    if errors.is_empty() { Ok(()) } else { Err(errors) }
 }
 
 /// Merge path parameters with parameter schema