RubyGems - spikard - Versions diffs - 0.3.2 → 0.3.3 - Mend

spikard 0.3.2 → 0.3.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (180) hide show

checksums.yaml +4 -4
data/LICENSE +1 -1
data/README.md +659 -659
data/ext/spikard_rb/Cargo.toml +17 -17
data/ext/spikard_rb/extconf.rb +10 -10
data/ext/spikard_rb/src/lib.rs +6 -6
data/lib/spikard/app.rb +386 -386
data/lib/spikard/background.rb +27 -27
data/lib/spikard/config.rb +396 -396
data/lib/spikard/converters.rb +13 -13
data/lib/spikard/handler_wrapper.rb +113 -113
data/lib/spikard/provide.rb +214 -214
data/lib/spikard/response.rb +173 -173
data/lib/spikard/schema.rb +243 -243
data/lib/spikard/sse.rb +111 -111
data/lib/spikard/streaming_response.rb +44 -44
data/lib/spikard/testing.rb +221 -221
data/lib/spikard/upload_file.rb +131 -131
data/lib/spikard/version.rb +5 -5
data/lib/spikard/websocket.rb +59 -59
data/lib/spikard.rb +43 -43
data/sig/spikard.rbs +360 -360
data/vendor/crates/spikard-core/Cargo.toml +40 -40
data/vendor/crates/spikard-core/src/bindings/mod.rs +3 -3
data/vendor/crates/spikard-core/src/bindings/response.rs +133 -133
data/vendor/crates/spikard-core/src/debug.rs +63 -63
data/vendor/crates/spikard-core/src/di/container.rs +726 -726
data/vendor/crates/spikard-core/src/di/dependency.rs +273 -273
data/vendor/crates/spikard-core/src/di/error.rs +118 -118
data/vendor/crates/spikard-core/src/di/factory.rs +538 -538
data/vendor/crates/spikard-core/src/di/graph.rs +545 -545
data/vendor/crates/spikard-core/src/di/mod.rs +192 -192
data/vendor/crates/spikard-core/src/di/resolved.rs +411 -411
data/vendor/crates/spikard-core/src/di/value.rs +283 -283
data/vendor/crates/spikard-core/src/errors.rs +39 -39
data/vendor/crates/spikard-core/src/http.rs +153 -153
data/vendor/crates/spikard-core/src/lib.rs +29 -29
data/vendor/crates/spikard-core/src/lifecycle.rs +422 -422
data/vendor/crates/spikard-core/src/parameters.rs +722 -722
data/vendor/crates/spikard-core/src/problem.rs +310 -310
data/vendor/crates/spikard-core/src/request_data.rs +189 -189
data/vendor/crates/spikard-core/src/router.rs +249 -249
data/vendor/crates/spikard-core/src/schema_registry.rs +183 -183
data/vendor/crates/spikard-core/src/type_hints.rs +304 -304
data/vendor/crates/spikard-core/src/validation.rs +699 -699
data/vendor/crates/spikard-http/Cargo.toml +58 -58
data/vendor/crates/spikard-http/src/auth.rs +247 -247
data/vendor/crates/spikard-http/src/background.rs +249 -249
data/vendor/crates/spikard-http/src/bindings/mod.rs +3 -3
data/vendor/crates/spikard-http/src/bindings/response.rs +1 -1
data/vendor/crates/spikard-http/src/body_metadata.rs +8 -8
data/vendor/crates/spikard-http/src/cors.rs +490 -490
data/vendor/crates/spikard-http/src/debug.rs +63 -63
data/vendor/crates/spikard-http/src/di_handler.rs +423 -423
data/vendor/crates/spikard-http/src/handler_response.rs +190 -190
data/vendor/crates/spikard-http/src/handler_trait.rs +228 -228
data/vendor/crates/spikard-http/src/handler_trait_tests.rs +284 -284
data/vendor/crates/spikard-http/src/lib.rs +529 -529
data/vendor/crates/spikard-http/src/lifecycle/adapter.rs +149 -149
data/vendor/crates/spikard-http/src/lifecycle.rs +428 -428
data/vendor/crates/spikard-http/src/middleware/mod.rs +285 -285
data/vendor/crates/spikard-http/src/middleware/multipart.rs +86 -86
data/vendor/crates/spikard-http/src/middleware/urlencoded.rs +147 -147
data/vendor/crates/spikard-http/src/middleware/validation.rs +287 -287
data/vendor/crates/spikard-http/src/openapi/mod.rs +309 -309
data/vendor/crates/spikard-http/src/openapi/parameter_extraction.rs +190 -190
data/vendor/crates/spikard-http/src/openapi/schema_conversion.rs +308 -308
data/vendor/crates/spikard-http/src/openapi/spec_generation.rs +195 -195
data/vendor/crates/spikard-http/src/parameters.rs +1 -1
data/vendor/crates/spikard-http/src/problem.rs +1 -1
data/vendor/crates/spikard-http/src/query_parser.rs +369 -369
data/vendor/crates/spikard-http/src/response.rs +399 -399
data/vendor/crates/spikard-http/src/router.rs +1 -1
data/vendor/crates/spikard-http/src/schema_registry.rs +1 -1
data/vendor/crates/spikard-http/src/server/handler.rs +87 -87
data/vendor/crates/spikard-http/src/server/lifecycle_execution.rs +98 -98
data/vendor/crates/spikard-http/src/server/mod.rs +805 -805
data/vendor/crates/spikard-http/src/server/request_extraction.rs +119 -119
data/vendor/crates/spikard-http/src/sse.rs +447 -447
data/vendor/crates/spikard-http/src/testing/form.rs +14 -14
data/vendor/crates/spikard-http/src/testing/multipart.rs +60 -60
data/vendor/crates/spikard-http/src/testing/test_client.rs +285 -285
data/vendor/crates/spikard-http/src/testing.rs +377 -377
data/vendor/crates/spikard-http/src/type_hints.rs +1 -1
data/vendor/crates/spikard-http/src/validation.rs +1 -1
data/vendor/crates/spikard-http/src/websocket.rs +324 -324
data/vendor/crates/spikard-rb/Cargo.toml +42 -42
data/vendor/crates/spikard-rb/build.rs +8 -8
data/vendor/crates/spikard-rb/src/background.rs +63 -63
data/vendor/crates/spikard-rb/src/config.rs +294 -294
data/vendor/crates/spikard-rb/src/conversion.rs +453 -453
data/vendor/crates/spikard-rb/src/di.rs +409 -409
data/vendor/crates/spikard-rb/src/handler.rs +625 -625
data/vendor/crates/spikard-rb/src/lib.rs +2771 -2771
data/vendor/crates/spikard-rb/src/lifecycle.rs +274 -274
data/vendor/crates/spikard-rb/src/server.rs +283 -283
data/vendor/crates/spikard-rb/src/sse.rs +231 -231
data/vendor/crates/spikard-rb/src/test_client.rs +404 -404
data/vendor/crates/spikard-rb/src/test_sse.rs +143 -143
data/vendor/crates/spikard-rb/src/test_websocket.rs +221 -221
data/vendor/crates/spikard-rb/src/websocket.rs +233 -233
data/vendor/spikard-core/Cargo.toml +40 -40
data/vendor/spikard-core/src/bindings/mod.rs +3 -3
data/vendor/spikard-core/src/bindings/response.rs +133 -133
data/vendor/spikard-core/src/debug.rs +63 -63
data/vendor/spikard-core/src/di/container.rs +726 -726
data/vendor/spikard-core/src/di/dependency.rs +273 -273
data/vendor/spikard-core/src/di/error.rs +118 -118
data/vendor/spikard-core/src/di/factory.rs +538 -538
data/vendor/spikard-core/src/di/graph.rs +545 -545
data/vendor/spikard-core/src/di/mod.rs +192 -192
data/vendor/spikard-core/src/di/resolved.rs +411 -411
data/vendor/spikard-core/src/di/value.rs +283 -283
data/vendor/spikard-core/src/http.rs +153 -153
data/vendor/spikard-core/src/lib.rs +28 -28
data/vendor/spikard-core/src/lifecycle.rs +422 -422
data/vendor/spikard-core/src/parameters.rs +719 -719
data/vendor/spikard-core/src/problem.rs +310 -310
data/vendor/spikard-core/src/request_data.rs +189 -189
data/vendor/spikard-core/src/router.rs +249 -249
data/vendor/spikard-core/src/schema_registry.rs +183 -183
data/vendor/spikard-core/src/type_hints.rs +304 -304
data/vendor/spikard-core/src/validation.rs +699 -699
data/vendor/spikard-http/Cargo.toml +58 -58
data/vendor/spikard-http/src/auth.rs +247 -247
data/vendor/spikard-http/src/background.rs +249 -249
data/vendor/spikard-http/src/bindings/mod.rs +3 -3
data/vendor/spikard-http/src/bindings/response.rs +1 -1
data/vendor/spikard-http/src/body_metadata.rs +8 -8
data/vendor/spikard-http/src/cors.rs +490 -490
data/vendor/spikard-http/src/debug.rs +63 -63
data/vendor/spikard-http/src/di_handler.rs +423 -423
data/vendor/spikard-http/src/handler_response.rs +190 -190
data/vendor/spikard-http/src/handler_trait.rs +228 -228
data/vendor/spikard-http/src/handler_trait_tests.rs +284 -284
data/vendor/spikard-http/src/lib.rs +529 -529
data/vendor/spikard-http/src/lifecycle/adapter.rs +149 -149
data/vendor/spikard-http/src/lifecycle.rs +428 -428
data/vendor/spikard-http/src/middleware/mod.rs +285 -285
data/vendor/spikard-http/src/middleware/multipart.rs +86 -86
data/vendor/spikard-http/src/middleware/urlencoded.rs +147 -147
data/vendor/spikard-http/src/middleware/validation.rs +287 -287
data/vendor/spikard-http/src/openapi/mod.rs +309 -309
data/vendor/spikard-http/src/openapi/parameter_extraction.rs +190 -190
data/vendor/spikard-http/src/openapi/schema_conversion.rs +308 -308
data/vendor/spikard-http/src/openapi/spec_generation.rs +195 -195
data/vendor/spikard-http/src/parameters.rs +1 -1
data/vendor/spikard-http/src/problem.rs +1 -1
data/vendor/spikard-http/src/query_parser.rs +369 -369
data/vendor/spikard-http/src/response.rs +399 -399
data/vendor/spikard-http/src/router.rs +1 -1
data/vendor/spikard-http/src/schema_registry.rs +1 -1
data/vendor/spikard-http/src/server/handler.rs +80 -80
data/vendor/spikard-http/src/server/lifecycle_execution.rs +98 -98
data/vendor/spikard-http/src/server/mod.rs +805 -805
data/vendor/spikard-http/src/server/request_extraction.rs +119 -119
data/vendor/spikard-http/src/sse.rs +447 -447
data/vendor/spikard-http/src/testing/form.rs +14 -14
data/vendor/spikard-http/src/testing/multipart.rs +60 -60
data/vendor/spikard-http/src/testing/test_client.rs +285 -285
data/vendor/spikard-http/src/testing.rs +377 -377
data/vendor/spikard-http/src/type_hints.rs +1 -1
data/vendor/spikard-http/src/validation.rs +1 -1
data/vendor/spikard-http/src/websocket.rs +324 -324
data/vendor/spikard-rb/Cargo.toml +42 -42
data/vendor/spikard-rb/build.rs +8 -8
data/vendor/spikard-rb/src/background.rs +63 -63
data/vendor/spikard-rb/src/config.rs +294 -294
data/vendor/spikard-rb/src/conversion.rs +392 -392
data/vendor/spikard-rb/src/di.rs +409 -409
data/vendor/spikard-rb/src/handler.rs +534 -534
data/vendor/spikard-rb/src/lib.rs +2020 -2020
data/vendor/spikard-rb/src/lifecycle.rs +267 -267
data/vendor/spikard-rb/src/server.rs +283 -283
data/vendor/spikard-rb/src/sse.rs +231 -231
data/vendor/spikard-rb/src/test_client.rs +404 -404
data/vendor/spikard-rb/src/test_sse.rs +143 -143
data/vendor/spikard-rb/src/test_websocket.rs +221 -221
data/vendor/spikard-rb/src/websocket.rs +233 -233
metadata +1 -1

data/vendor/spikard-http/src/lifecycle.rs CHANGED Viewed

@@ -1,428 +1,428 @@
-use axum::{
-    body::Body,
-    http::{Request, Response},
-};
-use std::sync::Arc;
-pub mod adapter;
-pub use spikard_core::lifecycle::{HookResult, LifecycleHook};
-pub type LifecycleHooks = spikard_core::lifecycle::LifecycleHooks<Request<Body>, Response<Body>>;
-pub type LifecycleHooksBuilder = spikard_core::lifecycle::LifecycleHooksBuilder<Request<Body>, Response<Body>>;
-/// Create a request hook for the current target.
-#[cfg(not(target_arch = "wasm32"))]
-pub fn request_hook<F, Fut>(name: impl Into<String>, func: F) -> Arc<dyn LifecycleHook<Request<Body>, Response<Body>>>
-where
-    F: Fn(Request<Body>) -> Fut + Send + Sync + 'static,
-    Fut: std::future::Future<Output = Result<HookResult<Request<Body>, Response<Body>>, String>> + Send + 'static,
-{
-    spikard_core::lifecycle::request_hook::<Request<Body>, Response<Body>, _, _>(name, func)
-}
-/// Create a request hook for wasm targets (no Send on futures).
-#[cfg(target_arch = "wasm32")]
-pub fn request_hook<F, Fut>(name: impl Into<String>, func: F) -> Arc<dyn LifecycleHook<Request<Body>, Response<Body>>>
-where
-    F: Fn(Request<Body>) -> Fut + Send + Sync + 'static,
-    Fut: std::future::Future<Output = Result<HookResult<Request<Body>, Response<Body>>, String>> + 'static,
-{
-    spikard_core::lifecycle::request_hook::<Request<Body>, Response<Body>, _, _>(name, func)
-}
-/// Create a response hook for the current target.
-#[cfg(not(target_arch = "wasm32"))]
-pub fn response_hook<F, Fut>(name: impl Into<String>, func: F) -> Arc<dyn LifecycleHook<Request<Body>, Response<Body>>>
-where
-    F: Fn(Response<Body>) -> Fut + Send + Sync + 'static,
-    Fut: std::future::Future<Output = Result<HookResult<Response<Body>, Response<Body>>, String>> + Send + 'static,
-{
-    spikard_core::lifecycle::response_hook::<Request<Body>, Response<Body>, _, _>(name, func)
-}
-/// Create a response hook for wasm targets (no Send on futures).
-#[cfg(target_arch = "wasm32")]
-pub fn response_hook<F, Fut>(name: impl Into<String>, func: F) -> Arc<dyn LifecycleHook<Request<Body>, Response<Body>>>
-where
-    F: Fn(Response<Body>) -> Fut + Send + Sync + 'static,
-    Fut: std::future::Future<Output = Result<HookResult<Response<Body>, Response<Body>>, String>> + 'static,
-{
-    spikard_core::lifecycle::response_hook::<Request<Body>, Response<Body>, _, _>(name, func)
-}
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use axum::body::Body;
-    use axum::http::{Request, Response, StatusCode};
-    use std::future::Future;
-    use std::pin::Pin;
-    /// Test hook that always continues
-    struct ContinueHook {
-        name: String,
-    }
-    impl LifecycleHook<Request<Body>, Response<Body>> for ContinueHook {
-        fn name(&self) -> &str {
-            &self.name
-        }
-        fn execute_request<'a>(
-            &'a self,
-            req: Request<Body>,
-        ) -> Pin<Box<dyn Future<Output = Result<HookResult<Request<Body>, Response<Body>>, String>> + Send + 'a>>
-        {
-            Box::pin(async move { Ok(HookResult::Continue(req)) })
-        }
-        fn execute_response<'a>(
-            &'a self,
-            resp: Response<Body>,
-        ) -> Pin<Box<dyn Future<Output = Result<HookResult<Response<Body>, Response<Body>>, String>> + Send + 'a>>
-        {
-            Box::pin(async move { Ok(HookResult::Continue(resp)) })
-        }
-    }
-    /// Test hook that short-circuits with a 401 response
-    struct ShortCircuitHook {
-        name: String,
-    }
-    impl LifecycleHook<Request<Body>, Response<Body>> for ShortCircuitHook {
-        fn name(&self) -> &str {
-            &self.name
-        }
-        fn execute_request<'a>(
-            &'a self,
-            _req: Request<Body>,
-        ) -> Pin<Box<dyn Future<Output = Result<HookResult<Request<Body>, Response<Body>>, String>> + Send + 'a>>
-        {
-            Box::pin(async move {
-                let response = Response::builder()
-                    .status(StatusCode::UNAUTHORIZED)
-                    .body(Body::from("Unauthorized"))
-                    .unwrap();
-                Ok(HookResult::ShortCircuit(response))
-            })
-        }
-        fn execute_response<'a>(
-            &'a self,
-            _resp: Response<Body>,
-        ) -> Pin<Box<dyn Future<Output = Result<HookResult<Response<Body>, Response<Body>>, String>> + Send + 'a>>
-        {
-            Box::pin(async move {
-                let response = Response::builder()
-                    .status(StatusCode::UNAUTHORIZED)
-                    .body(Body::from("Unauthorized"))
-                    .unwrap();
-                Ok(HookResult::ShortCircuit(response))
-            })
-        }
-    }
-    #[tokio::test]
-    async fn test_empty_hooks_fast_path() {
-        let hooks = LifecycleHooks::new();
-        assert!(hooks.is_empty());
-        let req = Request::builder().body(Body::empty()).unwrap();
-        let result = hooks.execute_on_request(req).await.unwrap();
-        assert!(matches!(result, HookResult::Continue(_)));
-    }
-    #[tokio::test]
-    async fn test_on_request_continue() {
-        let mut hooks = LifecycleHooks::new();
-        hooks.add_on_request(Arc::new(ContinueHook {
-            name: "test".to_string(),
-        }));
-        let req = Request::builder().body(Body::empty()).unwrap();
-        let result = hooks.execute_on_request(req).await.unwrap();
-        assert!(matches!(result, HookResult::Continue(_)));
-    }
-    #[tokio::test]
-    async fn test_on_request_short_circuit() {
-        let mut hooks = LifecycleHooks::new();
-        hooks.add_on_request(Arc::new(ShortCircuitHook {
-            name: "auth_check".to_string(),
-        }));
-        let req = Request::builder().body(Body::empty()).unwrap();
-        let result = hooks.execute_on_request(req).await.unwrap();
-        match result {
-            HookResult::ShortCircuit(resp) => {
-                assert_eq!(resp.status(), StatusCode::UNAUTHORIZED);
-            }
-            HookResult::Continue(_) => panic!("Expected ShortCircuit, got Continue"),
-        }
-    }
-    #[tokio::test]
-    async fn test_multiple_hooks_in_order() {
-        let mut hooks = LifecycleHooks::new();
-        hooks.add_on_request(Arc::new(ContinueHook {
-            name: "first".to_string(),
-        }));
-        hooks.add_on_request(Arc::new(ContinueHook {
-            name: "second".to_string(),
-        }));
-        let req = Request::builder().body(Body::empty()).unwrap();
-        let result = hooks.execute_on_request(req).await.unwrap();
-        assert!(matches!(result, HookResult::Continue(_)));
-    }
-    #[tokio::test]
-    async fn test_short_circuit_stops_execution() {
-        let mut hooks = LifecycleHooks::new();
-        hooks.add_on_request(Arc::new(ShortCircuitHook {
-            name: "short_circuit".to_string(),
-        }));
-        hooks.add_on_request(Arc::new(ContinueHook {
-            name: "never_executed".to_string(),
-        }));
-        let req = Request::builder().body(Body::empty()).unwrap();
-        let result = hooks.execute_on_request(req).await.unwrap();
-        match result {
-            HookResult::ShortCircuit(_) => {}
-            HookResult::Continue(_) => panic!("Expected ShortCircuit, got Continue"),
-        }
-    }
-    #[tokio::test]
-    async fn test_on_response_hooks() {
-        let mut hooks = LifecycleHooks::new();
-        hooks.add_on_response(Arc::new(ContinueHook {
-            name: "response_hook".to_string(),
-        }));
-        let resp = Response::builder().status(StatusCode::OK).body(Body::empty()).unwrap();
-        let result = hooks.execute_on_response(resp).await.unwrap();
-        assert_eq!(result.status(), StatusCode::OK);
-    }
-    #[tokio::test]
-    async fn test_request_hook_builder() {
-        let hook = request_hook("test", |req| async move { Ok(HookResult::Continue(req)) });
-        let req = Request::builder().body(Body::empty()).unwrap();
-        let result = hook.execute_request(req).await.unwrap();
-        assert!(matches!(result, HookResult::Continue(_)));
-    }
-    #[tokio::test]
-    async fn test_request_hook_with_modification() {
-        let hook = request_hook("add_header", |mut req| async move {
-            req.headers_mut()
-                .insert("X-Custom-Header", axum::http::HeaderValue::from_static("test-value"));
-            Ok(HookResult::Continue(req))
-        });
-        let req = Request::builder().body(Body::empty()).unwrap();
-        let result = hook.execute_request(req).await.unwrap();
-        match result {
-            HookResult::Continue(req) => {
-                assert_eq!(req.headers().get("X-Custom-Header").unwrap(), "test-value");
-            }
-            HookResult::ShortCircuit(_) => panic!("Expected Continue"),
-        }
-    }
-    #[tokio::test]
-    async fn test_request_hook_short_circuit() {
-        let hook = request_hook("auth", |_req| async move {
-            let response = Response::builder()
-                .status(StatusCode::UNAUTHORIZED)
-                .body(Body::from("Unauthorized"))
-                .unwrap();
-            Ok(HookResult::ShortCircuit(response))
-        });
-        let req = Request::builder().body(Body::empty()).unwrap();
-        let result = hook.execute_request(req).await.unwrap();
-        match result {
-            HookResult::ShortCircuit(resp) => {
-                assert_eq!(resp.status(), StatusCode::UNAUTHORIZED);
-            }
-            HookResult::Continue(_) => panic!("Expected ShortCircuit"),
-        }
-    }
-    #[tokio::test]
-    async fn test_response_hook_builder() {
-        let hook = response_hook("security", |mut resp| async move {
-            resp.headers_mut()
-                .insert("X-Frame-Options", axum::http::HeaderValue::from_static("DENY"));
-            Ok(HookResult::Continue(resp))
-        });
-        let resp = Response::builder().status(StatusCode::OK).body(Body::empty()).unwrap();
-        let result = hook.execute_response(resp).await.unwrap();
-        match result {
-            HookResult::Continue(resp) => {
-                assert_eq!(resp.headers().get("X-Frame-Options").unwrap(), "DENY");
-                assert_eq!(resp.status(), StatusCode::OK);
-            }
-            HookResult::ShortCircuit(_) => panic!("Expected Continue"),
-        }
-    }
-    #[tokio::test]
-    async fn test_builder_pattern() {
-        let hooks = LifecycleHooks::builder()
-            .on_request(request_hook(
-                "logger",
-                |req| async move { Ok(HookResult::Continue(req)) },
-            ))
-            .pre_handler(request_hook("auth", |req| async move { Ok(HookResult::Continue(req)) }))
-            .on_response(response_hook("security", |resp| async move {
-                Ok(HookResult::Continue(resp))
-            }))
-            .build();
-        assert!(!hooks.is_empty());
-        let req = Request::builder().body(Body::empty()).unwrap();
-        let result = hooks.execute_on_request(req).await.unwrap();
-        assert!(matches!(result, HookResult::Continue(_)));
-    }
-    #[tokio::test]
-    async fn test_builder_with_multiple_hooks() {
-        let hooks = LifecycleHooks::builder()
-            .on_request(request_hook("first", |mut req| async move {
-                req.headers_mut()
-                    .insert("X-First", axum::http::HeaderValue::from_static("1"));
-                Ok(HookResult::Continue(req))
-            }))
-            .on_request(request_hook("second", |mut req| async move {
-                req.headers_mut()
-                    .insert("X-Second", axum::http::HeaderValue::from_static("2"));
-                Ok(HookResult::Continue(req))
-            }))
-            .build();
-        let req = Request::builder().body(Body::empty()).unwrap();
-        let result = hooks.execute_on_request(req).await.unwrap();
-        match result {
-            HookResult::Continue(req) => {
-                assert_eq!(req.headers().get("X-First").unwrap(), "1");
-                assert_eq!(req.headers().get("X-Second").unwrap(), "2");
-            }
-            HookResult::ShortCircuit(_) => panic!("Expected Continue"),
-        }
-    }
-    #[tokio::test]
-    async fn test_builder_short_circuit_stops_chain() {
-        let hooks = LifecycleHooks::builder()
-            .on_request(request_hook(
-                "first",
-                |req| async move { Ok(HookResult::Continue(req)) },
-            ))
-            .on_request(request_hook("short_circuit", |_req| async move {
-                let response = Response::builder()
-                    .status(StatusCode::FORBIDDEN)
-                    .body(Body::from("Blocked"))
-                    .unwrap();
-                Ok(HookResult::ShortCircuit(response))
-            }))
-            .on_request(request_hook("never_called", |mut req| async move {
-                req.headers_mut()
-                    .insert("X-Should-Not-Exist", axum::http::HeaderValue::from_static("value"));
-                Ok(HookResult::Continue(req))
-            }))
-            .build();
-        let req = Request::builder().body(Body::empty()).unwrap();
-        let result = hooks.execute_on_request(req).await.unwrap();
-        match result {
-            HookResult::ShortCircuit(resp) => {
-                assert_eq!(resp.status(), StatusCode::FORBIDDEN);
-            }
-            HookResult::Continue(_) => panic!("Expected ShortCircuit"),
-        }
-    }
-    #[tokio::test]
-    async fn test_all_hook_types() {
-        let hooks = LifecycleHooks::builder()
-            .on_request(request_hook("on_request", |req| async move {
-                Ok(HookResult::Continue(req))
-            }))
-            .pre_validation(request_hook("pre_validation", |req| async move {
-                Ok(HookResult::Continue(req))
-            }))
-            .pre_handler(request_hook("pre_handler", |req| async move {
-                Ok(HookResult::Continue(req))
-            }))
-            .on_response(response_hook("on_response", |resp| async move {
-                Ok(HookResult::Continue(resp))
-            }))
-            .on_error(response_hook("on_error", |resp| async move {
-                Ok(HookResult::Continue(resp))
-            }))
-            .build();
-        assert!(!hooks.is_empty());
-        let req = Request::builder().body(Body::empty()).unwrap();
-        assert!(matches!(
-            hooks.execute_on_request(req).await.unwrap(),
-            HookResult::Continue(_)
-        ));
-        let req = Request::builder().body(Body::empty()).unwrap();
-        assert!(matches!(
-            hooks.execute_pre_validation(req).await.unwrap(),
-            HookResult::Continue(_)
-        ));
-        let req = Request::builder().body(Body::empty()).unwrap();
-        assert!(matches!(
-            hooks.execute_pre_handler(req).await.unwrap(),
-            HookResult::Continue(_)
-        ));
-        let resp = Response::builder().status(StatusCode::OK).body(Body::empty()).unwrap();
-        let result = hooks.execute_on_response(resp).await.unwrap();
-        assert_eq!(result.status(), StatusCode::OK);
-        let resp = Response::builder()
-            .status(StatusCode::INTERNAL_SERVER_ERROR)
-            .body(Body::empty())
-            .unwrap();
-        let result = hooks.execute_on_error(resp).await.unwrap();
-        assert_eq!(result.status(), StatusCode::INTERNAL_SERVER_ERROR);
-    }
-    #[tokio::test]
-    async fn test_empty_builder() {
-        let hooks = LifecycleHooks::builder().build();
-        assert!(hooks.is_empty());
-        let req = Request::builder().body(Body::empty()).unwrap();
-        let result = hooks.execute_on_request(req).await.unwrap();
-        assert!(matches!(result, HookResult::Continue(_)));
-    }
-}
+use axum::{
+    body::Body,
+    http::{Request, Response},
+};
+use std::sync::Arc;
+pub mod adapter;
+pub use spikard_core::lifecycle::{HookResult, LifecycleHook};
+pub type LifecycleHooks = spikard_core::lifecycle::LifecycleHooks<Request<Body>, Response<Body>>;
+pub type LifecycleHooksBuilder = spikard_core::lifecycle::LifecycleHooksBuilder<Request<Body>, Response<Body>>;
+/// Create a request hook for the current target.
+#[cfg(not(target_arch = "wasm32"))]
+pub fn request_hook<F, Fut>(name: impl Into<String>, func: F) -> Arc<dyn LifecycleHook<Request<Body>, Response<Body>>>
+where
+    F: Fn(Request<Body>) -> Fut + Send + Sync + 'static,
+    Fut: std::future::Future<Output = Result<HookResult<Request<Body>, Response<Body>>, String>> + Send + 'static,
+{
+    spikard_core::lifecycle::request_hook::<Request<Body>, Response<Body>, _, _>(name, func)
+}
+/// Create a request hook for wasm targets (no Send on futures).
+#[cfg(target_arch = "wasm32")]
+pub fn request_hook<F, Fut>(name: impl Into<String>, func: F) -> Arc<dyn LifecycleHook<Request<Body>, Response<Body>>>
+where
+    F: Fn(Request<Body>) -> Fut + Send + Sync + 'static,
+    Fut: std::future::Future<Output = Result<HookResult<Request<Body>, Response<Body>>, String>> + 'static,
+{
+    spikard_core::lifecycle::request_hook::<Request<Body>, Response<Body>, _, _>(name, func)
+}
+/// Create a response hook for the current target.
+#[cfg(not(target_arch = "wasm32"))]
+pub fn response_hook<F, Fut>(name: impl Into<String>, func: F) -> Arc<dyn LifecycleHook<Request<Body>, Response<Body>>>
+where
+    F: Fn(Response<Body>) -> Fut + Send + Sync + 'static,
+    Fut: std::future::Future<Output = Result<HookResult<Response<Body>, Response<Body>>, String>> + Send + 'static,
+{
+    spikard_core::lifecycle::response_hook::<Request<Body>, Response<Body>, _, _>(name, func)
+}
+/// Create a response hook for wasm targets (no Send on futures).
+#[cfg(target_arch = "wasm32")]
+pub fn response_hook<F, Fut>(name: impl Into<String>, func: F) -> Arc<dyn LifecycleHook<Request<Body>, Response<Body>>>
+where
+    F: Fn(Response<Body>) -> Fut + Send + Sync + 'static,
+    Fut: std::future::Future<Output = Result<HookResult<Response<Body>, Response<Body>>, String>> + 'static,
+{
+    spikard_core::lifecycle::response_hook::<Request<Body>, Response<Body>, _, _>(name, func)
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use axum::body::Body;
+    use axum::http::{Request, Response, StatusCode};
+    use std::future::Future;
+    use std::pin::Pin;
+    /// Test hook that always continues
+    struct ContinueHook {
+        name: String,
+    }
+    impl LifecycleHook<Request<Body>, Response<Body>> for ContinueHook {
+        fn name(&self) -> &str {
+            &self.name
+        }
+        fn execute_request<'a>(
+            &'a self,
+            req: Request<Body>,
+        ) -> Pin<Box<dyn Future<Output = Result<HookResult<Request<Body>, Response<Body>>, String>> + Send + 'a>>
+        {
+            Box::pin(async move { Ok(HookResult::Continue(req)) })
+        }
+        fn execute_response<'a>(
+            &'a self,
+            resp: Response<Body>,
+        ) -> Pin<Box<dyn Future<Output = Result<HookResult<Response<Body>, Response<Body>>, String>> + Send + 'a>>
+        {
+            Box::pin(async move { Ok(HookResult::Continue(resp)) })
+        }
+    }
+    /// Test hook that short-circuits with a 401 response
+    struct ShortCircuitHook {
+        name: String,
+    }
+    impl LifecycleHook<Request<Body>, Response<Body>> for ShortCircuitHook {
+        fn name(&self) -> &str {
+            &self.name
+        }
+        fn execute_request<'a>(
+            &'a self,
+            _req: Request<Body>,
+        ) -> Pin<Box<dyn Future<Output = Result<HookResult<Request<Body>, Response<Body>>, String>> + Send + 'a>>
+        {
+            Box::pin(async move {
+                let response = Response::builder()
+                    .status(StatusCode::UNAUTHORIZED)
+                    .body(Body::from("Unauthorized"))
+                    .unwrap();
+                Ok(HookResult::ShortCircuit(response))
+            })
+        }
+        fn execute_response<'a>(
+            &'a self,
+            _resp: Response<Body>,
+        ) -> Pin<Box<dyn Future<Output = Result<HookResult<Response<Body>, Response<Body>>, String>> + Send + 'a>>
+        {
+            Box::pin(async move {
+                let response = Response::builder()
+                    .status(StatusCode::UNAUTHORIZED)
+                    .body(Body::from("Unauthorized"))
+                    .unwrap();
+                Ok(HookResult::ShortCircuit(response))
+            })
+        }
+    }
+    #[tokio::test]
+    async fn test_empty_hooks_fast_path() {
+        let hooks = LifecycleHooks::new();
+        assert!(hooks.is_empty());
+        let req = Request::builder().body(Body::empty()).unwrap();
+        let result = hooks.execute_on_request(req).await.unwrap();
+        assert!(matches!(result, HookResult::Continue(_)));
+    }
+    #[tokio::test]
+    async fn test_on_request_continue() {
+        let mut hooks = LifecycleHooks::new();
+        hooks.add_on_request(Arc::new(ContinueHook {
+            name: "test".to_string(),
+        }));
+        let req = Request::builder().body(Body::empty()).unwrap();
+        let result = hooks.execute_on_request(req).await.unwrap();
+        assert!(matches!(result, HookResult::Continue(_)));
+    }
+    #[tokio::test]
+    async fn test_on_request_short_circuit() {
+        let mut hooks = LifecycleHooks::new();
+        hooks.add_on_request(Arc::new(ShortCircuitHook {
+            name: "auth_check".to_string(),
+        }));
+        let req = Request::builder().body(Body::empty()).unwrap();
+        let result = hooks.execute_on_request(req).await.unwrap();
+        match result {
+            HookResult::ShortCircuit(resp) => {
+                assert_eq!(resp.status(), StatusCode::UNAUTHORIZED);
+            }
+            HookResult::Continue(_) => panic!("Expected ShortCircuit, got Continue"),
+        }
+    }
+    #[tokio::test]
+    async fn test_multiple_hooks_in_order() {
+        let mut hooks = LifecycleHooks::new();
+        hooks.add_on_request(Arc::new(ContinueHook {
+            name: "first".to_string(),
+        }));
+        hooks.add_on_request(Arc::new(ContinueHook {
+            name: "second".to_string(),
+        }));
+        let req = Request::builder().body(Body::empty()).unwrap();
+        let result = hooks.execute_on_request(req).await.unwrap();
+        assert!(matches!(result, HookResult::Continue(_)));
+    }
+    #[tokio::test]
+    async fn test_short_circuit_stops_execution() {
+        let mut hooks = LifecycleHooks::new();
+        hooks.add_on_request(Arc::new(ShortCircuitHook {
+            name: "short_circuit".to_string(),
+        }));
+        hooks.add_on_request(Arc::new(ContinueHook {
+            name: "never_executed".to_string(),
+        }));
+        let req = Request::builder().body(Body::empty()).unwrap();
+        let result = hooks.execute_on_request(req).await.unwrap();
+        match result {
+            HookResult::ShortCircuit(_) => {}
+            HookResult::Continue(_) => panic!("Expected ShortCircuit, got Continue"),
+        }
+    }
+    #[tokio::test]
+    async fn test_on_response_hooks() {
+        let mut hooks = LifecycleHooks::new();
+        hooks.add_on_response(Arc::new(ContinueHook {
+            name: "response_hook".to_string(),
+        }));
+        let resp = Response::builder().status(StatusCode::OK).body(Body::empty()).unwrap();
+        let result = hooks.execute_on_response(resp).await.unwrap();
+        assert_eq!(result.status(), StatusCode::OK);
+    }
+    #[tokio::test]
+    async fn test_request_hook_builder() {
+        let hook = request_hook("test", |req| async move { Ok(HookResult::Continue(req)) });
+        let req = Request::builder().body(Body::empty()).unwrap();
+        let result = hook.execute_request(req).await.unwrap();
+        assert!(matches!(result, HookResult::Continue(_)));
+    }
+    #[tokio::test]
+    async fn test_request_hook_with_modification() {
+        let hook = request_hook("add_header", |mut req| async move {
+            req.headers_mut()
+                .insert("X-Custom-Header", axum::http::HeaderValue::from_static("test-value"));
+            Ok(HookResult::Continue(req))
+        });
+        let req = Request::builder().body(Body::empty()).unwrap();
+        let result = hook.execute_request(req).await.unwrap();
+        match result {
+            HookResult::Continue(req) => {
+                assert_eq!(req.headers().get("X-Custom-Header").unwrap(), "test-value");
+            }
+            HookResult::ShortCircuit(_) => panic!("Expected Continue"),
+        }
+    }
+    #[tokio::test]
+    async fn test_request_hook_short_circuit() {
+        let hook = request_hook("auth", |_req| async move {
+            let response = Response::builder()
+                .status(StatusCode::UNAUTHORIZED)
+                .body(Body::from("Unauthorized"))
+                .unwrap();
+            Ok(HookResult::ShortCircuit(response))
+        });
+        let req = Request::builder().body(Body::empty()).unwrap();
+        let result = hook.execute_request(req).await.unwrap();
+        match result {
+            HookResult::ShortCircuit(resp) => {
+                assert_eq!(resp.status(), StatusCode::UNAUTHORIZED);
+            }
+            HookResult::Continue(_) => panic!("Expected ShortCircuit"),
+        }
+    }
+    #[tokio::test]
+    async fn test_response_hook_builder() {
+        let hook = response_hook("security", |mut resp| async move {
+            resp.headers_mut()
+                .insert("X-Frame-Options", axum::http::HeaderValue::from_static("DENY"));
+            Ok(HookResult::Continue(resp))
+        });
+        let resp = Response::builder().status(StatusCode::OK).body(Body::empty()).unwrap();
+        let result = hook.execute_response(resp).await.unwrap();
+        match result {
+            HookResult::Continue(resp) => {
+                assert_eq!(resp.headers().get("X-Frame-Options").unwrap(), "DENY");
+                assert_eq!(resp.status(), StatusCode::OK);
+            }
+            HookResult::ShortCircuit(_) => panic!("Expected Continue"),
+        }
+    }
+    #[tokio::test]
+    async fn test_builder_pattern() {
+        let hooks = LifecycleHooks::builder()
+            .on_request(request_hook(
+                "logger",
+                |req| async move { Ok(HookResult::Continue(req)) },
+            ))
+            .pre_handler(request_hook("auth", |req| async move { Ok(HookResult::Continue(req)) }))
+            .on_response(response_hook("security", |resp| async move {
+                Ok(HookResult::Continue(resp))
+            }))
+            .build();
+        assert!(!hooks.is_empty());
+        let req = Request::builder().body(Body::empty()).unwrap();
+        let result = hooks.execute_on_request(req).await.unwrap();
+        assert!(matches!(result, HookResult::Continue(_)));
+    }
+    #[tokio::test]
+    async fn test_builder_with_multiple_hooks() {
+        let hooks = LifecycleHooks::builder()
+            .on_request(request_hook("first", |mut req| async move {
+                req.headers_mut()
+                    .insert("X-First", axum::http::HeaderValue::from_static("1"));
+                Ok(HookResult::Continue(req))
+            }))
+            .on_request(request_hook("second", |mut req| async move {
+                req.headers_mut()
+                    .insert("X-Second", axum::http::HeaderValue::from_static("2"));
+                Ok(HookResult::Continue(req))
+            }))
+            .build();
+        let req = Request::builder().body(Body::empty()).unwrap();
+        let result = hooks.execute_on_request(req).await.unwrap();
+        match result {
+            HookResult::Continue(req) => {
+                assert_eq!(req.headers().get("X-First").unwrap(), "1");
+                assert_eq!(req.headers().get("X-Second").unwrap(), "2");
+            }
+            HookResult::ShortCircuit(_) => panic!("Expected Continue"),
+        }
+    }
+    #[tokio::test]
+    async fn test_builder_short_circuit_stops_chain() {
+        let hooks = LifecycleHooks::builder()
+            .on_request(request_hook(
+                "first",
+                |req| async move { Ok(HookResult::Continue(req)) },
+            ))
+            .on_request(request_hook("short_circuit", |_req| async move {
+                let response = Response::builder()
+                    .status(StatusCode::FORBIDDEN)
+                    .body(Body::from("Blocked"))
+                    .unwrap();
+                Ok(HookResult::ShortCircuit(response))
+            }))
+            .on_request(request_hook("never_called", |mut req| async move {
+                req.headers_mut()
+                    .insert("X-Should-Not-Exist", axum::http::HeaderValue::from_static("value"));
+                Ok(HookResult::Continue(req))
+            }))
+            .build();
+        let req = Request::builder().body(Body::empty()).unwrap();
+        let result = hooks.execute_on_request(req).await.unwrap();
+        match result {
+            HookResult::ShortCircuit(resp) => {
+                assert_eq!(resp.status(), StatusCode::FORBIDDEN);
+            }
+            HookResult::Continue(_) => panic!("Expected ShortCircuit"),
+        }
+    }
+    #[tokio::test]
+    async fn test_all_hook_types() {
+        let hooks = LifecycleHooks::builder()
+            .on_request(request_hook("on_request", |req| async move {
+                Ok(HookResult::Continue(req))
+            }))
+            .pre_validation(request_hook("pre_validation", |req| async move {
+                Ok(HookResult::Continue(req))
+            }))
+            .pre_handler(request_hook("pre_handler", |req| async move {
+                Ok(HookResult::Continue(req))
+            }))
+            .on_response(response_hook("on_response", |resp| async move {
+                Ok(HookResult::Continue(resp))
+            }))
+            .on_error(response_hook("on_error", |resp| async move {
+                Ok(HookResult::Continue(resp))
+            }))
+            .build();
+        assert!(!hooks.is_empty());
+        let req = Request::builder().body(Body::empty()).unwrap();
+        assert!(matches!(
+            hooks.execute_on_request(req).await.unwrap(),
+            HookResult::Continue(_)
+        ));
+        let req = Request::builder().body(Body::empty()).unwrap();
+        assert!(matches!(
+            hooks.execute_pre_validation(req).await.unwrap(),
+            HookResult::Continue(_)
+        ));
+        let req = Request::builder().body(Body::empty()).unwrap();
+        assert!(matches!(
+            hooks.execute_pre_handler(req).await.unwrap(),
+            HookResult::Continue(_)
+        ));
+        let resp = Response::builder().status(StatusCode::OK).body(Body::empty()).unwrap();
+        let result = hooks.execute_on_response(resp).await.unwrap();
+        assert_eq!(result.status(), StatusCode::OK);
+        let resp = Response::builder()
+            .status(StatusCode::INTERNAL_SERVER_ERROR)
+            .body(Body::empty())
+            .unwrap();
+        let result = hooks.execute_on_error(resp).await.unwrap();
+        assert_eq!(result.status(), StatusCode::INTERNAL_SERVER_ERROR);
+    }
+    #[tokio::test]
+    async fn test_empty_builder() {
+        let hooks = LifecycleHooks::builder().build();
+        assert!(hooks.is_empty());
+        let req = Request::builder().body(Body::empty()).unwrap();
+        let result = hooks.execute_on_request(req).await.unwrap();
+        assert!(matches!(result, HookResult::Continue(_)));
+    }
+}