RubyGems - spikard - Versions diffs - 0.8.3 → 0.10.1 - Mend

spikard 0.8.3 → 0.10.1

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 (106) hide show

data/vendor/crates/spikard-http/src/handler_trait.rs CHANGED Viewed

@@ -5,14 +5,52 @@
 use axum::{
     body::Body,
-    http::{Request, Response, StatusCode},
+    http::{HeaderValue, Request, Response, StatusCode, header::HeaderName},
 };
+use bytes::Bytes;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use std::collections::HashMap;
 use std::future::Future;
 use std::pin::Pin;
+/// Pre-built response for routes that always return the same content.
+///
+/// When a route is registered with a `StaticResponse`, the server bypasses
+/// handler execution, validation, lifecycle hooks, and request extraction —
+/// returning the cached response directly. This is ideal for health-check
+/// endpoints or any route whose output never changes at runtime.
+#[derive(Clone, Debug)]
+pub struct StaticResponse {
+    pub status: u16,
+    pub headers: Vec<(HeaderName, HeaderValue)>,
+    pub body: Bytes,
+    pub content_type: HeaderValue,
+}
+impl StaticResponse {
+    /// Build an `axum::response::Response` from this static response.
+    ///
+    /// This is the single canonical path for constructing HTTP responses from
+    /// static data — used by the FastRouter middleware, the Axum fallback
+    /// handler, and the `StaticResponseHandler::call` fallback.
+    pub fn to_response(&self) -> Response<Body> {
+        let status = StatusCode::from_u16(self.status).unwrap_or(StatusCode::OK);
+        let mut builder = Response::builder()
+            .status(status)
+            .header(axum::http::header::CONTENT_TYPE, self.content_type.clone());
+        for (name, value) in &self.headers {
+            builder = builder.header(name.clone(), value.clone());
+        }
+        builder.body(Body::from(self.body.clone())).unwrap_or_else(|_| {
+            Response::builder()
+                .status(StatusCode::INTERNAL_SERVER_ERROR)
+                .body(Body::from("Failed to build static response"))
+                .expect("fallback response must build")
+        })
+    }
+}
 /// Request data extracted from HTTP request
 /// This is the language-agnostic representation passed to handlers
 ///
@@ -25,11 +63,11 @@ use std::pin::Pin;
 #[derive(Debug, Clone)]
 pub struct RequestData {
     pub path_params: std::sync::Arc<HashMap<String, String>>,
-    pub query_params: Value,
+    pub query_params: std::sync::Arc<Value>,
     /// Validated parameters produced by ParameterValidator (query/path/header/cookie combined).
-    pub validated_params: Option<Value>,
+    pub validated_params: Option<std::sync::Arc<Value>>,
     pub raw_query_params: std::sync::Arc<HashMap<String, Vec<String>>>,
-    pub body: Value,
+    pub body: std::sync::Arc<Value>,
     pub raw_body: Option<bytes::Bytes>,
     pub headers: std::sync::Arc<HashMap<String, String>>,
     pub cookies: std::sync::Arc<HashMap<String, String>>,
@@ -53,10 +91,10 @@ impl Serialize for RequestData {
         let mut state = serializer.serialize_struct("RequestData", field_count)?;
         state.serialize_field("path_params", &*self.path_params)?;
-        state.serialize_field("query_params", &self.query_params)?;
-        state.serialize_field("validated_params", &self.validated_params)?;
+        state.serialize_field("query_params", &*self.query_params)?;
+        state.serialize_field("validated_params", &self.validated_params.as_deref())?;
         state.serialize_field("raw_query_params", &*self.raw_query_params)?;
-        state.serialize_field("body", &self.body)?;
+        state.serialize_field("body", &*self.body)?;
         state.serialize_field("raw_body", &self.raw_body.as_ref().map(|b| b.as_ref()))?;
         state.serialize_field("headers", &*self.headers)?;
         state.serialize_field("cookies", &*self.cookies)?;
@@ -124,16 +162,16 @@ impl<'de> Deserialize<'de> for RequestData {
                             path_params = Some(std::sync::Arc::new(map.next_value()?));
                         }
                         Field::QueryParams => {
-                            query_params = Some(map.next_value()?);
+                            query_params = Some(std::sync::Arc::new(map.next_value()?));
                         }
                         Field::RawQueryParams => {
                             raw_query_params = Some(std::sync::Arc::new(map.next_value()?));
                         }
                         Field::ValidatedParams => {
-                            validated_params = Some(map.next_value()?);
+                            validated_params = Some(std::sync::Arc::new(map.next_value()?));
                         }
                         Field::Body => {
-                            body = Some(map.next_value()?);
+                            body = Some(std::sync::Arc::new(map.next_value()?));
                         }
                         Field::RawBody => {
                             let bytes_vec: Option<Vec<u8>> = map.next_value()?;
@@ -269,6 +307,69 @@ pub trait Handler: Send + Sync {
     fn wants_request_extensions(&self) -> bool {
         false
     }
+    /// Return a pre-built static response if this handler always produces the
+    /// same output. When `Some`, the server bypasses the full middleware
+    /// pipeline and serves the pre-built response directly.
+    fn static_response(&self) -> Option<StaticResponse> {
+        None
+    }
+}
+/// A no-op handler that declares a static response.
+///
+/// Language bindings create this handler when a route is registered with
+/// `static_response` configuration. The handler's `call()` method is never
+/// invoked — the server uses the `static_response()` return value instead.
+pub struct StaticResponseHandler {
+    response: StaticResponse,
+}
+impl StaticResponseHandler {
+    /// Create a new static response handler.
+    pub fn new(response: StaticResponse) -> Self {
+        Self { response }
+    }
+    /// Build a `StaticResponse` from common parameters.
+    ///
+    /// Convenience constructor for language bindings that pass status, body,
+    /// content-type, and optional extra headers.
+    pub fn from_parts(
+        status: u16,
+        body: impl Into<Bytes>,
+        content_type: Option<&str>,
+        extra_headers: Vec<(HeaderName, HeaderValue)>,
+    ) -> Self {
+        let ct = content_type
+            .and_then(|s| HeaderValue::from_str(s).ok())
+            .unwrap_or_else(|| HeaderValue::from_static("text/plain; charset=utf-8"));
+        Self {
+            response: StaticResponse {
+                status,
+                headers: extra_headers,
+                body: body.into(),
+                content_type: ct,
+            },
+        }
+    }
+}
+impl Handler for StaticResponseHandler {
+    fn call(
+        &self,
+        _request: Request<Body>,
+        _request_data: RequestData,
+    ) -> Pin<Box<dyn Future<Output = HandlerResult> + Send + '_>> {
+        // This should never be called — the server fast-path intercepts first.
+        // Provide a working fallback just in case.
+        let resp = self.response.to_response();
+        Box::pin(async move { Ok(resp) })
+    }
+    fn static_response(&self) -> Option<StaticResponse> {
+        Some(self.response.clone())
+    }
 }
 /// Validated parameters from request (path, query, headers, cookies)
@@ -285,10 +386,10 @@ mod tests {
     fn minimal_request_data() -> RequestData {
         RequestData {
             path_params: std::sync::Arc::new(HashMap::new()),
-            query_params: Value::Object(serde_json::Map::new()),
+            query_params: std::sync::Arc::new(Value::Object(serde_json::Map::new())),
             validated_params: None,
             raw_query_params: std::sync::Arc::new(HashMap::new()),
-            body: Value::Null,
+            body: std::sync::Arc::new(Value::Null),
             raw_body: None,
             headers: std::sync::Arc::new(HashMap::new()),
             cookies: std::sync::Arc::new(HashMap::new()),
@@ -341,7 +442,7 @@ mod tests {
         });
         let data = RequestData {
-            query_params,
+            query_params: std::sync::Arc::new(query_params),
             ..minimal_request_data()
         };
@@ -416,7 +517,7 @@ mod tests {
         });
         let data = RequestData {
-            body,
+            body: std::sync::Arc::new(body),
             ..minimal_request_data()
         };
@@ -481,7 +582,7 @@ mod tests {
         });
         let data = RequestData {
-            body,
+            body: std::sync::Arc::new(body),
             ..minimal_request_data()
         };
@@ -512,10 +613,10 @@ mod tests {
         let data = RequestData {
             path_params: std::sync::Arc::new(path_params),
-            query_params: serde_json::json!({"page": 1}),
+            query_params: std::sync::Arc::new(serde_json::json!({"page": 1})),
             validated_params: None,
             raw_query_params: std::sync::Arc::new(raw_query_params),
-            body,
+            body: std::sync::Arc::new(body),
             raw_body: Some(raw_body),
             headers: std::sync::Arc::new(headers),
             cookies: std::sync::Arc::new(cookies),
@@ -642,14 +743,14 @@ mod tests {
                 map.insert("id".to_string(), "999".to_string());
                 map
             }),
-            query_params: serde_json::json!({"limit": 50, "offset": 10}),
+            query_params: std::sync::Arc::new(serde_json::json!({"limit": 50, "offset": 10})),
             validated_params: None,
             raw_query_params: std::sync::Arc::new({
                 let mut map = HashMap::new();
                 map.insert("sort".to_string(), vec!["name".to_string(), "date".to_string()]);
                 map
             }),
-            body: serde_json::json!({"title": "New Post", "content": "Hello World"}),
+            body: std::sync::Arc::new(serde_json::json!({"title": "New Post", "content": "Hello World"})),
             raw_body: None,
             headers: std::sync::Arc::new({
                 let mut map = HashMap::new();
@@ -689,7 +790,7 @@ mod tests {
         }
         let data = RequestData {
-            body: Value::Object(large_object),
+            body: std::sync::Arc::new(Value::Object(large_object)),
             ..minimal_request_data()
         };
@@ -704,10 +805,10 @@ mod tests {
     fn test_request_data_empty_collections() {
         let data = RequestData {
             path_params: std::sync::Arc::new(HashMap::new()),
-            query_params: Value::Object(serde_json::Map::new()),
+            query_params: std::sync::Arc::new(Value::Object(serde_json::Map::new())),
             validated_params: None,
             raw_query_params: std::sync::Arc::new(HashMap::new()),
-            body: Value::Object(serde_json::Map::new()),
+            body: std::sync::Arc::new(Value::Object(serde_json::Map::new())),
             raw_body: None,
             headers: std::sync::Arc::new(HashMap::new()),
             cookies: std::sync::Arc::new(HashMap::new()),
@@ -738,7 +839,7 @@ mod tests {
             method: "POST".to_string(),
             path: "/api/v1/users\\test".to_string(),
             headers: std::sync::Arc::new(headers),
-            body: serde_json::json!({"note": "Contains\nnewline"}),
+            body: std::sync::Arc::new(serde_json::json!({"note": "Contains\nnewline"})),
             ..minimal_request_data()
         };
@@ -779,7 +880,7 @@ mod tests {
     #[test]
     fn test_request_data_serialization_null_body() {
         let data = RequestData {
-            body: Value::Null,
+            body: std::sync::Arc::new(Value::Null),
             ..minimal_request_data()
         };
@@ -791,7 +892,7 @@ mod tests {
     #[test]
     fn test_request_data_serialization_array_body() {
         let data = RequestData {
-            body: serde_json::json!([1, 2, 3, "four", {"five": 5}]),
+            body: std::sync::Arc::new(serde_json::json!([1, 2, 3, "four", {"five": 5}])),
             ..minimal_request_data()
         };
@@ -807,12 +908,12 @@ mod tests {
     #[test]
     fn test_request_data_serialization_numeric_edge_cases() {
         let data = RequestData {
-            body: serde_json::json!({
+            body: std::sync::Arc::new(serde_json::json!({
                 "zero": 0,
                 "negative": -42,
                 "large": 9223372036854775807i64,
                 "float": 3.14159
-            }),
+            })),
             ..minimal_request_data()
         };
@@ -835,4 +936,80 @@ mod tests {
         assert_eq!(validated.params.get("id").unwrap(), &Value::String("123".to_string()));
         assert_eq!(validated.params.get("active").unwrap(), &Value::Bool(true));
     }
+    #[test]
+    fn test_static_response_handler_new() {
+        let sr = StaticResponse {
+            status: 200,
+            headers: vec![],
+            body: Bytes::from("OK"),
+            content_type: HeaderValue::from_static("text/plain"),
+        };
+        let handler = StaticResponseHandler::new(sr);
+        let resp = handler.static_response();
+        assert!(resp.is_some());
+        let resp = resp.unwrap();
+        assert_eq!(resp.status, 200);
+        assert_eq!(resp.body.as_ref(), b"OK");
+    }
+    #[test]
+    fn test_static_response_handler_from_parts_defaults() {
+        let handler = StaticResponseHandler::from_parts(204, "No Content", None, vec![]);
+        let resp = handler.static_response().unwrap();
+        assert_eq!(resp.status, 204);
+        assert_eq!(resp.body.as_ref(), b"No Content");
+        assert_eq!(resp.content_type, "text/plain; charset=utf-8");
+    }
+    #[test]
+    fn test_static_response_handler_from_parts_custom_content_type() {
+        let handler = StaticResponseHandler::from_parts(200, r#"{"ok":true}"#, Some("application/json"), vec![]);
+        let resp = handler.static_response().unwrap();
+        assert_eq!(resp.content_type, "application/json");
+    }
+    #[test]
+    fn test_static_response_handler_from_parts_extra_headers() {
+        let handler = StaticResponseHandler::from_parts(
+            200,
+            "OK",
+            None,
+            vec![(HeaderName::from_static("x-custom"), HeaderValue::from_static("value"))],
+        );
+        let resp = handler.static_response().unwrap();
+        assert_eq!(resp.headers.len(), 1);
+        assert_eq!(resp.headers[0].0, "x-custom");
+        assert_eq!(resp.headers[0].1, "value");
+    }
+    #[tokio::test]
+    async fn test_static_response_handler_call_fallback() {
+        use http_body_util::BodyExt;
+        let handler = StaticResponseHandler::from_parts(201, "created", Some("text/plain"), vec![]);
+        let request = Request::builder().body(Body::empty()).unwrap();
+        let result = handler.call(request, minimal_request_data()).await;
+        assert!(result.is_ok());
+        let response = result.unwrap();
+        assert_eq!(response.status(), StatusCode::CREATED);
+        assert_eq!(response.headers().get("content-type").unwrap(), "text/plain");
+        let body = response.into_body().collect().await.unwrap().to_bytes();
+        assert_eq!(body.as_ref(), b"created");
+    }
+    #[test]
+    fn test_default_handler_static_response_is_none() {
+        struct DummyHandler;
+        impl Handler for DummyHandler {
+            fn call(
+                &self,
+                _: Request<Body>,
+                _: RequestData,
+            ) -> Pin<Box<dyn Future<Output = HandlerResult> + Send + '_>> {
+                Box::pin(async { Err((StatusCode::OK, String::new())) })
+            }
+        }
+        assert!(DummyHandler.static_response().is_none());
+    }
 }

data/vendor/crates/spikard-http/src/handler_trait_tests.rs CHANGED Viewed

@@ -99,10 +99,10 @@ mod tests {
         let request_data = RequestData {
             path_params: Arc::new(path_params),
-            query_params: json!({"page": 1}),
+            query_params: Arc::new(json!({"page": 1})),
             validated_params: None,
             raw_query_params: Arc::new(HashMap::new()),
-            body: json!({"test": "data"}),
+            body: Arc::new(json!({"test": "data"})),
             raw_body: None,
             headers: Arc::new(headers),
             cookies: Arc::new(HashMap::new()),
@@ -131,10 +131,10 @@ mod tests {
         let request_data = RequestData {
             path_params: Arc::new(HashMap::new()),
-            query_params: Value::Null,
+            query_params: Arc::new(Value::Null),
             validated_params: None,
             raw_query_params: Arc::new(HashMap::new()),
-            body: Value::Null,
+            body: Arc::new(Value::Null),
             raw_body: None,
             headers: Arc::new(HashMap::new()),
             cookies: Arc::new(HashMap::new()),
@@ -170,10 +170,10 @@ mod tests {
         let request_data = RequestData {
             path_params: Arc::new(HashMap::new()),
-            query_params: json!({"api_key": "secret123"}),
+            query_params: Arc::new(json!({"api_key": "secret123"})),
             validated_params: None,
             raw_query_params: Arc::new(raw_query_params.clone()),
-            body: Value::Null,
+            body: Arc::new(Value::Null),
             raw_body: None,
             headers: Arc::new(HashMap::new()),
             cookies: Arc::new(HashMap::new()),
@@ -194,10 +194,10 @@ mod tests {
         let request_data_no_param = RequestData {
             path_params: Arc::new(HashMap::new()),
-            query_params: Value::Null,
+            query_params: Arc::new(Value::Null),
             validated_params: None,
             raw_query_params: Arc::new(HashMap::new()),
-            body: Value::Null,
+            body: Arc::new(Value::Null),
             raw_body: None,
             headers: Arc::new(HashMap::new()),
             cookies: Arc::new(HashMap::new()),
@@ -232,10 +232,10 @@ mod tests {
         let request_data = RequestData {
             path_params: Arc::new(path_params),
-            query_params: json!({"filter": "active"}),
+            query_params: Arc::new(json!({"filter": "active"})),
             validated_params: None,
             raw_query_params: Arc::new(raw_query_params),
-            body: json!({"name": "test"}),
+            body: Arc::new(json!({"name": "test"})),
             raw_body: None,
             headers: Arc::new(HashMap::new()),
             cookies: Arc::new(HashMap::new()),
@@ -251,17 +251,17 @@ mod tests {
         assert_eq!(deserialized.method, "PUT");
         assert_eq!(deserialized.path, "/users/42");
         assert_eq!(deserialized.path_params.get("user_id").unwrap(), "42");
-        assert_eq!(deserialized.body, json!({"name": "test"}));
+        assert_eq!(*deserialized.body, json!({"name": "test"}));
     }
     #[test]
     fn test_request_data_default_values() {
         let request_data = RequestData {
             path_params: Arc::new(HashMap::new()),
-            query_params: Value::Null,
+            query_params: Arc::new(Value::Null),
             validated_params: None,
             raw_query_params: Arc::new(HashMap::new()),
-            body: Value::Null,
+            body: Arc::new(Value::Null),
             raw_body: None,
             headers: Arc::new(HashMap::new()),
             cookies: Arc::new(HashMap::new()),
@@ -278,8 +278,8 @@ mod tests {
         assert!(request_data.raw_query_params.is_empty());
         assert!(request_data.headers.is_empty());
         assert!(request_data.cookies.is_empty());
-        assert_eq!(request_data.body, Value::Null);
-        assert_eq!(request_data.query_params, Value::Null);
+        assert_eq!(*request_data.body, Value::Null);
+        assert_eq!(*request_data.query_params, Value::Null);
     }
     #[test]

data/vendor/crates/spikard-http/src/jsonrpc/http_handler.rs CHANGED Viewed

@@ -159,10 +159,10 @@ pub async fn handle_jsonrpc(
 fn create_jsonrpc_request_data(headers: &HeaderMap, uri: &axum::http::Uri) -> RequestData {
     RequestData {
         path_params: Arc::new(HashMap::new()),
-        query_params: serde_json::json!({}),
+        query_params: Arc::new(serde_json::json!({})),
         validated_params: None,
         raw_query_params: Arc::new(HashMap::new()),
-        body: serde_json::json!({}),
+        body: Arc::new(serde_json::json!({})),
         raw_body: None,
         headers: Arc::new(extract_headers(headers)),
         cookies: Arc::new(HashMap::new()),

data/vendor/crates/spikard-http/src/jsonrpc/router.rs CHANGED Viewed

@@ -348,10 +348,10 @@ mod tests {
     fn create_test_request_data() -> RequestData {
         RequestData {
             path_params: Arc::new(HashMap::new()),
-            query_params: Value::Object(serde_json::Map::new()),
+            query_params: Arc::new(Value::Object(serde_json::Map::new())),
             validated_params: None,
             raw_query_params: Arc::new(HashMap::new()),
-            body: Value::Null,
+            body: Arc::new(Value::Null),
             raw_body: None,
             headers: Arc::new(HashMap::new()),
             cookies: Arc::new(HashMap::new()),

data/vendor/crates/spikard-http/src/lib.rs CHANGED Viewed

@@ -45,7 +45,7 @@ pub use grpc::{
     StreamingRequest, StreamingResponse,
 };
 pub use handler_response::HandlerResponse;
-pub use handler_trait::{Handler, HandlerResult, RequestData, ValidatedParams};
+pub use handler_trait::{Handler, HandlerResult, RequestData, StaticResponse, StaticResponseHandler, ValidatedParams};
 pub use jsonrpc::JsonRpcConfig;
 pub use lifecycle::{HookResult, LifecycleHook, LifecycleHooks, LifecycleHooksBuilder, request_hook, response_hook};
 pub use openapi::{ContactInfo, LicenseInfo, OpenApiConfig, SecuritySchemeInfo, ServerInfo};

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

@@ -183,7 +183,7 @@ mod tests {
             }
             fn execute_request<'a>(
-                &'a self,
+                &self,
                 req: Request<Body>,
             ) -> Pin<Box<dyn Future<Output = Result<HookResult<Request<Body>, Response<Body>>, String>> + Send + 'a>>
             {
@@ -191,7 +191,7 @@ mod tests {
             }
             fn execute_response<'a>(
-                &'a self,
+                &self,
                 resp: Response<Body>,
             ) -> Pin<Box<dyn Future<Output = Result<HookResult<Response<Body>, Response<Body>>, String>> + Send + 'a>>
             {

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

@@ -70,7 +70,7 @@ mod tests {
         }
         fn execute_request<'a>(
-            &'a self,
+            &self,
             req: Request<Body>,
         ) -> Pin<Box<dyn Future<Output = Result<HookResult<Request<Body>, Response<Body>>, String>> + Send + 'a>>
         {
@@ -78,7 +78,7 @@ mod tests {
         }
         fn execute_response<'a>(
-            &'a self,
+            &self,
             resp: Response<Body>,
         ) -> Pin<Box<dyn Future<Output = Result<HookResult<Response<Body>, Response<Body>>, String>> + Send + 'a>>
         {
@@ -97,7 +97,7 @@ mod tests {
         }
         fn execute_request<'a>(
-            &'a self,
+            &self,
             _req: Request<Body>,
         ) -> Pin<Box<dyn Future<Output = Result<HookResult<Request<Body>, Response<Body>>, String>> + Send + 'a>>
         {
@@ -111,7 +111,7 @@ mod tests {
         }
         fn execute_response<'a>(
-            &'a self,
+            &self,
             _resp: Response<Body>,
         ) -> Pin<Box<dyn Future<Output = Result<HookResult<Response<Body>, Response<Body>>, String>> + Send + 'a>>
         {

data/vendor/crates/spikard-http/src/openapi/spec_generation.rs CHANGED Viewed

@@ -188,6 +188,7 @@ mod tests {
             #[cfg(feature = "di")]
             handler_dependencies: None,
             jsonrpc_method: None,
+            static_response: None,
         }
     }
@@ -654,6 +655,7 @@ mod tests {
             #[cfg(feature = "di")]
             handler_dependencies: None,
             jsonrpc_method: None,
+            static_response: None,
         };
         let result = route_to_operation(&route);