spikard 0.4.0-arm64-darwin-23

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

@@ -0,0 +1,25 @@
+//! Shared utilities for language bindings
+//!
+//! This crate provides common functionality used across all language bindings
+//! (Python, Node.js, Ruby, PHP, WASM) to eliminate code duplication and ensure
+//! consistent behavior.
+
+pub mod config_extractor;
+pub mod conversion_traits;
+pub mod di_traits;
+pub mod error_response;
+pub mod handler_base;
+pub mod lifecycle_base;
+pub mod lifecycle_executor;
+pub mod response_builder;
+pub mod test_client_base;
+pub mod validation_helpers;
+
+// Re-export commonly used types
+pub use config_extractor::{ConfigExtractor, ConfigSource};
+pub use di_traits::{FactoryDependencyAdapter, ValueDependencyAdapter};
+pub use error_response::ErrorResponseBuilder;
+pub use handler_base::{HandlerError, HandlerExecutor, LanguageHandler};
+pub use lifecycle_executor::{
+    HookResultData, LanguageLifecycleHook, LifecycleExecutor, RequestModifications, extract_body,
+};

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

@@ -0,0 +1,298 @@
+//! Lifecycle hook base implementations
+
+use std::sync::Arc;
+
+/// Lifecycle hook types supported across all bindings
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum LifecycleHookType {
+    /// Called at the start of request processing
+    OnRequest,
+    /// Called before validation
+    PreValidation,
+    /// Called before handler execution
+    PreHandler,
+    /// Called after handler execution
+    OnResponse,
+    /// Called when an error occurs
+    OnError,
+}
+
+/// Result type for lifecycle hooks
+#[derive(Clone)]
+pub enum HookResult {
+    /// Continue with normal processing
+    Continue,
+    /// Short-circuit and return this response
+    ShortCircuit(serde_json::Value),
+}
+
+/// Trait for implementing lifecycle hooks in language bindings
+pub trait LifecycleHook: Send + Sync {
+    /// Execute the lifecycle hook
+    fn execute(&self, context: serde_json::Value) -> Result<HookResult, String>;
+
+    /// Get the hook type
+    fn hook_type(&self) -> LifecycleHookType;
+}
+
+/// Base configuration for lifecycle hooks
+pub struct LifecycleConfig {
+    /// Registered hooks by type
+    hooks: std::collections::HashMap<LifecycleHookType, Vec<Arc<dyn LifecycleHook>>>,
+}
+
+impl LifecycleConfig {
+    /// Create a new lifecycle configuration
+    pub fn new() -> Self {
+        Self {
+            hooks: std::collections::HashMap::new(),
+        }
+    }
+
+    /// Register a lifecycle hook
+    pub fn register(&mut self, hook: Arc<dyn LifecycleHook>) {
+        self.hooks.entry(hook.hook_type()).or_default().push(hook);
+    }
+
+    /// Get hooks for a specific type
+    pub fn get_hooks(&self, hook_type: LifecycleHookType) -> Vec<Arc<dyn LifecycleHook>> {
+        self.hooks.get(&hook_type).cloned().unwrap_or_default()
+    }
+}
+
+impl Default for LifecycleConfig {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    struct TestHook {
+        hook_type: LifecycleHookType,
+        result: HookResult,
+    }
+
+    impl LifecycleHook for TestHook {
+        fn execute(&self, _context: serde_json::Value) -> Result<HookResult, String> {
+            Ok(self.result.clone())
+        }
+
+        fn hook_type(&self) -> LifecycleHookType {
+            self.hook_type
+        }
+    }
+
+    #[test]
+    fn test_lifecycle_hook_type_equality() {
+        assert_eq!(LifecycleHookType::OnRequest, LifecycleHookType::OnRequest);
+        assert_ne!(LifecycleHookType::OnRequest, LifecycleHookType::OnResponse);
+    }
+
+    #[test]
+    fn test_lifecycle_hook_type_hash() {
+        use std::collections::HashSet;
+
+        let mut set = HashSet::new();
+        set.insert(LifecycleHookType::OnRequest);
+        set.insert(LifecycleHookType::PreHandler);
+        set.insert(LifecycleHookType::OnRequest);
+
+        assert_eq!(set.len(), 2); // OnRequest should only be added once
+    }
+
+    #[test]
+    fn test_hook_result_continue() {
+        let result = HookResult::Continue;
+        match result {
+            HookResult::Continue => {
+                // Expected
+            }
+            HookResult::ShortCircuit(_) => panic!("Expected Continue"),
+        }
+    }
+
+    #[test]
+    fn test_hook_result_short_circuit() {
+        let response = json!({ "status": "error" });
+        let result = HookResult::ShortCircuit(response.clone());
+        match result {
+            HookResult::Continue => panic!("Expected ShortCircuit"),
+            HookResult::ShortCircuit(r) => {
+                assert_eq!(r, response);
+            }
+        }
+    }
+
+    #[test]
+    fn test_lifecycle_config_new() {
+        let config = LifecycleConfig::new();
+        assert_eq!(config.get_hooks(LifecycleHookType::OnRequest).len(), 0);
+    }
+
+    #[test]
+    fn test_lifecycle_config_default() {
+        let config = LifecycleConfig::default();
+        assert_eq!(config.get_hooks(LifecycleHookType::OnRequest).len(), 0);
+    }
+
+    #[test]
+    fn test_register_single_hook() {
+        let mut config = LifecycleConfig::new();
+        let hook = Arc::new(TestHook {
+            hook_type: LifecycleHookType::OnRequest,
+            result: HookResult::Continue,
+        });
+
+        config.register(hook);
+
+        let hooks = config.get_hooks(LifecycleHookType::OnRequest);
+        assert_eq!(hooks.len(), 1);
+    }
+
+    #[test]
+    fn test_register_multiple_hooks_same_type() {
+        let mut config = LifecycleConfig::new();
+
+        for i in 0..3 {
+            let hook = Arc::new(TestHook {
+                hook_type: LifecycleHookType::OnRequest,
+                result: if i == 0 {
+                    HookResult::Continue
+                } else {
+                    HookResult::ShortCircuit(json!({ "index": i }))
+                },
+            });
+            config.register(hook);
+        }
+
+        let hooks = config.get_hooks(LifecycleHookType::OnRequest);
+        assert_eq!(hooks.len(), 3);
+    }
+
+    #[test]
+    fn test_register_hooks_different_types() {
+        let mut config = LifecycleConfig::new();
+
+        let hook_on_request = Arc::new(TestHook {
+            hook_type: LifecycleHookType::OnRequest,
+            result: HookResult::Continue,
+        });
+
+        let hook_on_error = Arc::new(TestHook {
+            hook_type: LifecycleHookType::OnError,
+            result: HookResult::Continue,
+        });
+
+        config.register(hook_on_request);
+        config.register(hook_on_error);
+
+        assert_eq!(config.get_hooks(LifecycleHookType::OnRequest).len(), 1);
+        assert_eq!(config.get_hooks(LifecycleHookType::OnError).len(), 1);
+        assert_eq!(config.get_hooks(LifecycleHookType::PreHandler).len(), 0);
+    }
+
+    #[test]
+    fn test_get_hooks_empty() {
+        let config = LifecycleConfig::new();
+        let hooks = config.get_hooks(LifecycleHookType::PreValidation);
+        assert!(hooks.is_empty());
+    }
+
+    #[test]
+    fn test_get_hooks_multiple_calls() {
+        let mut config = LifecycleConfig::new();
+
+        let hook1 = Arc::new(TestHook {
+            hook_type: LifecycleHookType::OnResponse,
+            result: HookResult::Continue,
+        });
+
+        let hook2 = Arc::new(TestHook {
+            hook_type: LifecycleHookType::OnResponse,
+            result: HookResult::Continue,
+        });
+
+        config.register(hook1);
+        config.register(hook2);
+
+        // Multiple calls should return independent clones
+        let hooks1 = config.get_hooks(LifecycleHookType::OnResponse);
+        let hooks2 = config.get_hooks(LifecycleHookType::OnResponse);
+
+        assert_eq!(hooks1.len(), 2);
+        assert_eq!(hooks2.len(), 2);
+    }
+
+    #[test]
+    fn test_hook_execute() {
+        let hook = TestHook {
+            hook_type: LifecycleHookType::OnRequest,
+            result: HookResult::Continue,
+        };
+
+        let context = json!({ "test": "data" });
+        let result = hook.execute(context);
+
+        assert!(result.is_ok());
+        match result.unwrap() {
+            HookResult::Continue => {
+                // Expected
+            }
+            HookResult::ShortCircuit(_) => panic!("Expected Continue"),
+        }
+    }
+
+    #[test]
+    fn test_hook_type_retrieval() {
+        let hook = TestHook {
+            hook_type: LifecycleHookType::PreValidation,
+            result: HookResult::Continue,
+        };
+
+        assert_eq!(hook.hook_type(), LifecycleHookType::PreValidation);
+    }
+
+    #[test]
+    fn test_all_hook_types() {
+        let hook_types = vec![
+            LifecycleHookType::OnRequest,
+            LifecycleHookType::PreValidation,
+            LifecycleHookType::PreHandler,
+            LifecycleHookType::OnResponse,
+            LifecycleHookType::OnError,
+        ];
+
+        let mut config = LifecycleConfig::new();
+
+        for hook_type in hook_types.iter() {
+            let hook = Arc::new(TestHook {
+                hook_type: *hook_type,
+                result: HookResult::Continue,
+            });
+            config.register(hook);
+        }
+
+        // Verify all types are registered
+        for hook_type in hook_types {
+            let hooks = config.get_hooks(hook_type);
+            assert_eq!(hooks.len(), 1);
+        }
+    }
+
+    #[test]
+    fn test_hook_result_clone() {
+        let original = HookResult::ShortCircuit(json!({ "key": "value" }));
+        let cloned = original.clone();
+
+        match cloned {
+            HookResult::ShortCircuit(response) => {
+                assert_eq!(response["key"], "value");
+            }
+            _ => panic!("Expected ShortCircuit"),
+        }
+    }
+}