spikard 0.3.5 → 0.5.0

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

@@ -1,68 +1,64 @@
-[package]
-name = "spikard-http"
-version = "0.3.5"
-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.7", 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", features = ["di"] }
-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.18"
-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 = "1.1"
-brotli = "8.0"
-
-[features]
-default = []
-di = ["spikard-core/di"]
-
-[dev-dependencies]
-chrono = "0.4"
-doc-comment = "0.3"
+[package]
+name = "spikard-http"
+version = "0.5.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"
+lru = "0.16"
+regex = "1"
+rustc-hash = "2.1"
+urlencoding = "2.1"
+url = "2.5"
+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"
+
+[lints]
+workspace = true
+
+[features]
+default = []
+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");
+}