spikard 0.4.0-x86_64-linux

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

@@ -0,0 +1,194 @@
+//! 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
+    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
+    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
+    fn from_json(value: serde_json::Value) -> Result<Self, Self::Error>;
+
+    /// Convert to a JSON value
+    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| TestType { 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.14,
+            "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.clone());
+        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.clone());
+        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.clone());
+        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

@@ -0,0 +1,246 @@
+//! 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()
+    }
+
+    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()
+    }
+
+    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,
+            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,
+            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();
+
+        // First call
+        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);
+
+        // Second call - factory is invoked again
+        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);
+    }
+}