spikard 0.2.5 → 0.3.1

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

@@ -1,283 +0,0 @@
-//! Value dependency implementation
-//!
-//! This module provides `ValueDependency<T>`, a simple dependency that wraps
-//! a static value and returns it whenever resolved.
-
-use super::dependency::Dependency;
-use super::error::DependencyError;
-use super::resolved::ResolvedDependencies;
-use crate::request_data::RequestData;
-use http::Request;
-use std::any::Any;
-use std::future::Future;
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::sync::Arc;
-
-/// A dependency that wraps a static value
-///
-/// This is the simplest form of dependency - it just returns a pre-configured
-/// value whenever resolved. Useful for configuration values, constants, or
-/// pre-built objects.
-///
-/// # Type Parameters
-///
-/// * `T` - The type of value to provide. Must be `Clone + Send + Sync + 'static`.
-///
-/// # Examples
-///
-/// ```ignore
-/// use spikard_core::di::{Dependency, ValueDependency};
-/// use http::Request;
-/// use crate::request_data::RequestData;
-/// use std::collections::HashMap;
-/// use std::sync::Arc;
-///
-/// # tokio_test::block_on(async {
-/// // Create a value dependency with a configuration string
-/// let config = ValueDependency::new("database_url", "postgresql://localhost/mydb");
-///
-/// // Resolve it (returns the same value every time)
-/// let request = Request::builder().body(()).unwrap();
-/// let request_data = RequestData {
-///     path_params: Arc::new(HashMap::new()),
-///     query_params: serde_json::Value::Null,
-///     raw_query_params: Arc::new(HashMap::new()),
-///     body: serde_json::Value::Null,
-///     raw_body: None,
-///     headers: Arc::new(HashMap::new()),
-///     cookies: Arc::new(HashMap::new()),
-///     method: "GET".to_string(),
-///     path: "/".to_string(),
-/// };
-/// let resolved = spikard_core::di::ResolvedDependencies::new();
-///
-/// let result = config.resolve(&request, &request_data, &resolved).await.unwrap();
-/// let value: Arc<String> = result.downcast().unwrap();
-/// assert_eq!(*value, "postgresql://localhost/mydb");
-/// # });
-/// ```
-pub struct ValueDependency<T: Clone + Send + Sync + 'static> {
-    key: String,
-    value: Arc<T>,
-    _phantom: PhantomData<T>,
-}
-
-impl<T: Clone + Send + Sync + 'static> ValueDependency<T> {
-    /// Create a new value dependency
-    ///
-    /// # Arguments
-    ///
-    /// * `key` - The unique key for this dependency
-    /// * `value` - The value to provide when resolved
-    ///
-    /// # Examples
-    ///
-    /// ```ignore
-    /// use spikard_core::di::ValueDependency;
-    ///
-    /// // Simple value
-    /// let port = ValueDependency::new("port", 8080u16);
-    ///
-    /// // Complex value
-    /// #[derive(Clone)]
-    /// struct Config {
-    ///     debug: bool,
-    ///     timeout: u64,
-    /// }
-    ///
-    /// let config = ValueDependency::new("config", Config {
-    ///     debug: true,
-    ///     timeout: 30,
-    /// });
-    /// ```
-    pub fn new(key: impl Into<String>, value: T) -> Self {
-        Self {
-            key: key.into(),
-            value: Arc::new(value),
-            _phantom: PhantomData,
-        }
-    }
-}
-
-impl<T: Clone + Send + Sync + 'static> Dependency for ValueDependency<T> {
-    fn resolve(
-        &self,
-        _request: &Request<()>,
-        _request_data: &RequestData,
-        _resolved: &ResolvedDependencies,
-    ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn Any + Send + Sync>, DependencyError>> + Send>> {
-        let value = Arc::clone(&self.value);
-        Box::pin(async move { Ok(value as Arc<dyn Any + Send + Sync>) })
-    }
-
-    fn key(&self) -> &str {
-        &self.key
-    }
-
-    fn depends_on(&self) -> Vec<String> {
-        // Value dependencies have no dependencies
-        vec![]
-    }
-
-    fn cacheable(&self) -> bool {
-        // Values are inherently cacheable (they never change)
-        true
-    }
-
-    fn singleton(&self) -> bool {
-        // Values can be singletons (they never change)
-        true
-    }
-}
-
-impl<T: Clone + Send + Sync + 'static> std::fmt::Debug for ValueDependency<T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("ValueDependency")
-            .field("key", &self.key)
-            .field("value_type", &std::any::type_name::<T>())
-            .finish()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::collections::HashMap;
-
-    fn make_request_data() -> RequestData {
-        RequestData {
-            path_params: Arc::new(HashMap::new()),
-            query_params: serde_json::Value::Null,
-            raw_query_params: Arc::new(HashMap::new()),
-            body: serde_json::Value::Null,
-            raw_body: None,
-            headers: Arc::new(HashMap::new()),
-            cookies: Arc::new(HashMap::new()),
-            method: "GET".to_string(),
-            path: "/".to_string(),
-            #[cfg(feature = "di")]
-            dependencies: None,
-        }
-    }
-
-    #[test]
-    fn test_new() {
-        let dep = ValueDependency::new("test", 42i32);
-        assert_eq!(dep.key(), "test");
-    }
-
-    #[test]
-    fn test_key() {
-        let dep = ValueDependency::new("my_key", "value");
-        assert_eq!(dep.key(), "my_key");
-    }
-
-    #[test]
-    fn test_depends_on() {
-        let dep = ValueDependency::new("test", 42i32);
-        assert_eq!(dep.depends_on(), Vec::<String>::new());
-    }
-
-    #[test]
-    fn test_cacheable() {
-        let dep = ValueDependency::new("test", 42i32);
-        assert!(dep.cacheable());
-    }
-
-    #[test]
-    fn test_singleton() {
-        let dep = ValueDependency::new("test", 42i32);
-        assert!(dep.singleton());
-    }
-
-    #[tokio::test]
-    async fn test_resolve_simple() {
-        let dep = ValueDependency::new("answer", 42i32);
-        let request = Request::builder().body(()).unwrap();
-        let request_data = make_request_data();
-        let resolved = ResolvedDependencies::new();
-
-        let result = dep.resolve(&request, &request_data, &resolved).await;
-        assert!(result.is_ok());
-
-        let value: Arc<i32> = result.unwrap().downcast().unwrap();
-        assert_eq!(*value, 42);
-    }
-
-    #[tokio::test]
-    async fn test_resolve_string() {
-        let dep = ValueDependency::new("message", "Hello, World!".to_string());
-        let request = Request::builder().body(()).unwrap();
-        let request_data = make_request_data();
-        let resolved = ResolvedDependencies::new();
-
-        let result = dep.resolve(&request, &request_data, &resolved).await;
-        assert!(result.is_ok());
-
-        let value: Arc<String> = result.unwrap().downcast().unwrap();
-        assert_eq!(*value, "Hello, World!");
-    }
-
-    #[tokio::test]
-    async fn test_resolve_concurrent() {
-        let dep = Arc::new(ValueDependency::new("shared", 100i32));
-        let request = Request::builder().body(()).unwrap();
-        let request_data = make_request_data();
-
-        // Resolve concurrently from multiple tasks
-        let handles: Vec<_> = (0..10)
-            .map(|_| {
-                let dep = Arc::clone(&dep);
-                let req = request.clone();
-                let data = request_data.clone();
-                tokio::spawn(async move {
-                    let resolved = ResolvedDependencies::new();
-                    let result = dep.resolve(&req, &data, &resolved).await.unwrap();
-                    let value: Arc<i32> = result.downcast().unwrap();
-                    *value
-                })
-            })
-            .collect();
-
-        for handle in handles {
-            let value = handle.await.unwrap();
-            assert_eq!(value, 100);
-        }
-    }
-
-    #[derive(Clone, Debug, PartialEq)]
-    struct ComplexValue {
-        name: String,
-        count: i32,
-        tags: Vec<String>,
-    }
-
-    #[tokio::test]
-    async fn test_resolve_complex_type() {
-        let complex = ComplexValue {
-            name: "test".to_string(),
-            count: 42,
-            tags: vec!["tag1".to_string(), "tag2".to_string()],
-        };
-
-        let dep = ValueDependency::new("complex", complex.clone());
-        let request = Request::builder().body(()).unwrap();
-        let request_data = make_request_data();
-        let resolved = ResolvedDependencies::new();
-
-        let result = dep.resolve(&request, &request_data, &resolved).await;
-        assert!(result.is_ok());
-
-        let value: Arc<ComplexValue> = result.unwrap().downcast().unwrap();
-        assert_eq!(*value, complex);
-    }
-
-    #[test]
-    fn test_debug() {
-        let dep = ValueDependency::new("test", 42i32);
-        let debug_str = format!("{:?}", dep);
-        assert!(debug_str.contains("ValueDependency"));
-        assert!(debug_str.contains("test"));
-    }
-}

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

@@ -1,153 +0,0 @@
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-
-/// HTTP method
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub enum Method {
-    Get,
-    Post,
-    Put,
-    Patch,
-    Delete,
-    Head,
-    Options,
-    Trace,
-}
-
-impl Method {
-    pub 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",
-        }
-    }
-}
-
-impl std::fmt::Display for Method {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.as_str())
-    }
-}
-
-impl std::str::FromStr for Method {
-    type Err = String;
-
-    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)),
-        }
-    }
-}
-
-/// CORS configuration for a route
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct CorsConfig {
-    pub allowed_origins: Vec<String>,
-    pub allowed_methods: Vec<String>,
-    #[serde(default)]
-    pub allowed_headers: Vec<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub expose_headers: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub max_age: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub allow_credentials: Option<bool>,
-}
-
-/// Route metadata extracted from bindings
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct RouteMetadata {
-    pub method: String,
-    pub path: String,
-    pub handler_name: String,
-    pub request_schema: Option<Value>,
-    pub response_schema: Option<Value>,
-    pub parameter_schema: Option<Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub file_params: Option<Value>,
-    pub is_async: bool,
-    pub cors: Option<CorsConfig>,
-    /// Name of the body parameter (defaults to "body" if not specified)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub body_param_name: Option<String>,
-    /// List of dependency keys this handler requires (for DI)
-    #[cfg(feature = "di")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub handler_dependencies: Option<Vec<String>>,
-}
-
-/// Compression configuration shared across runtimes
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct CompressionConfig {
-    /// Enable gzip compression
-    #[serde(default = "default_true")]
-    pub gzip: bool,
-    /// Enable brotli compression
-    #[serde(default = "default_true")]
-    pub brotli: bool,
-    /// Minimum response size to compress (bytes)
-    #[serde(default = "default_compression_min_size")]
-    pub min_size: usize,
-    /// Compression quality (0-11 for brotli, 0-9 for gzip)
-    #[serde(default = "default_compression_quality")]
-    pub quality: u32,
-}
-
-const fn default_true() -> bool {
-    true
-}
-
-const fn default_compression_min_size() -> usize {
-    1024
-}
-
-const fn default_compression_quality() -> u32 {
-    6
-}
-
-impl Default for CompressionConfig {
-    fn default() -> Self {
-        Self {
-            gzip: true,
-            brotli: true,
-            min_size: default_compression_min_size(),
-            quality: default_compression_quality(),
-        }
-    }
-}
-
-/// Rate limiting configuration shared across runtimes
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct RateLimitConfig {
-    /// Requests per second
-    pub per_second: u64,
-    /// Burst allowance
-    pub burst: u32,
-    /// Use IP-based rate limiting
-    #[serde(default = "default_true")]
-    pub ip_based: bool,
-}
-
-impl Default for RateLimitConfig {
-    fn default() -> Self {
-        Self {
-            per_second: 100,
-            burst: 200,
-            ip_based: true,
-        }
-    }
-}

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

@@ -1,28 +0,0 @@
-pub mod bindings;
-pub mod debug;
-#[cfg(feature = "di")]
-pub mod di;
-pub mod http;
-pub mod lifecycle;
-pub mod parameters;
-pub mod problem;
-pub mod request_data;
-pub mod router;
-pub mod schema_registry;
-pub mod type_hints;
-pub mod validation;
-
-pub use bindings::response::{RawResponse, StaticAsset};
-#[cfg(feature = "di")]
-pub use di::{
-    Dependency, DependencyContainer, DependencyError, DependencyGraph, FactoryDependency, FactoryDependencyBuilder,
-    ResolvedDependencies, ValueDependency,
-};
-pub use http::{CompressionConfig, CorsConfig, Method, RateLimitConfig, RouteMetadata};
-pub use lifecycle::{HookResult, LifecycleHook, LifecycleHooks, LifecycleHooksBuilder, request_hook, response_hook};
-pub use parameters::ParameterValidator;
-pub use problem::ProblemDetails;
-pub use request_data::RequestData;
-pub use router::{Route, RouteHandler, Router};
-pub use schema_registry::SchemaRegistry;
-pub use validation::{SchemaValidator, ValidationError, ValidationErrorDetail};