spikard 0.3.6 → 0.5.0

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

@@ -1,10 +1,14 @@
 //! 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 {
@@ -200,280 +204,34 @@ impl SchemaValidator {
                     format!("/properties/{}", param_name)
                 };
 
-                let (error_type, msg, ctx) = if schema_path_str.contains("minLength") {
-                    if let Some(min_len) = self
-                        .schema
-                        .pointer(&format!("{}/minLength", schema_prop_path))
-                        .and_then(|v| v.as_u64())
-                    {
-                        let ctx = serde_json::json!({"min_length": min_len});
-                        (
-                            "string_too_short".to_string(),
-                            format!("String should have at least {} characters", min_len),
-                            Some(ctx),
-                        )
-                    } else {
-                        ("string_too_short".to_string(), "String is too short".to_string(), None)
-                    }
-                } else if schema_path_str.contains("maxLength") {
-                    if let Some(max_len) = self
-                        .schema
-                        .pointer(&format!("{}/maxLength", schema_prop_path))
-                        .and_then(|v| v.as_u64())
-                    {
-                        let ctx = serde_json::json!({"max_length": max_len});
-                        (
-                            "string_too_long".to_string(),
-                            format!("String should have at most {} characters", max_len),
-                            Some(ctx),
-                        )
-                    } else {
-                        ("string_too_long".to_string(), "String is too long".to_string(), None)
-                    }
-                } else if schema_path_str.contains("exclusiveMinimum")
-                    || (error_msg.contains("less than or equal to") && error_msg.contains("minimum"))
-                {
-                    if let Some(min_val) = self
-                        .schema
-                        .pointer(&format!("{}/exclusiveMinimum", schema_prop_path))
-                        .and_then(|v| v.as_i64())
-                    {
-                        let ctx = serde_json::json!({"gt": min_val});
-                        (
-                            "greater_than".to_string(),
-                            format!("Input should be greater than {}", min_val),
-                            Some(ctx),
-                        )
-                    } else {
-                        (
-                            "greater_than".to_string(),
-                            "Input should be greater than the minimum".to_string(),
-                            None,
-                        )
-                    }
-                } else if schema_path_str.contains("minimum") || error_msg.contains("less than the minimum") {
-                    if let Some(min_val) = self
-                        .schema
-                        .pointer(&format!("{}/minimum", schema_prop_path))
-                        .and_then(|v| v.as_i64())
-                    {
-                        let ctx = serde_json::json!({"ge": min_val});
-                        (
-                            "greater_than_equal".to_string(),
-                            format!("Input should be greater than or equal to {}", min_val),
-                            Some(ctx),
-                        )
-                    } else {
-                        (
-                            "greater_than_equal".to_string(),
-                            "Input should be greater than or equal to the minimum".to_string(),
-                            None,
-                        )
-                    }
-                } else if schema_path_str.contains("exclusiveMaximum")
-                    || (error_msg.contains("greater than or equal to") && error_msg.contains("maximum"))
-                {
-                    if let Some(max_val) = self
-                        .schema
-                        .pointer(&format!("{}/exclusiveMaximum", schema_prop_path))
-                        .and_then(|v| v.as_i64())
-                    {
-                        let ctx = serde_json::json!({"lt": max_val});
-                        (
-                            "less_than".to_string(),
-                            format!("Input should be less than {}", max_val),
-                            Some(ctx),
-                        )
-                    } else {
-                        (
-                            "less_than".to_string(),
-                            "Input should be less than the maximum".to_string(),
-                            None,
-                        )
+                let mut error_condition = ErrorCondition::from_schema_error(schema_path_str, &error_msg);
+
+                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 }
                     }
-                } else if schema_path_str.contains("maximum") || error_msg.contains("greater than the maximum") {
-                    if let Some(max_val) = self
-                        .schema
-                        .pointer(&format!("{}/maximum", schema_prop_path))
-                        .and_then(|v| v.as_i64())
-                    {
-                        let ctx = serde_json::json!({"le": max_val});
-                        (
-                            "less_than_equal".to_string(),
-                            format!("Input should be less than or equal to {}", max_val),
-                            Some(ctx),
-                        )
-                    } else {
-                        (
-                            "less_than_equal".to_string(),
-                            "Input should be less than or equal to the maximum".to_string(),
-                            None,
-                        )
-                    }
-                } else if schema_path_str.contains("enum") || error_msg.contains("is not one of") {
-                    if let Some(enum_values) = self
-                        .schema
-                        .pointer(&format!("{}/enum", schema_prop_path))
-                        .and_then(|v| v.as_array())
-                    {
-                        let values: Vec<String> = enum_values
-                            .iter()
-                            .filter_map(|v| v.as_str().map(|s| format!("'{}'", s)))
-                            .collect();
-
-                        let msg = if values.len() > 1 {
-                            let last = values.last().unwrap();
-                            let rest = &values[..values.len() - 1];
-                            format!("Input should be {} or {}", rest.join(", "), last)
-                        } else if !values.is_empty() {
-                            format!("Input should be {}", values[0])
-                        } else {
-                            "Input should be one of the allowed values".to_string()
-                        };
-
-                        let expected_str = if values.len() > 1 {
-                            let last = values.last().unwrap();
-                            let rest = &values[..values.len() - 1];
-                            format!("{} or {}", rest.join(", "), last)
-                        } else if !values.is_empty() {
-                            values[0].clone()
+                    ErrorCondition::AdditionalProperties { .. } => {
+                        let unexpected_field = if param_name.contains('/') {
+                            param_name.split('/').next_back().unwrap_or(&param_name).to_string()
                         } else {
-                            "allowed values".to_string()
+                            param_name.clone()
                         };
-                        let ctx = serde_json::json!({"expected": expected_str});
-                        ("enum".to_string(), msg, Some(ctx))
-                    } else {
-                        (
-                            "enum".to_string(),
-                            "Input should be one of the allowed values".to_string(),
-                            None,
-                        )
-                    }
-                } else if schema_path_str.contains("pattern") || error_msg.contains("does not match") {
-                    if let Some(pattern) = self
-                        .schema
-                        .pointer(&format!("{}/pattern", schema_prop_path))
-                        .and_then(|v| v.as_str())
-                    {
-                        let ctx = serde_json::json!({"pattern": pattern});
-                        let msg = format!("String should match pattern '{}'", pattern);
-                        ("string_pattern_mismatch".to_string(), msg, Some(ctx))
-                    } else {
-                        (
-                            "string_pattern_mismatch".to_string(),
-                            "String does not match expected pattern".to_string(),
-                            None,
-                        )
-                    }
-                } else if schema_path_str.contains("format") {
-                    if error_msg.contains("email") {
-                        let email_pattern = r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$";
-                        let ctx = serde_json::json!({"pattern": email_pattern});
-                        (
-                            "string_pattern_mismatch".to_string(),
-                            format!("String should match pattern '{}'", email_pattern),
-                            Some(ctx),
-                        )
-                    } else if error_msg.contains("uuid") {
-                        (
-                            "uuid_parsing".to_string(),
-                            "Input should be a valid UUID".to_string(),
-                            None,
-                        )
-                    } else if error_msg.contains("date-time") {
-                        (
-                            "datetime_parsing".to_string(),
-                            "Input should be a valid datetime".to_string(),
-                            None,
-                        )
-                    } else if error_msg.contains("date") {
-                        (
-                            "date_parsing".to_string(),
-                            "Input should be a valid date".to_string(),
-                            None,
-                        )
-                    } else {
-                        ("format_error".to_string(), err.to_string(), None)
-                    }
-                } else if schema_path_str.contains("/type") {
-                    let expected_type = self
-                        .schema
-                        .pointer(&format!("{}/type", schema_prop_path))
-                        .and_then(|v| v.as_str())
-                        .unwrap_or("unknown");
-
-                    let (error_type, msg) = match expected_type {
-                        "integer" => (
-                            "int_parsing".to_string(),
-                            "Input should be a valid integer, unable to parse string as an integer".to_string(),
-                        ),
-                        "number" => (
-                            "float_parsing".to_string(),
-                            "Input should be a valid number, unable to parse string as a number".to_string(),
-                        ),
-                        "boolean" => (
-                            "bool_parsing".to_string(),
-                            "Input should be a valid boolean".to_string(),
-                        ),
-                        "string" => ("string_type".to_string(), "Input should be a valid string".to_string()),
-                        _ => (
-                            "type_error".to_string(),
-                            format!("Input should be a valid {}", expected_type),
-                        ),
-                    };
-                    (error_type, msg, None)
-                } else if schema_path_str.ends_with("/required") {
-                    ("missing".to_string(), "Field required".to_string(), None)
-                } else if schema_path_str.contains("/additionalProperties")
-                    || error_msg.contains("Additional properties are not allowed")
-                {
-                    let unexpected_field = if param_name.contains('/') {
-                        param_name.split('/').next_back().unwrap_or(&param_name).to_string()
-                    } else {
-                        param_name.clone()
-                    };
-
-                    let ctx = serde_json::json!({
-                        "additional_properties": false,
-                        "unexpected_field": unexpected_field
-                    });
-                    (
-                        "validation_error".to_string(),
-                        "Additional properties are not allowed".to_string(),
-                        Some(ctx),
-                    )
-                } else if schema_path_str.contains("/minItems") {
-                    let min_items = if let Some(start) = schema_path_str.rfind('/') {
-                        if let Some(_min_idx) = schema_path_str[..start].rfind("/minItems") {
-                            1
-                        } else {
-                            1
+                        ErrorCondition::AdditionalProperties {
+                            field: unexpected_field,
                         }
-                    } else {
-                        1
-                    };
-
-                    let ctx = serde_json::json!({
-                        "min_length": min_items
-                    });
-                    (
-                        "too_short".to_string(),
-                        format!("List should have at least {} item after validation", min_items),
-                        Some(ctx),
-                    )
-                } else if schema_path_str.contains("/maxItems") {
-                    let ctx = serde_json::json!({
-                        "max_length": 1
-                    });
-                    (
-                        "too_long".to_string(),
-                        "List should have at most N items after validation".to_string(),
-                        Some(ctx),
-                    )
-                } else {
-                    ("validation_error".to_string(), err.to_string(), None)
+                    }
+                    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,

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

@@ -1,6 +1,6 @@
 [package]
 name = "spikard-http"
-version = "0.3.6"
+version = "0.5.0"
 edition = "2024"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
 license = "MIT"
@@ -13,21 +13,11 @@ documentation = "https://docs.rs/spikard-http"
 readme = "README.md"
 
 [dependencies]
-axum = { version = "0.8", features = ["multipart", "ws"] }
+axum = { version = "0.8", features = ["multipart", "ws"]  }
 tokio = { version = "1", features = ["full"] }
 tokio-util = "0.7"
 tower = "0.5"
-tower-http = { version = "0.6.7", features = [
-    "trace",
-    "request-id",
-    "compression-gzip",
-    "compression-br",
-    "timeout",
-    "limit",
-    "fs",
-    "set-header",
-    "sensitive-headers",
-] }
+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"] }
@@ -37,18 +27,20 @@ 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", features = ["di"] }
+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"
+lru = "0.16"
 regex = "1"
 rustc-hash = "2.1"
 urlencoding = "2.1"
+url = "2.5"
 mime = "0.3"
 jiff = "0.2"
-uuid = "1.18"
+uuid = "1.19"
 bytes = "1.11"
 http-body-util = "0.1"
 http-body = "1.0"
@@ -56,9 +48,12 @@ axum-test = { version = "18", features = ["ws"] }
 anyhow = "1.0"
 cookie = "0.18"
 base64 = "0.22.1"
-flate2 = "1.1"
+flate2 = { version = "=1.1.5", default-features = false, features = ["rust_backend"] }
 brotli = "8.0"
 
+[lints]
+workspace = true
+
 [features]
 default = []
 di = ["spikard-core/di"]
@@ -66,3 +61,4 @@ di = ["spikard-core/di"]
 [dev-dependencies]
 chrono = "0.4"
 doc-comment = "0.3"
+tempfile = "3.23"

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

@@ -0,0 +1,148 @@
+#![allow(clippy::pedantic, clippy::nursery, clippy::all)]
+//! 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");
+}

data/vendor/crates/spikard-http/examples/websocket-chat.rs

@@ -0,0 +1,92 @@
+#![allow(clippy::pedantic, clippy::nursery, clippy::all)]
+//! WebSocket Chat Server Example
+//!
+//! Demonstrates WebSocket support in Spikard matching the AsyncAPI chat specification.
+//! This server implements a simple chat system with three message types:
+//! - chatMessage: User sends a chat message
+//! - userJoined: User joins the chat
+//! - userLeft: User leaves the chat
+
+use axum::{Router, routing::get};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use spikard_http::{WebSocketHandler, WebSocketState, websocket_handler};
+use tracing::{info, warn};
+
+/// Chat message types matching AsyncAPI specification
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type")]
+#[allow(clippy::enum_variant_names)]
+enum ChatMessage {
+    #[serde(rename = "message")]
+    ChatMessage {
+        user: String,
+        text: String,
+        timestamp: String,
+    },
+    #[serde(rename = "userJoined")]
+    UserJoined { user: String, timestamp: String },
+    #[serde(rename = "userLeft")]
+    UserLeft { user: String, timestamp: String },
+}
+
+/// Chat handler implementing WebSocketHandler trait
+struct ChatHandler;
+
+impl WebSocketHandler for ChatHandler {
+    async fn handle_message(&self, message: Value) -> Option<Value> {
+        match serde_json::from_value::<ChatMessage>(message.clone()) {
+            Ok(chat_msg) => {
+                match chat_msg {
+                    ChatMessage::ChatMessage { ref user, ref text, .. } => {
+                        info!("Chat message from {}: {}", user, text);
+                    }
+                    ChatMessage::UserJoined { ref user, .. } => {
+                        info!("User joined: {}", user);
+                    }
+                    ChatMessage::UserLeft { ref user, .. } => {
+                        info!("User left: {}", user);
+                    }
+                }
+
+                Some(message)
+            }
+            Err(e) => {
+                warn!("Failed to parse chat message: {}", e);
+                Some(serde_json::json!({
+                    "type": "error",
+                    "message": format!("Invalid message format: {}", e)
+                }))
+            }
+        }
+    }
+
+    async fn on_connect(&self) {
+        info!("Client connected to chat");
+    }
+
+    async fn on_disconnect(&self) {
+        info!("Client disconnected from chat");
+    }
+}
+
+#[tokio::main]
+async fn main() {
+    tracing_subscriber::fmt()
+        .with_env_filter("info,websocket_chat=debug")
+        .init();
+
+    let ws_state = WebSocketState::new(ChatHandler);
+
+    let app = Router::new()
+        .route("/chat", get(websocket_handler::<ChatHandler>))
+        .with_state(ws_state);
+
+    let addr = "127.0.0.1:8000";
+    info!("WebSocket chat server listening on {}", addr);
+    info!("Connect at: ws://{}/chat", addr);
+
+    let listener = tokio::net::TcpListener::bind(addr).await.expect("Failed to bind");
+
+    axum::serve(listener, app).await.expect("Server error");
+}