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

spikard 0.8.3 → 0.10.2

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/server/handler.rs CHANGED Viewed

@@ -43,9 +43,12 @@ impl Handler for ValidatingHandler {
         req: axum::http::Request<Body>,
         mut request_data: RequestData,
     ) -> Pin<Box<dyn Future<Output = HandlerResult> + Send + '_>> {
-        let inner = self.inner.clone();
-        let request_validator = self.request_validator.clone();
-        let parameter_validator = self.parameter_validator.clone();
+        // Performance: Use references where possible to avoid Arc clones on every request.
+        // The Arc clones here are cheap (atomic increment), but we store references
+        // to Option<Arc<...>> to avoid cloning when validators are None (common case).
+        let inner = &self.inner;
+        let request_validator = &self.request_validator;
+        let parameter_validator = &self.parameter_validator;
         Box::pin(async move {
             let is_json_body = request_data.body.is_null()
@@ -55,17 +58,25 @@ impl Handler for ValidatingHandler {
                     .get("content-type")
                     .is_some_and(|ct| crate::middleware::validation::is_json_like_str(ct));
-            if is_json_body && request_validator.is_none() && !inner.prefers_raw_json_body() {
-                let raw_bytes = request_data.raw_body.as_ref().unwrap();
-                request_data.body = serde_json::from_slice::<Value>(raw_bytes)
-                    .map_err(|e| (axum::http::StatusCode::BAD_REQUEST, format!("Invalid JSON: {}", e)))?;
+            if is_json_body
+                && request_validator.is_none()
+                && !inner.prefers_raw_json_body()
+                && let Some(raw_bytes) = request_data.raw_body.as_ref()
+            {
+                request_data.body = Arc::new(
+                    serde_json::from_slice::<Value>(raw_bytes)
+                        .map_err(|e| (axum::http::StatusCode::BAD_REQUEST, format!("Invalid JSON: {}", e)))?,
+                );
             }
             if let Some(validator) = request_validator {
-                if request_data.body.is_null() && request_data.raw_body.is_some() {
-                    let raw_bytes = request_data.raw_body.as_ref().unwrap();
-                    request_data.body = serde_json::from_slice::<Value>(raw_bytes)
-                        .map_err(|e| (axum::http::StatusCode::BAD_REQUEST, format!("Invalid JSON: {}", e)))?;
+                if request_data.body.is_null()
+                    && let Some(raw_bytes) = request_data.raw_body.as_ref()
+                {
+                    request_data.body = Arc::new(
+                        serde_json::from_slice::<Value>(raw_bytes)
+                            .map_err(|e| (axum::http::StatusCode::BAD_REQUEST, format!("Invalid JSON: {}", e)))?,
+                    );
                 }
                 if let Err(errors) = validator.validate(&request_data.body) {
@@ -86,7 +97,7 @@ impl Handler for ValidatingHandler {
                     &request_data.cookies,
                 ) {
                     Ok(validated) => {
-                        request_data.validated_params = Some(validated);
+                        request_data.validated_params = Some(Arc::new(validated));
                     }
                     Err(errors) => {
                         let problem = ProblemDetails::from_validation_error(&errors);
@@ -124,10 +135,10 @@ mod tests {
     fn create_request_data(body: Value) -> RequestData {
         RequestData {
             path_params: Arc::new(HashMap::new()),
-            query_params: json!({}),
+            query_params: Arc::new(json!({})),
             validated_params: None,
             raw_query_params: Arc::new(HashMap::new()),
-            body,
+            body: Arc::new(body),
             raw_body: None,
             headers: Arc::new(HashMap::new()),
             cookies: Arc::new(HashMap::new()),
@@ -142,10 +153,10 @@ mod tests {
     fn create_request_data_with_raw_body(raw_body: Vec<u8>) -> RequestData {
         RequestData {
             path_params: Arc::new(HashMap::new()),
-            query_params: json!({}),
+            query_params: Arc::new(json!({})),
             validated_params: None,
             raw_query_params: Arc::new(HashMap::new()),
-            body: Value::Null,
+            body: Arc::new(Value::Null),
             raw_body: Some(bytes::Bytes::from(raw_body)),
             headers: Arc::new(HashMap::new()),
             cookies: Arc::new(HashMap::new()),
@@ -261,10 +272,10 @@ mod tests {
         headers.insert("content-type".to_string(), "application/json".to_string());
         let request_data = RequestData {
             path_params: Arc::new(HashMap::new()),
-            query_params: json!({}),
+            query_params: Arc::new(json!({})),
             validated_params: None,
             raw_query_params: Arc::new(HashMap::new()),
-            body: Value::Null,
+            body: Arc::new(Value::Null),
             raw_body: Some(bytes::Bytes::from(br#"{"name":"Alice"}"#.to_vec())),
             headers: Arc::new(headers),
             cookies: Arc::new(HashMap::new()),
@@ -762,10 +773,10 @@ mod tests {
         let request_data = RequestData {
             path_params: Arc::new(HashMap::new()),
-            query_params: json!({}),
+            query_params: Arc::new(json!({})),
             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()),
@@ -900,10 +911,10 @@ mod tests {
         let request_data = RequestData {
             path_params: Arc::new(HashMap::new()),
-            query_params: json!({}),
+            query_params: Arc::new(json!({})),
             validated_params: None,
             raw_query_params: Arc::new(HashMap::new()),
-            body: Value::Null,
+            body: Arc::new(Value::Null),
             raw_body: Some(bytes::Bytes::from(br#"{"id":42}"#.to_vec())),
             headers: Arc::new(HashMap::new()),
             cookies: Arc::new(HashMap::new()),

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

@@ -29,6 +29,25 @@ pub async fn execute_with_lifecycle_hooks(
         return handler.call(req, request_data).await;
     }
+    let req = match hooks.execute_on_request(req).await {
+        Ok(HookResult::Continue(r)) => r,
+        Ok(HookResult::ShortCircuit(response)) => return Ok(response),
+        Err(e) => {
+            let error_response = axum::http::Response::builder()
+                .status(StatusCode::INTERNAL_SERVER_ERROR)
+                .body(Body::from(format!("{{\"error\":\"onRequest hook failed: {}\"}}", e)))
+                .unwrap();
+            return match hooks.execute_on_error(error_response).await {
+                Ok(resp) => Ok(resp),
+                Err(_) => Ok(axum::http::Response::builder()
+                    .status(StatusCode::INTERNAL_SERVER_ERROR)
+                    .body(Body::from("{\"error\":\"Hook execution failed\"}"))
+                    .unwrap()),
+            };
+        }
+    };
     let req = match hooks.execute_pre_validation(req).await {
         Ok(HookResult::Continue(r)) => r,
         Ok(HookResult::ShortCircuit(response)) => return Ok(response),
@@ -140,10 +159,10 @@ mod tests {
     fn empty_request_data() -> crate::handler_trait::RequestData {
         crate::handler_trait::RequestData {
             path_params: std::sync::Arc::new(HashMap::new()),
-            query_params: json!({}),
+            query_params: std::sync::Arc::new(json!({})),
             validated_params: None,
             raw_query_params: std::sync::Arc::new(HashMap::new()),
-            body: json!(null),
+            body: std::sync::Arc::new(json!(null)),
             raw_body: None,
             headers: std::sync::Arc::new(HashMap::new()),
             cookies: std::sync::Arc::new(HashMap::new()),

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

@@ -3,6 +3,7 @@
 //! This module provides the main server builder and routing infrastructure, with
 //! focused submodules for handler validation, request extraction, and lifecycle execution.
+pub mod fast_router;
 pub mod grpc_routing;
 pub mod handler;
 pub mod lifecycle_execution;
@@ -483,6 +484,7 @@ fn build_router_with_handlers_inner(
     enable_http_trace: bool,
 ) -> Result<AxumRouter, String> {
     let mut app = AxumRouter::new();
+    let mut fast_router = fast_router::FastRouter::new();
     let mut routes_by_path: HashMap<String, Vec<RouteHandlerPair>> = HashMap::new();
     for (route, handler) in routes {
@@ -500,7 +502,8 @@ fn build_router_with_handlers_inner(
             .remove(&path)
             .ok_or_else(|| format!("Missing handlers for path '{}'", path))?;
-        let mut handlers_by_method: HashMap<crate::Method, (crate::Route, Arc<dyn Handler>)> = HashMap::new();
+        type RouteEntry = (crate::Route, Arc<dyn Handler>, Option<crate::StaticResponse>);
+        let mut handlers_by_method: HashMap<crate::Method, RouteEntry> = HashMap::new();
         for (route, handler) in route_handlers {
             #[cfg(feature = "di")]
             let handler = if let Some(ref container) = di_container {
@@ -522,13 +525,16 @@ fn build_router_with_handlers_inner(
                 handler
             };
+            // Check for static_response before wrapping in ValidatingHandler,
+            // since ValidatingHandler doesn't delegate static_response().
+            let static_resp = handler.static_response();
             let validating_handler = Arc::new(handler::ValidatingHandler::new(handler, &route));
-            handlers_by_method.insert(route.method.clone(), (route, validating_handler));
+            handlers_by_method.insert(route.method.clone(), (route, validating_handler, static_resp));
         }
         let cors_config: Option<CorsConfig> = handlers_by_method
             .values()
-            .find_map(|(route, _)| route.cors.as_ref())
+            .find_map(|(route, _, _)| route.cors.as_ref())
             .cloned();
         let has_options_handler = handlers_by_method.keys().any(|m| m.as_str() == "OPTIONS");
@@ -536,8 +542,68 @@ fn build_router_with_handlers_inner(
         let mut combined_router: Option<MethodRouter> = None;
         let has_path_params = path.contains('{');
-        for (_method, (route, handler)) in handlers_by_method {
+        for (_method, (route, handler, static_resp_opt)) in handlers_by_method {
             let method = route.method.clone();
+            // Fast-path: if the handler declares a static response, bypass the
+            // entire middleware pipeline (validation, hooks, request extraction).
+            //
+            // NOTE: static routes also bypass CORS handling, content-type
+            // validation, and HTTP tracing. If CORS headers are needed they
+            // must be included in `StaticResponse.headers` explicitly.
+            //
+            // Non-parameterized paths are also inserted into the FastRouter for
+            // O(1) HashMap-based lookup as the outermost middleware. The Axum
+            // route below serves as fallback — it handles the same request if
+            // the FastRouter layer is somehow bypassed and also covers
+            // parameterized static routes that cannot go into the FastRouter.
+            if let Some(static_resp) = static_resp_opt {
+                let resp_status = static_resp.status;
+                if !has_path_params {
+                    let axum_path_for_fast = spikard_core::type_hints::strip_type_hints(&path);
+                    let http_method: axum::http::Method = route.method.as_str().parse().map_err(|_| {
+                        format!(
+                            "Invalid HTTP method '{}' for static route {}",
+                            route.method.as_str(),
+                            path
+                        )
+                    })?;
+                    fast_router.insert(http_method, &axum_path_for_fast, &static_resp);
+                }
+                // Axum fallback handler — uses the same `to_response()` as the
+                // FastRouter and `StaticResponseHandler::call`.
+                let static_handler = move || {
+                    let resp = static_resp.to_response();
+                    async move { resp }
+                };
+                let method_router: MethodRouter = match method {
+                    crate::Method::Get => axum::routing::get(static_handler),
+                    crate::Method::Post => axum::routing::post(static_handler),
+                    crate::Method::Put => axum::routing::put(static_handler),
+                    crate::Method::Patch => axum::routing::patch(static_handler),
+                    crate::Method::Delete => axum::routing::delete(static_handler),
+                    crate::Method::Head => axum::routing::head(static_handler),
+                    crate::Method::Options => axum::routing::options(static_handler),
+                    crate::Method::Trace => axum::routing::trace(static_handler),
+                };
+                combined_router = Some(match combined_router {
+                    None => method_router,
+                    Some(existing) => existing.merge(method_router),
+                });
+                tracing::info!(
+                    "Registered static route: {} {} (status {})",
+                    route.method.as_str(),
+                    path,
+                    resp_status,
+                );
+                continue;
+            }
             let method_router: MethodRouter = match method {
                 crate::Method::Options => {
                     if let Some(ref cors_cfg) = route.cors {
@@ -572,12 +638,24 @@ fn build_router_with_handlers_inner(
                 }
             };
-            let method_router = method_router.layer(axum::middleware::from_fn_with_state(
-                crate::middleware::RouteInfo {
-                    expects_json_body: route.expects_json_body,
-                },
-                crate::middleware::validate_content_type_middleware,
-            ));
+            // Only apply content-type validation middleware for methods that
+            // carry a request body. GET/DELETE/HEAD/OPTIONS/TRACE never have
+            // meaningful content-type headers, so the middleware just adds
+            // into_parts/from_parts overhead for those methods.
+            let method_router = if matches!(
+                route.method,
+                crate::Method::Post | crate::Method::Put | crate::Method::Patch
+            ) && (route.expects_json_body || route.file_params.is_some())
+            {
+                method_router.layer(axum::middleware::from_fn_with_state(
+                    crate::middleware::RouteInfo {
+                        expects_json_body: route.expects_json_body,
+                    },
+                    crate::middleware::validate_content_type_middleware,
+                ))
+            } else {
+                method_router
+            };
             combined_router = Some(match combined_router {
                 None => method_router,
@@ -616,6 +694,23 @@ fn build_router_with_handlers_inner(
         app = app.layer(TraceLayer::new_for_http());
     }
+    // Install the fast-router as the outermost middleware so that static-response
+    // routes are served without entering the Axum routing tree at all.
+    if fast_router.has_routes() {
+        let fast_router = Arc::new(fast_router);
+        app = app.layer(axum::middleware::from_fn(
+            move |req: axum::extract::Request, next: axum::middleware::Next| {
+                let fast_router = Arc::clone(&fast_router);
+                async move {
+                    if let Some(resp) = fast_router.lookup(req.method(), req.uri().path()) {
+                        return resp;
+                    }
+                    next.run(req).await
+                }
+            },
+        ));
+    }
     Ok(app)
 }
@@ -626,13 +721,13 @@ pub fn build_router_with_handlers_and_config(
     route_metadata: Vec<crate::RouteMetadata>,
 ) -> Result<AxumRouter, String> {
     #[cfg(feature = "di")]
-    if config.di_container.is_none() {
-        eprintln!("[spikard-di] build_router: di_container is None");
-    } else {
+    if let Some(di_container) = config.di_container.as_ref() {
         eprintln!(
             "[spikard-di] build_router: di_container has keys: {:?}",
-            config.di_container.as_ref().unwrap().keys()
+            di_container.keys()
         );
+    } else {
+        eprintln!("[spikard-di] build_router: di_container is None");
     }
     let hooks = config.lifecycle_hooks.clone();
@@ -698,10 +793,15 @@ pub fn build_router_with_handlers_and_config(
     #[cfg(not(feature = "di"))]
     let mut app = build_router_with_handlers_inner(routes, hooks, None, config.enable_http_trace)?;
-    app = app.layer(SetSensitiveRequestHeadersLayer::new([
-        axum::http::header::AUTHORIZATION,
-        axum::http::header::COOKIE,
-    ]));
+    // Only add the sensitive-header redaction layer when auth middleware is
+    // configured — without auth there is nothing to redact, and the layer
+    // otherwise adds per-request overhead.
+    if config.jwt_auth.is_some() || config.api_key_auth.is_some() {
+        app = app.layer(SetSensitiveRequestHeadersLayer::new([
+            axum::http::header::AUTHORIZATION,
+            axum::http::header::COOKIE,
+        ]));
+    }
     if let Some(ref compression) = config.compression {
         let mut compression_layer = CompressionLayer::new();
@@ -772,10 +872,11 @@ pub fn build_router_with_handlers_and_config(
             .layer(SetRequestIdLayer::x_request_id(MakeRequestUuid));
     }
+    // Only add the body-limit layer when a limit is explicitly configured.
+    // Omitting the layer entirely (instead of `disable()`) avoids a no-op
+    // middleware dispatch on every request.
     if let Some(max_size) = config.max_body_size {
         app = app.layer(DefaultBodyLimit::max(max_size));
-    } else {
-        app = app.layer(DefaultBodyLimit::disable());
     }
     for static_config in &config.static_files {
@@ -932,6 +1033,7 @@ impl Server {
                             .jsonrpc_method
                             .as_ref()
                             .map(|info| serde_json::to_value(info).unwrap_or(serde_json::json!(null))),
+                        static_response: None,
                     }
                 }
                 #[cfg(not(feature = "di"))]
@@ -951,6 +1053,7 @@ impl Server {
                             .jsonrpc_method
                             .as_ref()
                             .map(|info| serde_json::to_value(info).unwrap_or(serde_json::json!(null))),
+                        static_response: None,
                     }
                 }
             })
@@ -1448,6 +1551,7 @@ mod tests {
             expose_headers: None,
             max_age: Some(3600),
             allow_credentials: Some(true),
+            ..Default::default()
         };
         let route = build_test_route_with_cors("/users", "GET", "list_users", false, cors_config);
@@ -1468,6 +1572,7 @@ mod tests {
             expose_headers: None,
             max_age: Some(3600),
             allow_credentials: Some(true),
+            ..Default::default()
         };
         let get_route = build_test_route_with_cors("/users", "GET", "list_users", false, cors_config.clone());