spikard 0.13.0 → 0.15.2

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

@@ -1,82 +0,0 @@
-[package]
-name = "spikard-http"
-version = "0.13.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"
-tokio-stream = "0.1"
-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 = "1.0"
-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.22"
-ahash = "0.8"
-bytes = "1.11"
-http-body-util = "0.1"
-http-body = "1.0"
-axum-test = { version = "19", features = ["ws"] }
-anyhow = "1.0"
-cookie = "0.18"
-flate2 = { version = "=1.1.5", default-features = false, features = ["rust_backend"] }
-brotli = "8.0"
-tonic = { version = "0.14", features = ["transport", "codegen", "gzip"] }
-prost = "0.14"
-prost-types = "0.14"
-h2 = "0.4"
-
-[lints]
-workspace = true
-
-[features]
-default = []
-di = ["spikard-core/di"]
-
-[dev-dependencies]
-chrono = "0.4"
-doc-comment = "0.3"
-tempfile = "3.27"
-
-[package.metadata.cargo-machete]
-ignored = [
-  "anyhow",
-  "h2",
-  "http-body",
-  "jiff",
-  "prost",
-  "prost-types",
-  "tokio-stream",
-  "utoipa-redoc",
-  "utoipa-swagger-ui",
-]

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

@@ -1,148 +0,0 @@
-#![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

@@ -1,92 +0,0 @@
-#![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");
-}

data/vendor/crates/spikard-http/src/auth.rs

@@ -1,301 +0,0 @@
-//! Authentication middleware for JWT and API keys.
-//!
-//! This module provides tower middleware for authenticating requests using:
-//! - JWT tokens (via the Authorization header)
-//! - API keys (via custom headers)
-
-use axum::{
-    body::Body,
-    extract::Request,
-    http::{HeaderMap, StatusCode, Uri},
-    middleware::Next,
-    response::{IntoResponse, Response},
-};
-use jsonwebtoken::{Algorithm, DecodingKey, Validation, decode};
-use serde::{Deserialize, Serialize};
-use std::collections::HashSet;
-
-use crate::{ApiKeyConfig, JwtConfig, ProblemDetails};
-
-/// Standard type URI for authentication errors (401)
-const TYPE_AUTH_ERROR: &str = "https://spikard.dev/errors/unauthorized";
-
-/// Standard type URI for configuration errors (500)
-const TYPE_CONFIG_ERROR: &str = "https://spikard.dev/errors/configuration-error";
-
-/// Internal header key used to expose validated JWT claims to handlers.
-pub const INTERNAL_JWT_CLAIMS_HEADER: &str = "x-spikard-jwt-claims";
-
-/// JWT claims structure - can be extended based on needs
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Claims {
-    pub sub: String,
-    pub exp: usize,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub iat: Option<usize>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub nbf: Option<usize>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub aud: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub iss: Option<String>,
-}
-
-/// JWT authentication middleware
-///
-/// Validates JWT tokens from the Authorization header (Bearer scheme).
-/// On success, the validated claims are available to downstream handlers.
-/// On failure, returns 401 Unauthorized with RFC 9457 Problem Details.
-///
-/// Coverage: Tested via integration tests (`auth_integration.rs`)
-///
-/// # Errors
-/// Returns an error response when the Authorization header is missing, malformed,
-/// the token is invalid, or configuration is incorrect.
-#[cfg(not(tarpaulin_include))]
-pub async fn jwt_auth_middleware(
-    config: JwtConfig,
-    headers: HeaderMap,
-    request: Request<Body>,
-    next: Next,
-) -> Result<Response, Response> {
-    let auth_header = headers
-        .get("authorization")
-        .and_then(|v| v.to_str().ok())
-        .ok_or_else(|| {
-            let problem = ProblemDetails::new(
-                TYPE_AUTH_ERROR,
-                "Missing or invalid Authorization header",
-                StatusCode::UNAUTHORIZED,
-            )
-            .with_detail("Expected 'Authorization: Bearer <token>'");
-            (StatusCode::UNAUTHORIZED, axum::Json(problem)).into_response()
-        })?;
-
-    let token = auth_header.strip_prefix("Bearer ").ok_or_else(|| {
-        let problem = ProblemDetails::new(
-            TYPE_AUTH_ERROR,
-            "Invalid Authorization header format",
-            StatusCode::UNAUTHORIZED,
-        )
-        .with_detail("Authorization header must use Bearer scheme: 'Bearer <token>'");
-        (StatusCode::UNAUTHORIZED, axum::Json(problem)).into_response()
-    })?;
-
-    let parts: Vec<&str> = token.split('.').collect();
-    if parts.len() != 3 {
-        let problem = ProblemDetails::new(TYPE_AUTH_ERROR, "Malformed JWT token", StatusCode::UNAUTHORIZED)
-            .with_detail(format!(
-                "Malformed JWT token: expected 3 parts separated by dots, found {}",
-                parts.len()
-            ));
-        return Err((StatusCode::UNAUTHORIZED, axum::Json(problem)).into_response());
-    }
-
-    let algorithm = parse_algorithm(&config.algorithm).map_err(|_| {
-        let problem = ProblemDetails::new(
-            TYPE_CONFIG_ERROR,
-            "Invalid JWT configuration",
-            StatusCode::INTERNAL_SERVER_ERROR,
-        )
-        .with_detail(format!("Unsupported algorithm: {}", config.algorithm));
-        (StatusCode::INTERNAL_SERVER_ERROR, axum::Json(problem)).into_response()
-    })?;
-
-    let mut validation = Validation::new(algorithm);
-    if let Some(ref aud) = config.audience {
-        validation.set_audience(aud);
-    }
-    if let Some(ref iss) = config.issuer {
-        validation.set_issuer(std::slice::from_ref(iss));
-    }
-    validation.leeway = config.leeway;
-    validation.validate_nbf = true;
-
-    let decoding_key = DecodingKey::from_secret(config.secret.as_bytes());
-    let token_data = decode::<Claims>(token, &decoding_key, &validation).map_err(|e| {
-        let detail = match e.kind() {
-            jsonwebtoken::errors::ErrorKind::ExpiredSignature => "Token has expired".to_string(),
-            jsonwebtoken::errors::ErrorKind::InvalidToken => "Token is invalid".to_string(),
-            jsonwebtoken::errors::ErrorKind::InvalidSignature | jsonwebtoken::errors::ErrorKind::Base64(_) => {
-                "Token signature is invalid".to_string()
-            }
-            jsonwebtoken::errors::ErrorKind::InvalidAudience => "Token audience is invalid".to_string(),
-            jsonwebtoken::errors::ErrorKind::InvalidIssuer => config.issuer.as_ref().map_or_else(
-                || "Token issuer is invalid".to_string(),
-                |expected_iss| format!("Token issuer is invalid, expected '{expected_iss}'"),
-            ),
-            jsonwebtoken::errors::ErrorKind::ImmatureSignature => {
-                "JWT not valid yet, not before claim is in the future".to_string()
-            }
-            _ => format!("Token validation failed: {e}"),
-        };
-
-        let problem =
-            ProblemDetails::new(TYPE_AUTH_ERROR, "JWT validation failed", StatusCode::UNAUTHORIZED).with_detail(detail);
-        (StatusCode::UNAUTHORIZED, axum::Json(problem)).into_response()
-    })?;
-
-    let mut request = request;
-    request.extensions_mut().insert(token_data.claims);
-
-    Ok(next.run(request).await)
-}
-
-/// Parse JWT algorithm string to jsonwebtoken Algorithm enum
-fn parse_algorithm(alg: &str) -> Result<Algorithm, String> {
-    match alg {
-        "HS256" => Ok(Algorithm::HS256),
-        "HS384" => Ok(Algorithm::HS384),
-        "HS512" => Ok(Algorithm::HS512),
-        "RS256" => Ok(Algorithm::RS256),
-        "RS384" => Ok(Algorithm::RS384),
-        "RS512" => Ok(Algorithm::RS512),
-        "ES256" => Ok(Algorithm::ES256),
-        "ES384" => Ok(Algorithm::ES384),
-        "PS256" => Ok(Algorithm::PS256),
-        "PS384" => Ok(Algorithm::PS384),
-        "PS512" => Ok(Algorithm::PS512),
-        _ => Err(format!("Unsupported algorithm: {alg}")),
-    }
-}
-
-/// API Key authentication middleware
-///
-/// Validates API keys from a custom header (default: X-API-Key) or query parameter.
-/// Checks header first, then query parameter as fallback.
-/// On success, the request proceeds to the next handler.
-/// On failure, returns 401 Unauthorized with RFC 9457 Problem Details.
-///
-/// Coverage: Tested via integration tests (`auth_integration.rs`)
-///
-/// # Errors
-/// Returns an error response when the API key is missing or invalid.
-#[cfg(not(tarpaulin_include))]
-pub async fn api_key_auth_middleware(
-    config: ApiKeyConfig,
-    headers: HeaderMap,
-    request: Request<Body>,
-    next: Next,
-) -> Result<Response, Response> {
-    let valid_keys: HashSet<String> = config.keys.into_iter().collect();
-
-    let uri = request.uri().clone();
-
-    let api_key_from_header = headers.get(&config.header_name).and_then(|v| v.to_str().ok());
-
-    let api_key = api_key_from_header.map_or_else(|| extract_api_key_from_query(&uri), Some);
-
-    let api_key = api_key.ok_or_else(|| {
-        let problem =
-            ProblemDetails::new(TYPE_AUTH_ERROR, "Missing API key", StatusCode::UNAUTHORIZED).with_detail(format!(
-                "Expected '{}' header or 'api_key' query parameter with valid API key",
-                config.header_name
-            ));
-        (StatusCode::UNAUTHORIZED, axum::Json(problem)).into_response()
-    })?;
-
-    if !valid_keys.contains(api_key) {
-        let problem = ProblemDetails::new(TYPE_AUTH_ERROR, "Invalid API key", StatusCode::UNAUTHORIZED)
-            .with_detail("The provided API key is not valid");
-        return Err((StatusCode::UNAUTHORIZED, axum::Json(problem)).into_response());
-    }
-
-    Ok(next.run(request).await)
-}
-
-/// Extract API key from query parameters
-///
-/// Checks for common API key parameter names: api_key, apiKey, key
-fn extract_api_key_from_query(uri: &Uri) -> Option<&str> {
-    let query = uri.query()?;
-
-    for param in query.split('&') {
-        if let Some((key, value)) = param.split_once('=')
-            && (key == "api_key" || key == "apiKey" || key == "key")
-        {
-            return Some(value);
-        }
-    }
-
-    None
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_parse_algorithm() {
-        assert!(matches!(parse_algorithm("HS256"), Ok(Algorithm::HS256)));
-        assert!(matches!(parse_algorithm("HS384"), Ok(Algorithm::HS384)));
-        assert!(matches!(parse_algorithm("HS512"), Ok(Algorithm::HS512)));
-        assert!(matches!(parse_algorithm("RS256"), Ok(Algorithm::RS256)));
-        assert!(matches!(parse_algorithm("RS384"), Ok(Algorithm::RS384)));
-        assert!(matches!(parse_algorithm("RS512"), Ok(Algorithm::RS512)));
-        assert!(matches!(parse_algorithm("ES256"), Ok(Algorithm::ES256)));
-        assert!(matches!(parse_algorithm("ES384"), Ok(Algorithm::ES384)));
-        assert!(matches!(parse_algorithm("PS256"), Ok(Algorithm::PS256)));
-        assert!(matches!(parse_algorithm("PS384"), Ok(Algorithm::PS384)));
-        assert!(matches!(parse_algorithm("PS512"), Ok(Algorithm::PS512)));
-        assert!(parse_algorithm("INVALID").is_err());
-    }
-
-    #[test]
-    fn test_claims_serialization() {
-        let claims = Claims {
-            sub: "user123".to_string(),
-            exp: 1234567890,
-            iat: Some(1234567800),
-            nbf: None,
-            aud: Some(vec!["https://api.example.com".to_string()]),
-            iss: Some("https://auth.example.com".to_string()),
-        };
-
-        let json = serde_json::to_string(&claims).unwrap();
-        assert!(json.contains("user123"));
-        assert!(json.contains("1234567890"));
-    }
-
-    #[test]
-    fn test_extract_api_key_from_query_api_key() {
-        let uri: axum::http::Uri = "/api/endpoint?api_key=secret123".parse().unwrap();
-        let result = extract_api_key_from_query(&uri);
-        assert_eq!(result, Some("secret123"));
-    }
-
-    #[test]
-    fn test_extract_api_key_from_query_api_key_camel_case() {
-        let uri: axum::http::Uri = "/api/endpoint?apiKey=mykey456".parse().unwrap();
-        let result = extract_api_key_from_query(&uri);
-        assert_eq!(result, Some("mykey456"));
-    }
-
-    #[test]
-    fn test_extract_api_key_from_query_key() {
-        let uri: axum::http::Uri = "/api/endpoint?key=testkey789".parse().unwrap();
-        let result = extract_api_key_from_query(&uri);
-        assert_eq!(result, Some("testkey789"));
-    }
-
-    #[test]
-    fn test_extract_api_key_from_query_no_key() {
-        let uri: axum::http::Uri = "/api/endpoint?foo=bar&baz=qux".parse().unwrap();
-        let result = extract_api_key_from_query(&uri);
-        assert_eq!(result, None);
-    }
-
-    #[test]
-    fn test_extract_api_key_from_query_empty_string() {
-        let uri: axum::http::Uri = "/api/endpoint".parse().unwrap();
-        let result = extract_api_key_from_query(&uri);
-        assert_eq!(result, None);
-    }
-
-    #[test]
-    fn test_extract_api_key_from_query_multiple_params() {
-        let uri: axum::http::Uri = "/api/endpoint?foo=bar&api_key=found&baz=qux".parse().unwrap();
-        let result = extract_api_key_from_query(&uri);
-        assert_eq!(result, Some("found"));
-    }
-}