spikard 0.12.0 → 0.15.2

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

@@ -1,210 +0,0 @@
-//! Language-agnostic conversion interfaces
-
-use std::any::Any;
-
-/// Trait for converting from language-specific types to Rust types
-pub trait FromLanguage: Sized {
-    /// The error type for conversion failures
-    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>;
-}
-
-/// Trait for converting from Rust types to language-specific types
-pub trait ToLanguage {
-    /// The error type for conversion failures
-    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>;
-}
-
-/// Trait for converting to/from JSON values
-pub trait JsonConvertible: Sized {
-    /// The error type for conversion failures
-    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>;
-}
-
-/// Default JSON conversion error
-#[derive(Debug)]
-pub struct JsonConversionError(pub String);
-
-impl std::fmt::Display for JsonConversionError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "JSON conversion error: {}", self.0)
-    }
-}
-
-/// Default implementation for JSON values
-impl JsonConvertible for serde_json::Value {
-    type Error = JsonConversionError;
-
-    fn from_json(value: serde_json::Value) -> Result<Self, Self::Error> {
-        Ok(value)
-    }
-
-    fn to_json(&self) -> Result<serde_json::Value, Self::Error> {
-        Ok(self.clone())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use serde_json::json;
-
-    #[derive(Debug)]
-    struct TestType {
-        value: i32,
-    }
-
-    impl FromLanguage for TestType {
-        type Error = String;
-
-        fn from_any(value: &(dyn Any + Send + Sync)) -> Result<Self, Self::Error> {
-            value
-                .downcast_ref::<i32>()
-                .map(|&v| Self { value: v })
-                .ok_or_else(|| "Invalid type".to_string())
-        }
-    }
-
-    impl ToLanguage for TestType {
-        type Error = String;
-
-        fn to_any(&self) -> Result<Box<dyn Any + Send + Sync>, Self::Error> {
-            Ok(Box::new(self.value))
-        }
-    }
-
-    #[test]
-    fn test_json_conversion_error_display() {
-        let err = JsonConversionError("test error".to_string());
-        assert_eq!(err.to_string(), "JSON conversion error: test error");
-    }
-
-    #[test]
-    fn test_json_value_from_json() {
-        let input = json!({ "key": "value" });
-        let result = serde_json::Value::from_json(input.clone());
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), input);
-    }
-
-    #[test]
-    fn test_json_value_to_json() {
-        let input = json!({ "key": "value" });
-        let result = serde_json::Value::to_json(&input);
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), input);
-    }
-
-    #[test]
-    fn test_json_value_roundtrip() {
-        let original = json!({
-            "string": "test",
-            "number": 42,
-            "float": 3.2,
-            "bool": true,
-            "null": null,
-            "array": [1, 2, 3],
-            "object": { "nested": "value" }
-        });
-
-        let converted = serde_json::Value::from_json(original.clone()).unwrap();
-        let back = converted.to_json().unwrap();
-        assert_eq!(original, back);
-    }
-
-    #[test]
-    fn test_from_language_trait() {
-        let any_value: Box<dyn Any + Send + Sync> = Box::new(42i32);
-        let result = TestType::from_any(&*any_value);
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap().value, 42);
-    }
-
-    #[test]
-    fn test_from_language_wrong_type() {
-        let any_value: Box<dyn Any + Send + Sync> = Box::new("string");
-        let result = TestType::from_any(&*any_value);
-        assert!(result.is_err());
-        assert_eq!(result.unwrap_err(), "Invalid type");
-    }
-
-    #[test]
-    fn test_to_language_trait() {
-        let test_obj = TestType { value: 123 };
-        let result = test_obj.to_any();
-        assert!(result.is_ok());
-
-        let any_box = result.unwrap();
-        let downcast = any_box.downcast_ref::<i32>();
-        assert_eq!(*downcast.unwrap(), 123);
-    }
-
-    #[test]
-    fn test_json_null_conversion() {
-        let null_value = serde_json::Value::Null;
-        let result = serde_json::Value::from_json(null_value);
-        assert!(result.is_ok());
-        assert!(result.unwrap().is_null());
-    }
-
-    #[test]
-    fn test_json_array_conversion() {
-        let array = json!([1, 2, 3, 4, 5]);
-        let result = serde_json::Value::from_json(array);
-        assert!(result.is_ok());
-        let converted = result.unwrap();
-        assert!(converted.is_array());
-        assert_eq!(converted.as_array().unwrap().len(), 5);
-    }
-
-    #[test]
-    fn test_json_nested_object_conversion() {
-        let nested = json!({
-            "level1": {
-                "level2": {
-                    "level3": {
-                        "value": "deep"
-                    }
-                }
-            }
-        });
-
-        let result = serde_json::Value::from_json(nested);
-        assert!(result.is_ok());
-        let converted = result.unwrap();
-        assert_eq!(converted["level1"]["level2"]["level3"]["value"], "deep");
-    }
-
-    #[test]
-    fn test_json_conversion_error_description() {
-        let err = JsonConversionError("Custom message".to_string());
-        assert!(err.to_string().contains("Custom message"));
-    }
-}

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

@@ -1,252 +0,0 @@
-//! Dependency injection base traits
-//!
-//! This module provides language-agnostic DI abstractions that eliminate
-//! duplicate value/factory patterns across Node, Ruby, and PHP bindings.
-
-use std::any::Any;
-use std::future::Future;
-use std::pin::Pin;
-use std::sync::Arc;
-
-use http::Request;
-use spikard_core::RequestData;
-use spikard_core::di::{Dependency, DependencyError, ResolvedDependencies};
-
-/// Type alias for the common dependency resolution future type
-type DependencyFuture<'a> =
-    Pin<Box<dyn Future<Output = Result<Arc<dyn Any + Send + Sync>, DependencyError>> + Send + 'a>>;
-
-/// Adapter trait for value dependencies across language bindings
-///
-/// Language bindings should implement this trait to wrap their
-/// language-specific value storage (e.g., `Py<PyAny>`, `Opaque<Value>`, etc.)
-pub trait ValueDependencyAdapter: Send + Sync {
-    /// Get the dependency key
-    fn key(&self) -> &str;
-
-    /// Resolve the stored value
-    ///
-    /// Returns an `Arc<dyn Any>` that can be downcast to the concrete type
-    fn resolve_value(&self) -> DependencyFuture<'_>;
-}
-
-/// 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.)
-pub trait FactoryDependencyAdapter: Send + Sync {
-    /// Get the dependency key
-    fn key(&self) -> &str;
-
-    /// Invoke the factory with resolved dependencies
-    ///
-    /// The factory receives already-resolved dependencies and returns
-    /// a new instance wrapped in `Arc<dyn Any>`
-    fn invoke_factory(
-        &self,
-        request: &Request<()>,
-        request_data: &RequestData,
-        resolved: &ResolvedDependencies,
-    ) -> DependencyFuture<'_>;
-}
-
-/// Bridge between language-specific adapters and core DI system
-///
-/// This struct implements the core `Dependency` trait while delegating
-/// to the language-specific adapter implementation
-pub struct ValueDependencyBridge<T: ValueDependencyAdapter> {
-    adapter: Arc<T>,
-}
-
-impl<T: ValueDependencyAdapter + 'static> ValueDependencyBridge<T> {
-    /// Create a new value dependency bridge
-    pub fn new(adapter: T) -> Self {
-        Self {
-            adapter: Arc::new(adapter),
-        }
-    }
-}
-
-impl<T: ValueDependencyAdapter + 'static> Dependency for ValueDependencyBridge<T> {
-    fn resolve(
-        &self,
-        _request: &Request<()>,
-        _request_data: &RequestData,
-        _resolved: &ResolvedDependencies,
-    ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn Any + Send + Sync>, DependencyError>> + Send + '_>> {
-        self.adapter.resolve_value()
-    }
-
-    fn key(&self) -> &str {
-        self.adapter.key()
-    }
-
-    // PERFORMANCE: Value dependencies have no sub-dependencies.
-    // Returning an empty Vec is unavoidable if the trait requires it, but
-    // consider optimizing the DI system to use Option<&[String]> or a default method.
-    fn depends_on(&self) -> Vec<String> {
-        vec![]
-    }
-}
-
-/// Bridge between language-specific factory adapters and core DI system
-pub struct FactoryDependencyBridge<T: FactoryDependencyAdapter> {
-    adapter: Arc<T>,
-}
-
-impl<T: FactoryDependencyAdapter + 'static> FactoryDependencyBridge<T> {
-    /// Create a new factory dependency bridge
-    pub fn new(adapter: T) -> Self {
-        Self {
-            adapter: Arc::new(adapter),
-        }
-    }
-}
-
-impl<T: FactoryDependencyAdapter + 'static> Dependency for FactoryDependencyBridge<T> {
-    fn resolve(
-        &self,
-        request: &Request<()>,
-        request_data: &RequestData,
-        resolved: &ResolvedDependencies,
-    ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn Any + Send + Sync>, DependencyError>> + Send + '_>> {
-        self.adapter.invoke_factory(request, request_data, resolved)
-    }
-
-    fn key(&self) -> &str {
-        self.adapter.key()
-    }
-
-    // PERFORMANCE: Factory dependencies may or may not have sub-dependencies.
-    // Language bindings should override this if they track dependencies.
-    // The default empty Vec is acceptable for language bindings that don't track explicit dependency graphs.
-    fn depends_on(&self) -> Vec<String> {
-        vec![]
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::collections::HashMap;
-    use std::sync::atomic::{AtomicUsize, Ordering};
-
-    struct MockValueAdapter {
-        key: String,
-        value: i32,
-    }
-
-    impl ValueDependencyAdapter for MockValueAdapter {
-        fn key(&self) -> &str {
-            &self.key
-        }
-
-        fn resolve_value(
-            &self,
-        ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn Any + Send + Sync>, DependencyError>> + Send + '_>> {
-            let value = self.value;
-            Box::pin(async move { Ok(Arc::new(value) as Arc<dyn Any + Send + Sync>) })
-        }
-    }
-
-    struct MockFactoryAdapter {
-        key: String,
-        call_count: Arc<AtomicUsize>,
-    }
-
-    impl FactoryDependencyAdapter for MockFactoryAdapter {
-        fn key(&self) -> &str {
-            &self.key
-        }
-
-        fn invoke_factory(
-            &self,
-            _request: &Request<()>,
-            _request_data: &RequestData,
-            _resolved: &ResolvedDependencies,
-        ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn Any + Send + Sync>, DependencyError>> + Send + '_>> {
-            let count = self.call_count.clone();
-            count.fetch_add(1, Ordering::SeqCst);
-            Box::pin(async move {
-                let value = count.load(Ordering::SeqCst);
-                Ok(Arc::new(value) as Arc<dyn Any + Send + Sync>)
-            })
-        }
-    }
-
-    #[tokio::test]
-    async fn test_value_dependency_bridge() {
-        let adapter = MockValueAdapter {
-            key: "test_key".to_string(),
-            value: 42,
-        };
-        let bridge = ValueDependencyBridge::new(adapter);
-
-        assert_eq!(bridge.key(), "test_key");
-        assert_eq!(bridge.depends_on(), Vec::<String>::new());
-
-        let request = Request::builder().body(()).unwrap();
-        let request_data = RequestData {
-            path_params: Arc::new(HashMap::new()),
-            query_params: serde_json::Value::Null,
-            validated_params: None,
-            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(),
-            dependencies: None,
-        };
-        let resolved = ResolvedDependencies::new();
-
-        let result = bridge.resolve(&request, &request_data, &resolved).await;
-        assert!(result.is_ok());
-
-        let value = result.unwrap();
-        let downcast = value.downcast_ref::<i32>();
-        assert_eq!(*downcast.unwrap(), 42);
-    }
-
-    #[tokio::test]
-    async fn test_factory_dependency_bridge() {
-        let call_count = Arc::new(AtomicUsize::new(0));
-        let adapter = MockFactoryAdapter {
-            key: "factory_key".to_string(),
-            call_count: call_count.clone(),
-        };
-        let bridge = FactoryDependencyBridge::new(adapter);
-
-        assert_eq!(bridge.key(), "factory_key");
-        assert_eq!(bridge.depends_on(), Vec::<String>::new());
-
-        let request = Request::builder().body(()).unwrap();
-        let request_data = RequestData {
-            path_params: Arc::new(HashMap::new()),
-            query_params: serde_json::Value::Null,
-            validated_params: None,
-            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(),
-            dependencies: None,
-        };
-        let resolved = ResolvedDependencies::new();
-
-        let result1 = bridge.resolve(&request, &request_data, &resolved).await;
-        assert!(result1.is_ok());
-        let value1 = result1.unwrap();
-        let count1 = *value1.downcast_ref::<usize>().unwrap();
-        assert_eq!(count1, 1);
-
-        let result2 = bridge.resolve(&request, &request_data, &resolved).await;
-        assert!(result2.is_ok());
-        let value2 = result2.unwrap();
-        let count2 = *value2.downcast_ref::<usize>().unwrap();
-        assert_eq!(count2, 2);
-    }
-}