RubyGems - spikard - Versions diffs - 0.4.0-arm64-darwin-23 - Mend

spikard 0.4.0-arm64-darwin-23

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

checksums.yaml +7 -0
data/LICENSE +1 -0
data/README.md +659 -0
data/ext/spikard_rb/Cargo.toml +17 -0
data/ext/spikard_rb/extconf.rb +10 -0
data/ext/spikard_rb/src/lib.rs +6 -0
data/lib/spikard/app.rb +405 -0
data/lib/spikard/background.rb +27 -0
data/lib/spikard/config.rb +396 -0
data/lib/spikard/converters.rb +13 -0
data/lib/spikard/handler_wrapper.rb +113 -0
data/lib/spikard/provide.rb +214 -0
data/lib/spikard/response.rb +173 -0
data/lib/spikard/schema.rb +243 -0
data/lib/spikard/sse.rb +111 -0
data/lib/spikard/streaming_response.rb +44 -0
data/lib/spikard/testing.rb +221 -0
data/lib/spikard/upload_file.rb +131 -0
data/lib/spikard/version.rb +5 -0
data/lib/spikard/websocket.rb +59 -0
data/lib/spikard.rb +43 -0
data/sig/spikard.rbs +366 -0
data/vendor/bundle/ruby/3.4.0/gems/diff-lcs-1.6.2/mise.toml +5 -0
data/vendor/bundle/ruby/3.4.0/gems/rake-compiler-dock-1.10.0/build/buildkitd.toml +2 -0
data/vendor/crates/spikard-bindings-shared/Cargo.toml +63 -0
data/vendor/crates/spikard-bindings-shared/examples/config_extraction.rs +139 -0
data/vendor/crates/spikard-bindings-shared/src/config_extractor.rs +561 -0
data/vendor/crates/spikard-bindings-shared/src/conversion_traits.rs +194 -0
data/vendor/crates/spikard-bindings-shared/src/di_traits.rs +246 -0
data/vendor/crates/spikard-bindings-shared/src/error_response.rs +403 -0
data/vendor/crates/spikard-bindings-shared/src/handler_base.rs +274 -0
data/vendor/crates/spikard-bindings-shared/src/lib.rs +25 -0
data/vendor/crates/spikard-bindings-shared/src/lifecycle_base.rs +298 -0
data/vendor/crates/spikard-bindings-shared/src/lifecycle_executor.rs +637 -0
data/vendor/crates/spikard-bindings-shared/src/response_builder.rs +309 -0
data/vendor/crates/spikard-bindings-shared/src/test_client_base.rs +248 -0
data/vendor/crates/spikard-bindings-shared/src/validation_helpers.rs +355 -0
data/vendor/crates/spikard-bindings-shared/tests/comprehensive_coverage.rs +502 -0
data/vendor/crates/spikard-bindings-shared/tests/error_response_edge_cases.rs +389 -0
data/vendor/crates/spikard-bindings-shared/tests/handler_base_integration.rs +413 -0
data/vendor/crates/spikard-core/Cargo.toml +40 -0
data/vendor/crates/spikard-core/src/bindings/mod.rs +3 -0
data/vendor/crates/spikard-core/src/bindings/response.rs +133 -0
data/vendor/crates/spikard-core/src/debug.rs +63 -0
data/vendor/crates/spikard-core/src/di/container.rs +726 -0
data/vendor/crates/spikard-core/src/di/dependency.rs +273 -0
data/vendor/crates/spikard-core/src/di/error.rs +118 -0
data/vendor/crates/spikard-core/src/di/factory.rs +538 -0
data/vendor/crates/spikard-core/src/di/graph.rs +545 -0
data/vendor/crates/spikard-core/src/di/mod.rs +192 -0
data/vendor/crates/spikard-core/src/di/resolved.rs +411 -0
data/vendor/crates/spikard-core/src/di/value.rs +283 -0
data/vendor/crates/spikard-core/src/errors.rs +39 -0
data/vendor/crates/spikard-core/src/http.rs +153 -0
data/vendor/crates/spikard-core/src/lib.rs +29 -0
data/vendor/crates/spikard-core/src/lifecycle.rs +422 -0
data/vendor/crates/spikard-core/src/metadata.rs +397 -0
data/vendor/crates/spikard-core/src/parameters.rs +723 -0
data/vendor/crates/spikard-core/src/problem.rs +310 -0
data/vendor/crates/spikard-core/src/request_data.rs +189 -0
data/vendor/crates/spikard-core/src/router.rs +249 -0
data/vendor/crates/spikard-core/src/schema_registry.rs +183 -0
data/vendor/crates/spikard-core/src/type_hints.rs +304 -0
data/vendor/crates/spikard-core/src/validation/error_mapper.rs +689 -0
data/vendor/crates/spikard-core/src/validation/mod.rs +459 -0
data/vendor/crates/spikard-http/Cargo.toml +58 -0
data/vendor/crates/spikard-http/examples/sse-notifications.rs +147 -0
data/vendor/crates/spikard-http/examples/websocket-chat.rs +91 -0
data/vendor/crates/spikard-http/src/auth.rs +247 -0
data/vendor/crates/spikard-http/src/background.rs +1562 -0
data/vendor/crates/spikard-http/src/bindings/mod.rs +3 -0
data/vendor/crates/spikard-http/src/bindings/response.rs +1 -0
data/vendor/crates/spikard-http/src/body_metadata.rs +8 -0
data/vendor/crates/spikard-http/src/cors.rs +490 -0
data/vendor/crates/spikard-http/src/debug.rs +63 -0
data/vendor/crates/spikard-http/src/di_handler.rs +1878 -0
data/vendor/crates/spikard-http/src/handler_response.rs +532 -0
data/vendor/crates/spikard-http/src/handler_trait.rs +861 -0
data/vendor/crates/spikard-http/src/handler_trait_tests.rs +284 -0
data/vendor/crates/spikard-http/src/lib.rs +524 -0
data/vendor/crates/spikard-http/src/lifecycle/adapter.rs +149 -0
data/vendor/crates/spikard-http/src/lifecycle.rs +428 -0
data/vendor/crates/spikard-http/src/middleware/mod.rs +285 -0
data/vendor/crates/spikard-http/src/middleware/multipart.rs +930 -0
data/vendor/crates/spikard-http/src/middleware/urlencoded.rs +541 -0
data/vendor/crates/spikard-http/src/middleware/validation.rs +287 -0
data/vendor/crates/spikard-http/src/openapi/mod.rs +309 -0
data/vendor/crates/spikard-http/src/openapi/parameter_extraction.rs +535 -0
data/vendor/crates/spikard-http/src/openapi/schema_conversion.rs +867 -0
data/vendor/crates/spikard-http/src/openapi/spec_generation.rs +678 -0
data/vendor/crates/spikard-http/src/query_parser.rs +369 -0
data/vendor/crates/spikard-http/src/response.rs +399 -0
data/vendor/crates/spikard-http/src/server/handler.rs +1557 -0
data/vendor/crates/spikard-http/src/server/lifecycle_execution.rs +98 -0
data/vendor/crates/spikard-http/src/server/mod.rs +806 -0
data/vendor/crates/spikard-http/src/server/request_extraction.rs +630 -0
data/vendor/crates/spikard-http/src/server/routing_factory.rs +497 -0
data/vendor/crates/spikard-http/src/sse.rs +961 -0
data/vendor/crates/spikard-http/src/testing/form.rs +14 -0
data/vendor/crates/spikard-http/src/testing/multipart.rs +60 -0
data/vendor/crates/spikard-http/src/testing/test_client.rs +285 -0
data/vendor/crates/spikard-http/src/testing.rs +377 -0
data/vendor/crates/spikard-http/src/websocket.rs +831 -0
data/vendor/crates/spikard-http/tests/background_behavior.rs +918 -0
data/vendor/crates/spikard-http/tests/common/handlers.rs +308 -0
data/vendor/crates/spikard-http/tests/common/mod.rs +21 -0
data/vendor/crates/spikard-http/tests/di_integration.rs +202 -0
data/vendor/crates/spikard-http/tests/doc_snippets.rs +4 -0
data/vendor/crates/spikard-http/tests/lifecycle_execution.rs +1135 -0
data/vendor/crates/spikard-http/tests/multipart_behavior.rs +688 -0
data/vendor/crates/spikard-http/tests/server_config_builder.rs +324 -0
data/vendor/crates/spikard-http/tests/sse_behavior.rs +728 -0
data/vendor/crates/spikard-http/tests/websocket_behavior.rs +724 -0
data/vendor/crates/spikard-rb/Cargo.toml +43 -0
data/vendor/crates/spikard-rb/build.rs +199 -0
data/vendor/crates/spikard-rb/src/background.rs +63 -0
data/vendor/crates/spikard-rb/src/config/mod.rs +5 -0
data/vendor/crates/spikard-rb/src/config/server_config.rs +283 -0
data/vendor/crates/spikard-rb/src/conversion.rs +459 -0
data/vendor/crates/spikard-rb/src/di/builder.rs +105 -0
data/vendor/crates/spikard-rb/src/di/mod.rs +413 -0
data/vendor/crates/spikard-rb/src/handler.rs +612 -0
data/vendor/crates/spikard-rb/src/integration/mod.rs +3 -0
data/vendor/crates/spikard-rb/src/lib.rs +1857 -0
data/vendor/crates/spikard-rb/src/lifecycle.rs +275 -0
data/vendor/crates/spikard-rb/src/metadata/mod.rs +5 -0
data/vendor/crates/spikard-rb/src/metadata/route_extraction.rs +427 -0
data/vendor/crates/spikard-rb/src/runtime/mod.rs +5 -0
data/vendor/crates/spikard-rb/src/runtime/server_runner.rs +326 -0
data/vendor/crates/spikard-rb/src/server.rs +283 -0
data/vendor/crates/spikard-rb/src/sse.rs +231 -0
data/vendor/crates/spikard-rb/src/testing/client.rs +404 -0
data/vendor/crates/spikard-rb/src/testing/mod.rs +7 -0
data/vendor/crates/spikard-rb/src/testing/sse.rs +143 -0
data/vendor/crates/spikard-rb/src/testing/websocket.rs +221 -0
data/vendor/crates/spikard-rb/src/websocket.rs +233 -0
data/vendor/crates/spikard-rb/tests/magnus_ffi_tests.rs +14 -0
metadata +213 -0

data/vendor/crates/spikard-bindings-shared/tests/handler_base_integration.rs ADDED Viewed

@@ -0,0 +1,413 @@
+//! Integration tests for handler_base module
+//!
+//! These tests cover the validation paths and error handling that aren't
+//! covered by unit tests in the module itself.
+use axum::body::Body;
+use axum::http::Request;
+use serde_json::json;
+use spikard_bindings_shared::handler_base::{HandlerError, HandlerExecutor, LanguageHandler};
+use spikard_core::parameters::ParameterValidator;
+use spikard_core::validation::{SchemaValidator, ValidationError, ValidationErrorDetail};
+use spikard_http::handler_trait::{Handler, RequestData};
+use std::collections::HashMap;
+use std::future::Future;
+use std::pin::Pin;
+use std::sync::Arc;
+// Mock handler that returns controlled responses
+struct MockHandler {
+    should_fail_prepare: bool,
+    should_fail_invoke: bool,
+    should_fail_interpret: bool,
+}
+impl LanguageHandler for MockHandler {
+    type Input = String;
+    type Output = String;
+    fn prepare_request(&self, _data: &RequestData) -> Result<Self::Input, HandlerError> {
+        if self.should_fail_prepare {
+            Err(HandlerError::Internal("Prepare failed".to_string()))
+        } else {
+            Ok("prepared".to_string())
+        }
+    }
+    fn invoke_handler(
+        &self,
+        input: Self::Input,
+    ) -> Pin<Box<dyn Future<Output = Result<Self::Output, HandlerError>> + Send + '_>> {
+        let should_fail = self.should_fail_invoke;
+        Box::pin(async move {
+            if should_fail {
+                Err(HandlerError::Execution("Handler failed".to_string()))
+            } else {
+                Ok(format!("output:{}", input))
+            }
+        })
+    }
+    fn interpret_response(&self, output: Self::Output) -> Result<axum::http::Response<Body>, HandlerError> {
+        if self.should_fail_interpret {
+            Err(HandlerError::ResponseConversion("Interpret failed".to_string()))
+        } else {
+            Ok(axum::http::Response::builder()
+                .status(200)
+                .body(Body::from(output))
+                .unwrap())
+        }
+    }
+}
+#[tokio::test]
+async fn test_handler_executor_with_validation_error() {
+    // Create a validator that will reject the request
+    let schema = json!({
+        "type": "object",
+        "properties": {
+            "username": {"type": "string"},
+            "age": {"type": "number"}
+        },
+        "required": ["username", "age"]
+    });
+    let validator = Arc::new(SchemaValidator::new(schema).unwrap());
+    let handler = Arc::new(MockHandler {
+        should_fail_prepare: false,
+        should_fail_invoke: false,
+        should_fail_interpret: false,
+    });
+    let executor = HandlerExecutor::new(handler, Some(validator), None);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = RequestData {
+        path_params: Arc::new(HashMap::new()),
+        query_params: json!({}),
+        raw_query_params: Arc::new(HashMap::new()),
+        // Missing required field 'age'
+        body: json!({"username": "john"}),
+        raw_body: None,
+        headers: Arc::new(HashMap::new()),
+        cookies: Arc::new(HashMap::new()),
+        method: "POST".to_string(),
+        path: "/test".to_string(),
+        dependencies: None,
+    };
+    let result = executor.call(request, request_data).await;
+    assert!(result.is_err());
+}
+#[tokio::test]
+async fn test_handler_executor_with_parameter_validation() {
+    // Create a parameter validator with schema
+    let param_schema = json!({
+        "type": "object",
+        "properties": {
+            "page": {"type": "number", "source": "query"}
+        },
+        "required": ["page"]
+    });
+    let param_validator = ParameterValidator::new(param_schema).unwrap();
+    let handler = Arc::new(MockHandler {
+        should_fail_prepare: false,
+        should_fail_invoke: false,
+        should_fail_interpret: false,
+    });
+    let executor = HandlerExecutor::new(handler, None, Some(Arc::new(param_validator)));
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = RequestData {
+        path_params: Arc::new(HashMap::new()),
+        query_params: json!({}),
+        raw_query_params: Arc::new(HashMap::new()),
+        body: json!({}),
+        raw_body: None,
+        headers: Arc::new(HashMap::new()),
+        cookies: Arc::new(HashMap::new()),
+        method: "GET".to_string(),
+        path: "/test".to_string(),
+        dependencies: None,
+    };
+    // Missing required query param should fail validation
+    let result = executor.call(request, request_data).await;
+    assert!(result.is_err());
+}
+#[tokio::test]
+async fn test_handler_executor_with_valid_parameters() {
+    // Create a parameter validator with optional param
+    let param_schema = json!({
+        "type": "object",
+        "properties": {
+            "page": {"type": "number", "source": "query"}
+        }
+    });
+    let param_validator = ParameterValidator::new(param_schema).unwrap();
+    let handler = Arc::new(MockHandler {
+        should_fail_prepare: false,
+        should_fail_invoke: false,
+        should_fail_interpret: false,
+    });
+    let executor = HandlerExecutor::new(handler, None, Some(Arc::new(param_validator)));
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = RequestData {
+        path_params: Arc::new(HashMap::new()),
+        query_params: json!({"page": 1}),
+        raw_query_params: Arc::new(HashMap::new()),
+        body: json!({}),
+        raw_body: None,
+        headers: Arc::new(HashMap::new()),
+        cookies: Arc::new(HashMap::new()),
+        method: "GET".to_string(),
+        path: "/test".to_string(),
+        dependencies: None,
+    };
+    let result = executor.call(request, request_data).await;
+    assert!(result.is_ok());
+}
+#[tokio::test]
+async fn test_handler_executor_prepare_failure() {
+    let handler = Arc::new(MockHandler {
+        should_fail_prepare: true,
+        should_fail_invoke: false,
+        should_fail_interpret: false,
+    });
+    let executor = HandlerExecutor::with_handler(handler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = RequestData {
+        path_params: Arc::new(HashMap::new()),
+        query_params: json!({}),
+        raw_query_params: Arc::new(HashMap::new()),
+        body: json!({}),
+        raw_body: None,
+        headers: Arc::new(HashMap::new()),
+        cookies: Arc::new(HashMap::new()),
+        method: "GET".to_string(),
+        path: "/test".to_string(),
+        dependencies: None,
+    };
+    let result = executor.call(request, request_data).await;
+    assert!(result.is_err());
+}
+#[tokio::test]
+async fn test_handler_executor_invoke_failure() {
+    let handler = Arc::new(MockHandler {
+        should_fail_prepare: false,
+        should_fail_invoke: true,
+        should_fail_interpret: false,
+    });
+    let executor = HandlerExecutor::with_handler(handler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = RequestData {
+        path_params: Arc::new(HashMap::new()),
+        query_params: json!({}),
+        raw_query_params: Arc::new(HashMap::new()),
+        body: json!({}),
+        raw_body: None,
+        headers: Arc::new(HashMap::new()),
+        cookies: Arc::new(HashMap::new()),
+        method: "GET".to_string(),
+        path: "/test".to_string(),
+        dependencies: None,
+    };
+    let result = executor.call(request, request_data).await;
+    assert!(result.is_err());
+}
+#[tokio::test]
+async fn test_handler_executor_interpret_failure() {
+    let handler = Arc::new(MockHandler {
+        should_fail_prepare: false,
+        should_fail_invoke: false,
+        should_fail_interpret: true,
+    });
+    let executor = HandlerExecutor::with_handler(handler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = RequestData {
+        path_params: Arc::new(HashMap::new()),
+        query_params: json!({}),
+        raw_query_params: Arc::new(HashMap::new()),
+        body: json!({}),
+        raw_body: None,
+        headers: Arc::new(HashMap::new()),
+        cookies: Arc::new(HashMap::new()),
+        method: "GET".to_string(),
+        path: "/test".to_string(),
+        dependencies: None,
+    };
+    let result = executor.call(request, request_data).await;
+    assert!(result.is_err());
+}
+#[tokio::test]
+async fn test_handler_executor_with_both_validators() {
+    // Create both request and parameter validators
+    let schema = json!({
+        "type": "object",
+        "properties": {
+            "name": {"type": "string"}
+        },
+        "required": ["name"]
+    });
+    let request_validator = Arc::new(SchemaValidator::new(schema).unwrap());
+    let param_schema = json!({
+        "type": "object",
+        "properties": {
+            "x-api-key": {"type": "string", "source": "header"}
+        },
+        "required": ["x-api-key"]
+    });
+    let param_validator = ParameterValidator::new(param_schema).unwrap();
+    let handler = Arc::new(MockHandler {
+        should_fail_prepare: false,
+        should_fail_invoke: false,
+        should_fail_interpret: false,
+    });
+    let executor = HandlerExecutor::new(handler, Some(request_validator), Some(Arc::new(param_validator)));
+    let request = Request::builder().body(Body::empty()).unwrap();
+    // Valid request with all requirements
+    let mut headers = HashMap::new();
+    headers.insert("x-api-key".to_string(), "test-key".to_string());
+    let request_data = RequestData {
+        path_params: Arc::new(HashMap::new()),
+        query_params: json!({}),
+        raw_query_params: Arc::new(HashMap::new()),
+        body: json!({"name": "test"}),
+        raw_body: None,
+        headers: Arc::new(headers),
+        cookies: Arc::new(HashMap::new()),
+        method: "POST".to_string(),
+        path: "/test".to_string(),
+        dependencies: None,
+    };
+    let result = executor.call(request, request_data).await;
+    assert!(result.is_ok());
+}
+#[tokio::test]
+async fn test_handler_executor_parameter_validation_failure() {
+    let param_schema = json!({
+        "type": "object",
+        "properties": {
+            "authorization": {"type": "string", "source": "header"}
+        },
+        "required": ["authorization"]
+    });
+    let param_validator = ParameterValidator::new(param_schema).unwrap();
+    let handler = Arc::new(MockHandler {
+        should_fail_prepare: false,
+        should_fail_invoke: false,
+        should_fail_interpret: false,
+    });
+    let executor = HandlerExecutor::with_handler(handler).with_parameter_validator(Arc::new(param_validator));
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = RequestData {
+        path_params: Arc::new(HashMap::new()),
+        query_params: json!({}),
+        raw_query_params: Arc::new(HashMap::new()),
+        body: json!({}),
+        raw_body: None,
+        headers: Arc::new(HashMap::new()), // Missing required header
+        cookies: Arc::new(HashMap::new()),
+        method: "GET".to_string(),
+        path: "/test".to_string(),
+        dependencies: None,
+    };
+    let result = executor.call(request, request_data).await;
+    assert!(result.is_err());
+}
+#[test]
+fn test_handler_error_from_validation_error() {
+    let validation_error = ValidationError {
+        errors: vec![ValidationErrorDetail {
+            error_type: "missing".to_string(),
+            loc: vec!["body".to_string(), "field".to_string()],
+            msg: "Field required".to_string(),
+            input: json!(null),
+            ctx: None,
+        }],
+    };
+    let handler_error: HandlerError = validation_error.into();
+    assert!(matches!(handler_error, HandlerError::Validation(_)));
+}
+#[tokio::test]
+async fn test_handler_executor_builder_pattern() {
+    let schema = json!({
+        "type": "object",
+        "properties": {
+            "email": {"type": "string", "format": "email"}
+        }
+    });
+    let request_validator = Arc::new(SchemaValidator::new(schema).unwrap());
+    let param_schema = json!({
+        "type": "object",
+        "properties": {
+            "session_id": {"type": "string", "source": "cookie"}
+        }
+    });
+    let param_validator = ParameterValidator::new(param_schema).unwrap();
+    let handler = Arc::new(MockHandler {
+        should_fail_prepare: false,
+        should_fail_invoke: false,
+        should_fail_interpret: false,
+    });
+    // Test builder pattern chaining
+    let executor = HandlerExecutor::with_handler(handler)
+        .with_request_validator(request_validator)
+        .with_parameter_validator(Arc::new(param_validator));
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = RequestData {
+        path_params: Arc::new(HashMap::new()),
+        query_params: json!({}),
+        raw_query_params: Arc::new(HashMap::new()),
+        body: json!({"email": "test@example.com"}),
+        raw_body: None,
+        headers: Arc::new(HashMap::new()),
+        cookies: Arc::new(HashMap::new()),
+        method: "POST".to_string(),
+        path: "/test".to_string(),
+        dependencies: None,
+    };
+    let result = executor.call(request, request_data).await;
+    assert!(result.is_ok());
+}

data/vendor/crates/spikard-core/Cargo.toml ADDED Viewed

@@ -0,0 +1,40 @@
+[package]
+name = "spikard-core"
+version = "0.4.0"
+edition = "2024"
+authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
+license = "MIT"
+repository = "https://github.com/Goldziher/spikard"
+homepage = "https://github.com/Goldziher/spikard"
+description = "Shared transport-agnostic primitives for Spikard runtimes"
+keywords = ["http", "web", "framework", "validation", "middleware"]
+categories = ["web-programming::http-server", "web-programming", "development-tools"]
+documentation = "https://docs.rs/spikard-core"
+readme = "README.md"
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+tracing = "0.1"
+anyhow = "1.0"
+jsonschema = { version = "0.37", default-features = false }
+regex = "1"
+flate2 = { version = "=1.1.5", default-features = false, features = ["rust_backend"] }
+brotli = "8.0"
+http = "1.4"
+base64 = "0.22"
+serde_qs = "0.15"
+url = "2.5"
+jiff = "0.2"
+uuid = "1.19"
+indexmap = "2.12"
+tokio = { version = "1", features = ["full"], optional = true }
+bytes = { version = "1.11", optional = true }
+thiserror = { version = "2.0", optional = true }
+[features]
+default = []
+di = ["dep:tokio", "dep:bytes", "dep:thiserror"]
+[dev-dependencies]
+tokio-test = "0.4"

data/vendor/crates/spikard-core/src/bindings/mod.rs ADDED Viewed

@@ -0,0 +1,3 @@
+pub mod response;
+pub use response::{RawResponse, StaticAsset};

data/vendor/crates/spikard-core/src/bindings/response.rs ADDED Viewed

@@ -0,0 +1,133 @@
+use crate::CompressionConfig;
+use brotli::CompressorWriter;
+use flate2::Compression;
+use flate2::write::GzEncoder;
+use std::collections::HashMap;
+use std::io::Write;
+/// Minimal response container shared by bindings.
+#[derive(Clone, Debug)]
+pub struct RawResponse {
+    pub status: u16,
+    pub headers: HashMap<String, String>,
+    pub body: Vec<u8>,
+}
+impl RawResponse {
+    /// Construct a new response.
+    pub fn new(status: u16, headers: HashMap<String, String>, body: Vec<u8>) -> Self {
+        Self { status, headers, body }
+    }
+    /// Apply compression filters if the response qualifies.
+    pub fn apply_compression(&mut self, request_headers: &HashMap<String, String>, compression: &CompressionConfig) {
+        if self.body.is_empty() || self.status == 206 {
+            return;
+        }
+        if self
+            .headers
+            .keys()
+            .any(|key| key.eq_ignore_ascii_case("content-encoding"))
+        {
+            return;
+        }
+        if self.body.len() < compression.min_size {
+            return;
+        }
+        let accept_encoding = header_value(request_headers, "Accept-Encoding").map(|value| value.to_ascii_lowercase());
+        let accepts_brotli = accept_encoding
+            .as_ref()
+            .map(|value| value.contains("br"))
+            .unwrap_or(false);
+        if compression.brotli && accepts_brotli && self.try_compress_brotli(compression) {
+            return;
+        }
+        let accepts_gzip = accept_encoding
+            .as_ref()
+            .map(|value| value.contains("gzip"))
+            .unwrap_or(false);
+        if compression.gzip && accepts_gzip {
+            self.try_compress_gzip(compression);
+        }
+    }
+    fn try_compress_brotli(&mut self, compression: &CompressionConfig) -> bool {
+        let quality = compression.quality.min(11);
+        let mut writer = CompressorWriter::new(Vec::new(), 4096, quality, 22);
+        if writer.write_all(&self.body).is_err() || writer.flush().is_err() {
+            return false;
+        }
+        let compressed = writer.into_inner();
+        if compressed.is_empty() {
+            return false;
+        }
+        self.finalize_encoded_body("br", compressed);
+        true
+    }
+    fn try_compress_gzip(&mut self, compression: &CompressionConfig) -> bool {
+        let mut encoder = GzEncoder::new(Vec::new(), Compression::new(compression.quality));
+        if encoder.write_all(&self.body).is_err() {
+            return false;
+        }
+        let compressed = encoder.finish().unwrap_or_else(|_| Vec::new());
+        if compressed.is_empty() {
+            return false;
+        }
+        self.finalize_encoded_body("gzip", compressed);
+        true
+    }
+    fn finalize_encoded_body(&mut self, encoding: &str, compressed: Vec<u8>) {
+        self.body = compressed;
+        self.headers
+            .insert("content-encoding".to_string(), encoding.to_string());
+        self.headers.insert("vary".to_string(), "Accept-Encoding".to_string());
+        self.headers
+            .insert("content-length".to_string(), self.body.len().to_string());
+    }
+}
+fn header_value<'a>(headers: &'a HashMap<String, String>, name: &str) -> Option<&'a str> {
+    headers.iter().find_map(|(key, value)| {
+        if key.eq_ignore_ascii_case(name) {
+            Some(value.as_str())
+        } else {
+            None
+        }
+    })
+}
+/// Pre-rendered static asset produced by the CLI bundler.
+#[derive(Clone, Debug)]
+pub struct StaticAsset {
+    pub route: String,
+    pub headers: HashMap<String, String>,
+    pub body: Vec<u8>,
+}
+impl StaticAsset {
+    /// Build a response snapshot if the incoming request targets this asset.
+    pub fn serve(&self, method: &str, normalized_path: &str) -> Option<RawResponse> {
+        if !method.eq_ignore_ascii_case("GET") && !method.eq_ignore_ascii_case("HEAD") {
+            return None;
+        }
+        if self.route != normalized_path {
+            return None;
+        }
+        let mut headers = self.headers.clone();
+        headers
+            .entry("content-length".to_string())
+            .or_insert_with(|| self.body.len().to_string());
+        let body = if method.eq_ignore_ascii_case("HEAD") {
+            Vec::new()
+        } else {
+            self.body.clone()
+        };
+        Some(RawResponse::new(200, headers, body))
+    }
+}

data/vendor/crates/spikard-core/src/debug.rs ADDED Viewed

@@ -0,0 +1,63 @@
+//! Debug logging utilities for spikard-http
+//!
+//! This module provides debug logging that can be enabled via:
+//! - Building in debug mode (cfg(debug_assertions))
+//! - Setting SPIKARD_DEBUG=1 environment variable
+use std::sync::atomic::{AtomicBool, Ordering};
+static DEBUG_ENABLED: AtomicBool = AtomicBool::new(false);
+/// Initialize debug logging based on environment and build mode
+pub fn init() {
+    let enabled = cfg!(debug_assertions) || std::env::var("SPIKARD_DEBUG").is_ok() || std::env::var("DEBUG").is_ok();
+    eprintln!(
+        "[spikard-http::debug] init() called, cfg!(debug_assertions)={}, DEBUG={}, enabled={}",
+        cfg!(debug_assertions),
+        std::env::var("DEBUG").is_ok(),
+        enabled
+    );
+    DEBUG_ENABLED.store(enabled, Ordering::Relaxed);
+    if enabled {
+        eprintln!("[spikard-http] Debug logging enabled");
+    }
+}
+/// Check if debug logging is enabled
+#[inline]
+pub fn is_enabled() -> bool {
+    DEBUG_ENABLED.load(Ordering::Relaxed)
+}
+/// Log a debug message if debugging is enabled
+#[macro_export]
+macro_rules! debug_log {
+    ($($arg:tt)*) => {
+        if $crate::debug::is_enabled() {
+            eprintln!("[spikard-http] {}", format!($($arg)*));
+        }
+    };
+}
+/// Log a debug message with a specific module/component name
+#[macro_export]
+macro_rules! debug_log_module {
+    ($module:expr, $($arg:tt)*) => {
+        if $crate::debug::is_enabled() {
+            eprintln!("[spikard-http::{}] {}", $module, format!($($arg)*));
+        }
+    };
+}
+/// Log a debug value with pretty-printing
+#[macro_export]
+macro_rules! debug_log_value {
+    ($name:expr, $value:expr) => {
+        if $crate::debug::is_enabled() {
+            eprintln!("[spikard-http] {} = {:?}", $name, $value);
+        }
+    };
+}