spikard 0.4.0-x86_64-linux

data/vendor/crates/spikard-core/src/validation/mod.rs

@@ -0,0 +1,459 @@
+//! Request/response validation using JSON Schema
+
+pub mod error_mapper;
+
+use crate::debug_log_module;
+use jsonschema::Validator;
+use serde_json::Value;
+use std::sync::Arc;
+
+use self::error_mapper::{ErrorCondition, ErrorMapper};
+
+/// Schema validator that compiles and validates JSON Schema
+#[derive(Clone)]
+pub struct SchemaValidator {
+    compiled: Arc<Validator>,
+    schema: Value,
+}
+
+impl SchemaValidator {
+    /// Create a new validator from a JSON Schema
+    pub fn new(schema: Value) -> Result<Self, String> {
+        let compiled = jsonschema::options()
+            .with_draft(jsonschema::Draft::Draft202012)
+            .should_validate_formats(true)
+            .with_pattern_options(jsonschema::PatternOptions::regex())
+            .build(&schema)
+            .map_err(|e| {
+                anyhow::anyhow!("Invalid JSON Schema")
+                    .context(format!("Schema compilation failed: {}", e))
+                    .to_string()
+            })?;
+
+        Ok(Self {
+            compiled: Arc::new(compiled),
+            schema,
+        })
+    }
+
+    /// Get the underlying JSON Schema
+    pub fn schema(&self) -> &Value {
+        &self.schema
+    }
+
+    /// Pre-process data to convert file objects to strings for format: "binary" validation
+    ///
+    /// Files uploaded via multipart are converted to objects like:
+    /// {"filename": "...", "size": N, "content": "...", "content_type": "..."}
+    ///
+    /// But schemas define them as: {"type": "string", "format": "binary"}
+    ///
+    /// This method recursively processes the data and converts file objects to their content strings
+    /// so that validation passes, while preserving the original structure for handlers to use.
+    fn preprocess_binary_fields(&self, data: &Value) -> Value {
+        self.preprocess_value_with_schema(data, &self.schema)
+    }
+
+    #[allow(clippy::only_used_in_recursion)]
+    fn preprocess_value_with_schema(&self, data: &Value, schema: &Value) -> Value {
+        if let Some(schema_obj) = schema.as_object() {
+            let is_string_type = schema_obj.get("type").and_then(|t| t.as_str()) == Some("string");
+            let is_binary_format = schema_obj.get("format").and_then(|f| f.as_str()) == Some("binary");
+
+            #[allow(clippy::collapsible_if)]
+            if is_string_type && is_binary_format {
+                if let Some(data_obj) = data.as_object() {
+                    if data_obj.contains_key("filename")
+                        && data_obj.contains_key("content")
+                        && data_obj.contains_key("size")
+                        && data_obj.contains_key("content_type")
+                    {
+                        return data_obj.get("content").unwrap_or(&Value::Null).clone();
+                    }
+                }
+                return data.clone();
+            }
+
+            #[allow(clippy::collapsible_if)]
+            if schema_obj.get("type").and_then(|t| t.as_str()) == Some("array") {
+                if let Some(items_schema) = schema_obj.get("items") {
+                    if let Some(data_array) = data.as_array() {
+                        let processed_array: Vec<Value> = data_array
+                            .iter()
+                            .map(|item| self.preprocess_value_with_schema(item, items_schema))
+                            .collect();
+                        return Value::Array(processed_array);
+                    }
+                }
+            }
+
+            #[allow(clippy::collapsible_if)]
+            if schema_obj.get("type").and_then(|t| t.as_str()) == Some("object") {
+                if let Some(properties) = schema_obj.get("properties").and_then(|p| p.as_object()) {
+                    if let Some(data_obj) = data.as_object() {
+                        let mut processed_obj = serde_json::Map::new();
+                        for (key, value) in data_obj {
+                            if let Some(prop_schema) = properties.get(key) {
+                                processed_obj
+                                    .insert(key.clone(), self.preprocess_value_with_schema(value, prop_schema));
+                            } else {
+                                processed_obj.insert(key.clone(), value.clone());
+                            }
+                        }
+                        return Value::Object(processed_obj);
+                    }
+                }
+            }
+        }
+
+        data.clone()
+    }
+
+    /// Validate JSON data against the schema
+    pub fn validate(&self, data: &Value) -> Result<(), ValidationError> {
+        let processed_data = self.preprocess_binary_fields(data);
+
+        let validation_errors: Vec<_> = self.compiled.iter_errors(&processed_data).collect();
+
+        if validation_errors.is_empty() {
+            return Ok(());
+        }
+
+        let errors: Vec<ValidationErrorDetail> = validation_errors
+            .into_iter()
+            .map(|err| {
+                let instance_path = err.instance_path().to_string();
+                let schema_path_str = err.schema_path().as_str();
+                let error_msg = err.to_string();
+
+                let param_name = if schema_path_str.ends_with("/required") {
+                    let field_name = if let Some(start) = error_msg.find('"') {
+                        if let Some(end) = error_msg[start + 1..].find('"') {
+                            error_msg[start + 1..start + 1 + end].to_string()
+                        } else {
+                            "".to_string()
+                        }
+                    } else {
+                        "".to_string()
+                    };
+
+                    if !instance_path.is_empty() && instance_path.starts_with('/') && instance_path.len() > 1 {
+                        let base_path = &instance_path[1..];
+                        if !field_name.is_empty() {
+                            format!("{}/{}", base_path, field_name)
+                        } else {
+                            base_path.to_string()
+                        }
+                    } else if !field_name.is_empty() {
+                        field_name
+                    } else {
+                        "body".to_string()
+                    }
+                } else if schema_path_str.contains("/additionalProperties") {
+                    if let Some(start) = error_msg.find('(') {
+                        if let Some(quote_start) = error_msg[start..].find('\'') {
+                            let abs_start = start + quote_start + 1;
+                            if let Some(quote_end) = error_msg[abs_start..].find('\'') {
+                                let property_name = error_msg[abs_start..abs_start + quote_end].to_string();
+                                if !instance_path.is_empty()
+                                    && instance_path.starts_with('/')
+                                    && instance_path.len() > 1
+                                {
+                                    format!("{}/{}", &instance_path[1..], property_name)
+                                } else {
+                                    property_name
+                                }
+                            } else {
+                                instance_path[1..].to_string()
+                            }
+                        } else {
+                            instance_path[1..].to_string()
+                        }
+                    } else if instance_path.starts_with('/') && instance_path.len() > 1 {
+                        instance_path[1..].to_string()
+                    } else {
+                        "body".to_string()
+                    }
+                } else if instance_path.starts_with('/') && instance_path.len() > 1 {
+                    instance_path[1..].to_string()
+                } else if instance_path.is_empty() {
+                    "body".to_string()
+                } else {
+                    instance_path
+                };
+
+                let loc_parts: Vec<String> = if param_name.contains('/') {
+                    let mut parts = vec!["body".to_string()];
+                    parts.extend(param_name.split('/').map(|s| s.to_string()));
+                    parts
+                } else if param_name == "body" {
+                    vec!["body".to_string()]
+                } else {
+                    vec!["body".to_string(), param_name.clone()]
+                };
+
+                let input_value = if schema_path_str == "/required" {
+                    data.clone()
+                } else {
+                    err.instance().clone().into_owned()
+                };
+
+                let schema_prop_path = if param_name.contains('/') {
+                    format!("/properties/{}", param_name.replace('/', "/properties/"))
+                } else {
+                    format!("/properties/{}", param_name)
+                };
+
+                // Use table-driven error mapping
+                let mut error_condition = ErrorCondition::from_schema_error(schema_path_str, &error_msg);
+
+                // Enrich condition with extracted values from schema
+                error_condition = match error_condition {
+                    ErrorCondition::TypeMismatch { .. } => {
+                        let expected_type = self
+                            .schema
+                            .pointer(&format!("{}/type", schema_prop_path))
+                            .and_then(|v| v.as_str())
+                            .unwrap_or("unknown")
+                            .to_string();
+                        ErrorCondition::TypeMismatch { expected_type }
+                    }
+                    ErrorCondition::AdditionalProperties { .. } => {
+                        let unexpected_field = if param_name.contains('/') {
+                            param_name.split('/').next_back().unwrap_or(&param_name).to_string()
+                        } else {
+                            param_name.clone()
+                        };
+                        ErrorCondition::AdditionalProperties {
+                            field: unexpected_field,
+                        }
+                    }
+                    other => other,
+                };
+
+                let (error_type, msg, ctx) =
+                    ErrorMapper::map_error(&error_condition, &self.schema, &schema_prop_path, &error_msg);
+
+                ValidationErrorDetail {
+                    error_type,
+                    loc: loc_parts,
+                    msg,
+                    input: input_value,
+                    ctx,
+                }
+            })
+            .collect();
+
+        debug_log_module!("validation", "Returning {} validation errors", errors.len());
+        for (i, error) in errors.iter().enumerate() {
+            debug_log_module!(
+                "validation",
+                "  Error {}: type={}, loc={:?}, msg={}, input={}, ctx={:?}",
+                i,
+                error.error_type,
+                error.loc,
+                error.msg,
+                error.input,
+                error.ctx
+            );
+        }
+        #[allow(clippy::collapsible_if)]
+        if crate::debug::is_enabled() {
+            if let Ok(json_errors) = serde_json::to_value(&errors) {
+                if let Ok(json_str) = serde_json::to_string_pretty(&json_errors) {
+                    debug_log_module!("validation", "Serialized errors:\n{}", json_str);
+                }
+            }
+        }
+
+        Err(ValidationError { errors })
+    }
+
+    /// Validate and parse JSON bytes
+    pub fn validate_json(&self, json_bytes: &[u8]) -> Result<Value, ValidationError> {
+        let value: Value = serde_json::from_slice(json_bytes).map_err(|e| ValidationError {
+            errors: vec![ValidationErrorDetail {
+                error_type: "json_parse_error".to_string(),
+                loc: vec!["body".to_string()],
+                msg: format!("Invalid JSON: {}", e),
+                input: Value::Null,
+                ctx: None,
+            }],
+        })?;
+
+        self.validate(&value)?;
+
+        Ok(value)
+    }
+}
+
+/// Validation error containing one or more validation failures
+#[derive(Debug, Clone)]
+pub struct ValidationError {
+    pub errors: Vec<ValidationErrorDetail>,
+}
+
+/// Individual validation error detail (FastAPI-compatible format)
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct ValidationErrorDetail {
+    #[serde(rename = "type")]
+    pub error_type: String,
+    pub loc: Vec<String>,
+    pub msg: String,
+    pub input: Value,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ctx: Option<Value>,
+}
+
+impl std::fmt::Display for ValidationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Validation failed: {} errors", self.errors.len())
+    }
+}
+
+impl std::error::Error for ValidationError {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn test_validator_creation() {
+        let schema = json!({
+            "type": "object",
+            "properties": {
+                "name": {"type": "string"},
+                "age": {"type": "integer"}
+            },
+            "required": ["name"]
+        });
+
+        let validator = SchemaValidator::new(schema).unwrap();
+        assert!(validator.compiled.is_valid(&json!({"name": "Alice", "age": 30})));
+    }
+
+    #[test]
+    fn test_validation_success() {
+        let schema = json!({
+            "type": "object",
+            "properties": {
+                "email": {"type": "string", "format": "email"}
+            }
+        });
+
+        let validator = SchemaValidator::new(schema).unwrap();
+        let data = json!({"email": "test@example.com"});
+
+        assert!(validator.validate(&data).is_ok());
+    }
+
+    #[test]
+    fn test_validation_failure() {
+        let schema = json!({
+            "type": "object",
+            "properties": {
+                "age": {"type": "integer", "minimum": 0}
+            },
+            "required": ["age"]
+        });
+
+        let validator = SchemaValidator::new(schema).unwrap();
+        let data = json!({"age": -5});
+
+        assert!(validator.validate(&data).is_err());
+    }
+
+    #[test]
+    fn test_validation_error_serialization() {
+        let schema = json!({
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string",
+                    "maxLength": 10
+                }
+            },
+            "required": ["name"]
+        });
+
+        let validator = SchemaValidator::new(schema).unwrap();
+        let data = json!({"name": "this_is_way_too_long"});
+
+        let result = validator.validate(&data);
+        assert!(result.is_err());
+
+        let err = result.unwrap_err();
+        assert_eq!(err.errors.len(), 1);
+
+        let error_detail = &err.errors[0];
+        assert_eq!(error_detail.error_type, "string_too_long");
+        assert_eq!(error_detail.loc, vec!["body", "name"]);
+        assert_eq!(error_detail.msg, "String should have at most 10 characters");
+        assert_eq!(error_detail.input, Value::String("this_is_way_too_long".to_string()));
+        assert_eq!(error_detail.ctx, Some(json!({"max_length": 10})));
+
+        let json_output = serde_json::to_value(&err.errors).unwrap();
+        println!(
+            "Serialized JSON: {}",
+            serde_json::to_string_pretty(&json_output).unwrap()
+        );
+
+        let serialized_error = &json_output[0];
+        assert!(serialized_error.get("type").is_some());
+        assert!(serialized_error.get("loc").is_some());
+        assert!(serialized_error.get("msg").is_some());
+        assert!(
+            serialized_error.get("input").is_some(),
+            "Missing 'input' field in serialized JSON!"
+        );
+        assert!(
+            serialized_error.get("ctx").is_some(),
+            "Missing 'ctx' field in serialized JSON!"
+        );
+
+        assert_eq!(
+            serialized_error["input"],
+            Value::String("this_is_way_too_long".to_string())
+        );
+        assert_eq!(serialized_error["ctx"], json!({"max_length": 10}));
+    }
+
+    #[test]
+    fn test_exclusive_minimum() {
+        let schema = json!({
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": ["id", "name", "price"],
+            "properties": {
+                "id": {
+                    "type": "integer"
+                },
+                "name": {
+                    "type": "string",
+                    "minLength": 3
+                },
+                "price": {
+                    "type": "number",
+                    "exclusiveMinimum": 0
+                }
+            }
+        });
+
+        let validator = SchemaValidator::new(schema).unwrap();
+
+        let data = json!({
+            "id": 1,
+            "name": "X",
+            "price": -10
+        });
+
+        let result = validator.validate(&data);
+        eprintln!("Validation result: {:?}", result);
+
+        assert!(result.is_err(), "Should have validation errors");
+        let err = result.unwrap_err();
+        eprintln!("Errors: {:?}", err.errors);
+        assert_eq!(err.errors.len(), 2, "Should have 2 errors");
+    }
+}

data/vendor/crates/spikard-http/Cargo.toml

@@ -0,0 +1,58 @@
+[package]
+name = "spikard-http"
+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 = "High-performance HTTP server for Spikard with tower-http middleware stack"
+keywords = ["http", "server", "axum", "tower", "middleware"]
+categories = ["web-programming::http-server", "web-programming"]
+documentation = "https://docs.rs/spikard-http"
+readme = "README.md"
+
+[dependencies]
+axum = { version = "0.8", features = ["multipart", "ws"]  }
+tokio = { version = "1", features = ["full"] }
+tokio-util = "0.7"
+tower = "0.5"
+tower-http = { version = "0.6.8", features = ["trace", "request-id", "compression-gzip", "compression-br", "timeout", "limit", "fs", "set-header", "sensitive-headers"] }
+tower_governor = "0.8"
+jsonwebtoken = { version = "10.2", features = ["use_pem", "rust_crypto"] }
+utoipa = { version = "5", features = ["axum_extras", "chrono", "uuid"] }
+utoipa-swagger-ui = { version = "9", features = ["axum"] }
+utoipa-redoc = { version = "6", features = ["axum"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+spikard-core = { path = "../spikard-core" }
+futures-util = "0.3"
+futures = "0.3"
+jsonschema = { version = "0.37", default-features = false }
+serde_qs = "0.15"
+lazy_static = "1.5"
+regex = "1"
+rustc-hash = "2.1"
+urlencoding = "2.1"
+mime = "0.3"
+jiff = "0.2"
+uuid = "1.19"
+bytes = "1.11"
+http-body-util = "0.1"
+http-body = "1.0"
+axum-test = { version = "18", features = ["ws"] }
+anyhow = "1.0"
+cookie = "0.18"
+base64 = "0.22.1"
+flate2 = { version = "=1.1.5", default-features = false, features = ["rust_backend"] }
+brotli = "8.0"
+
+[features]
+default = []
+di = ["spikard-core/di"]
+
+[dev-dependencies]
+chrono = "0.4"
+doc-comment = "0.3"

data/vendor/crates/spikard-http/examples/sse-notifications.rs

@@ -0,0 +1,147 @@
+//! SSE Notifications Server Example
+//!
+//! Demonstrates Server-Sent Events support in Spikard matching the AsyncAPI notifications specification.
+
+use axum::{Router, routing::get};
+use chrono::Utc;
+use serde::Serialize;
+use serde_json::json;
+use spikard_http::{SseEvent, SseEventProducer, SseState, sse_handler};
+use std::sync::atomic::{AtomicUsize, Ordering};
+use tokio::time::{Duration, sleep};
+use tracing::info;
+
+/// Notification event types matching AsyncAPI specification
+#[derive(Debug, Clone, Serialize)]
+#[serde(tag = "type")]
+#[allow(clippy::enum_variant_names)]
+enum Notification {
+    #[serde(rename = "system_alert")]
+    SystemAlert {
+        level: String,
+        message: String,
+        source: String,
+        timestamp: String,
+    },
+    #[serde(rename = "user_notification")]
+    UserNotification {
+        #[serde(rename = "userId")]
+        user_id: String,
+        title: String,
+        body: String,
+        priority: String,
+        timestamp: String,
+    },
+    #[serde(rename = "status_update")]
+    StatusUpdate {
+        service: String,
+        status: String,
+        message: Option<String>,
+        metadata: serde_json::Value,
+        timestamp: String,
+    },
+}
+
+/// Notification producer implementing SseEventProducer trait
+struct NotificationProducer {
+    counter: AtomicUsize,
+}
+
+impl NotificationProducer {
+    fn new() -> Self {
+        Self {
+            counter: AtomicUsize::new(0),
+        }
+    }
+
+    fn create_notification(&self, index: usize) -> Notification {
+        let timestamp = Utc::now().to_rfc3339();
+
+        match index % 3 {
+            0 => Notification::SystemAlert {
+                level: "info".to_string(),
+                message: format!("System checkpoint {} reached", index),
+                source: "monitoring-system".to_string(),
+                timestamp,
+            },
+            1 => Notification::UserNotification {
+                user_id: format!("user_{}", index),
+                title: "New Update Available".to_string(),
+                body: format!("Version 1.{} is now available for download", index),
+                priority: "normal".to_string(),
+                timestamp,
+            },
+            _ => Notification::StatusUpdate {
+                service: "api-gateway".to_string(),
+                status: "operational".to_string(),
+                message: Some(format!("Health check {} passed", index)),
+                metadata: json!({
+                    "response_time_ms": 50 + (index % 100),
+                    "active_connections": 100 + (index % 50)
+                }),
+                timestamp,
+            },
+        }
+    }
+}
+
+impl SseEventProducer for NotificationProducer {
+    async fn next_event(&self) -> Option<SseEvent> {
+        sleep(Duration::from_secs(2)).await;
+
+        let count = self.counter.fetch_add(1, Ordering::Relaxed);
+
+        if count >= 10 {
+            info!("Completed sending 10 notifications");
+            return None;
+        }
+
+        let notification = self.create_notification(count);
+        let event_type = match &notification {
+            Notification::SystemAlert { .. } => "system_alert",
+            Notification::UserNotification { .. } => "user_notification",
+            Notification::StatusUpdate { .. } => "status_update",
+        };
+
+        info!("Sending notification #{}: {}", count + 1, event_type);
+
+        let data = serde_json::to_value(notification).unwrap();
+
+        Some(
+            SseEvent::with_type(event_type, data)
+                .with_id(format!("event_{}", count))
+                .with_retry(3000),
+        )
+    }
+
+    async fn on_connect(&self) {
+        info!("Client connected to notifications stream");
+    }
+
+    async fn on_disconnect(&self) {
+        info!("Client disconnected from notifications stream");
+    }
+}
+
+#[tokio::main]
+async fn main() {
+    tracing_subscriber::fmt()
+        .with_env_filter("info,sse_notifications=debug")
+        .init();
+
+    let producer = NotificationProducer::new();
+    let sse_state = SseState::new(producer);
+
+    let app = Router::new()
+        .route("/notifications", get(sse_handler::<NotificationProducer>))
+        .with_state(sse_state);
+
+    let addr = "127.0.0.1:8000";
+    info!("SSE notifications server listening on {}", addr);
+    info!("Connect at: http://{}/notifications", addr);
+    info!("Try: curl -N http://{}/notifications", addr);
+
+    let listener = tokio::net::TcpListener::bind(addr).await.expect("Failed to bind");
+
+    axum::serve(listener, app).await.expect("Server error");
+}