spikard 0.2.1 → 0.2.5

data/vendor/crates/spikard-http/src/openapi/parameter_extraction.rs

@@ -0,0 +1,190 @@
+//! Parameter extraction from routes and schemas for OpenAPI generation
+
+use utoipa::openapi::RefOr;
+use utoipa::openapi::path::Parameter;
+use utoipa::openapi::path::{ParameterBuilder, ParameterIn};
+
+/// Extract parameters from JSON Schema parameter_schema
+pub fn extract_parameters_from_schema(
+    param_schema: &serde_json::Value,
+    route_path: &str,
+) -> Result<Vec<RefOr<Parameter>>, String> {
+    let mut parameters = Vec::new();
+
+    let path_params = extract_path_param_names(route_path);
+
+    let properties = param_schema
+        .get("properties")
+        .and_then(|p| p.as_object())
+        .ok_or_else(|| "Parameter schema missing 'properties' field".to_string())?;
+
+    let required = param_schema
+        .get("required")
+        .and_then(|r| r.as_array())
+        .map(|arr| arr.iter().filter_map(|v| v.as_str()).collect::<Vec<_>>())
+        .unwrap_or_default();
+
+    for (name, schema) in properties {
+        let is_required = required.contains(&name.as_str());
+        let param_in = if path_params.contains(&name.as_str()) {
+            ParameterIn::Path
+        } else {
+            ParameterIn::Query
+        };
+
+        let openapi_schema = crate::openapi::schema_conversion::json_value_to_schema(schema)?;
+
+        let is_path_param = matches!(param_in, ParameterIn::Path);
+
+        let param = ParameterBuilder::new()
+            .name(name)
+            .parameter_in(param_in)
+            .required(if is_path_param || is_required {
+                utoipa::openapi::Required::True
+            } else {
+                utoipa::openapi::Required::False
+            })
+            .schema(Some(openapi_schema))
+            .build();
+
+        parameters.push(RefOr::T(param));
+    }
+
+    Ok(parameters)
+}
+
+/// Extract path parameter names from route pattern (e.g., "/users/{id}" -> ["id"])
+pub fn extract_path_param_names(route: &str) -> Vec<&str> {
+    route
+        .split('/')
+        .filter_map(|segment| {
+            if segment.starts_with('{') && segment.ends_with('}') {
+                Some(&segment[1..segment.len() - 1])
+            } else {
+                None
+            }
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn test_extract_path_param_names() {
+        let names = extract_path_param_names("/users/{id}/posts/{post_id}");
+        assert_eq!(names, vec!["id", "post_id"]);
+
+        let names = extract_path_param_names("/users");
+        assert_eq!(names, Vec::<&str>::new());
+
+        let names = extract_path_param_names("/users/{user_id}");
+        assert_eq!(names, vec!["user_id"]);
+    }
+
+    #[test]
+    fn test_extract_parameters_from_schema_path_params() {
+        let param_schema = json!({
+            "type": "object",
+            "properties": {
+                "user_id": { "type": "integer" },
+                "post_id": { "type": "integer" }
+            },
+            "required": ["user_id", "post_id"]
+        });
+
+        let result = extract_parameters_from_schema(&param_schema, "/users/{user_id}/posts/{post_id}");
+        assert!(result.is_ok());
+
+        let params = result.unwrap();
+        assert_eq!(params.len(), 2);
+
+        for param in params {
+            if let RefOr::T(p) = param {
+                assert!(matches!(p.parameter_in, ParameterIn::Path));
+                assert!(matches!(p.required, utoipa::openapi::Required::True));
+            }
+        }
+    }
+
+    #[test]
+    fn test_extract_parameters_from_schema_query_params() {
+        let param_schema = json!({
+            "type": "object",
+            "properties": {
+                "page": { "type": "integer" },
+                "limit": { "type": "integer" },
+                "search": { "type": "string" }
+            },
+            "required": ["page"]
+        });
+
+        let result = extract_parameters_from_schema(&param_schema, "/users");
+        assert!(result.is_ok());
+
+        let params = result.unwrap();
+        assert_eq!(params.len(), 3);
+
+        for param in &params {
+            if let RefOr::T(p) = param {
+                assert!(matches!(p.parameter_in, ParameterIn::Query));
+            }
+        }
+
+        for param in params {
+            if let RefOr::T(p) = param {
+                if p.name == "page" {
+                    assert!(matches!(p.required, utoipa::openapi::Required::True));
+                } else {
+                    assert!(matches!(p.required, utoipa::openapi::Required::False));
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_extract_parameters_from_schema_mixed() {
+        let param_schema = json!({
+            "type": "object",
+            "properties": {
+                "user_id": { "type": "integer" },
+                "page": { "type": "integer" },
+                "limit": { "type": "integer" }
+            },
+            "required": ["user_id"]
+        });
+
+        let result = extract_parameters_from_schema(&param_schema, "/users/{user_id}");
+        assert!(result.is_ok());
+
+        let params = result.unwrap();
+        assert_eq!(params.len(), 3);
+
+        for param in params {
+            if let RefOr::T(p) = param {
+                if p.name == "user_id" {
+                    assert!(matches!(p.parameter_in, ParameterIn::Path));
+                    assert!(matches!(p.required, utoipa::openapi::Required::True));
+                } else {
+                    assert!(matches!(p.parameter_in, ParameterIn::Query));
+                    assert!(matches!(p.required, utoipa::openapi::Required::False));
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_extract_parameters_error_on_missing_properties() {
+        let param_schema = json!({
+            "type": "object"
+        });
+
+        let result = extract_parameters_from_schema(&param_schema, "/users");
+        assert!(result.is_err());
+        if let Err(err) = result {
+            assert!(err.contains("properties"));
+        }
+    }
+}

data/vendor/crates/spikard-http/src/openapi/schema_conversion.rs

@@ -0,0 +1,308 @@
+//! JSON Schema to OpenAPI schema conversion utilities
+
+use utoipa::openapi::{RefOr, Schema};
+
+/// Convert serde_json::Value (JSON Schema) to utoipa Schema
+/// OpenAPI 3.1.0 is fully compatible with JSON Schema Draft 2020-12
+pub fn json_value_to_schema(value: &serde_json::Value) -> Result<RefOr<Schema>, String> {
+    if let Some(type_str) = value.get("type").and_then(|t| t.as_str()) {
+        match type_str {
+            "object" => {
+                let mut object_schema = utoipa::openapi::ObjectBuilder::new();
+
+                if let Some(properties) = value.get("properties").and_then(|p| p.as_object()) {
+                    for (prop_name, prop_schema) in properties {
+                        let prop_openapi_schema = json_value_to_schema(prop_schema)?;
+                        object_schema = object_schema.property(prop_name, prop_openapi_schema);
+                    }
+                }
+
+                if let Some(required) = value.get("required").and_then(|r| r.as_array()) {
+                    for field in required {
+                        if let Some(field_name) = field.as_str() {
+                            object_schema = object_schema.required(field_name);
+                        }
+                    }
+                }
+
+                Ok(RefOr::T(Schema::Object(object_schema.build())))
+            }
+            "array" => {
+                let mut array_schema = utoipa::openapi::ArrayBuilder::new();
+
+                if let Some(items) = value.get("items") {
+                    let items_schema = json_value_to_schema(items)?;
+                    array_schema = array_schema.items(items_schema);
+                }
+
+                Ok(RefOr::T(Schema::Array(array_schema.build())))
+            }
+            "string" => {
+                let mut schema_type = utoipa::openapi::schema::Type::String;
+
+                if let Some(format) = value.get("format").and_then(|f| f.as_str()) {
+                    match format {
+                        "date-time" => schema_type = utoipa::openapi::schema::Type::String,
+                        "date" => schema_type = utoipa::openapi::schema::Type::String,
+                        "email" => schema_type = utoipa::openapi::schema::Type::String,
+                        "uri" => schema_type = utoipa::openapi::schema::Type::String,
+                        _ => {}
+                    }
+                }
+
+                Ok(RefOr::T(Schema::Object(
+                    utoipa::openapi::ObjectBuilder::new().schema_type(schema_type).build(),
+                )))
+            }
+            "integer" => Ok(RefOr::T(Schema::Object(
+                utoipa::openapi::ObjectBuilder::new()
+                    .schema_type(utoipa::openapi::schema::Type::Integer)
+                    .build(),
+            ))),
+            "number" => Ok(RefOr::T(Schema::Object(
+                utoipa::openapi::ObjectBuilder::new()
+                    .schema_type(utoipa::openapi::schema::Type::Number)
+                    .build(),
+            ))),
+            "boolean" => Ok(RefOr::T(Schema::Object(
+                utoipa::openapi::ObjectBuilder::new()
+                    .schema_type(utoipa::openapi::schema::Type::Boolean)
+                    .build(),
+            ))),
+            _ => Err(format!("Unsupported schema type: {}", type_str)),
+        }
+    } else {
+        Ok(RefOr::T(Schema::Object(utoipa::openapi::ObjectBuilder::new().build())))
+    }
+}
+
+/// Convert JSON Schema to OpenAPI RequestBody
+pub fn json_schema_to_request_body(
+    schema: &serde_json::Value,
+) -> Result<utoipa::openapi::request_body::RequestBody, String> {
+    use utoipa::openapi::content::ContentBuilder;
+
+    let openapi_schema = json_value_to_schema(schema)?;
+
+    let content = ContentBuilder::new().schema(Some(openapi_schema)).build();
+
+    let mut request_body = utoipa::openapi::request_body::RequestBody::new();
+    request_body.content.insert("application/json".to_string(), content);
+
+    request_body.required = Some(utoipa::openapi::Required::True);
+
+    Ok(request_body)
+}
+
+/// Convert JSON Schema to OpenAPI Response
+pub fn json_schema_to_response(schema: &serde_json::Value) -> Result<utoipa::openapi::Response, String> {
+    use utoipa::openapi::content::ContentBuilder;
+
+    let openapi_schema = json_value_to_schema(schema)?;
+
+    let content = ContentBuilder::new().schema(Some(openapi_schema)).build();
+
+    let mut response = utoipa::openapi::Response::new("Successful response");
+    response.content.insert("application/json".to_string(), content);
+
+    Ok(response)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_json_value_to_schema_string() {
+        let schema_json = serde_json::json!({
+            "type": "string"
+        });
+
+        let result = json_value_to_schema(&schema_json);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_json_value_to_schema_integer() {
+        let schema_json = serde_json::json!({
+            "type": "integer"
+        });
+
+        let result = json_value_to_schema(&schema_json);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_json_value_to_schema_number() {
+        let schema_json = serde_json::json!({
+            "type": "number"
+        });
+
+        let result = json_value_to_schema(&schema_json);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_json_value_to_schema_boolean() {
+        let schema_json = serde_json::json!({
+            "type": "boolean"
+        });
+
+        let result = json_value_to_schema(&schema_json);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_json_value_to_schema_object() {
+        let schema_json = serde_json::json!({
+            "type": "object",
+            "properties": {
+                "name": { "type": "string" },
+                "age": { "type": "integer" }
+            },
+            "required": ["name"]
+        });
+
+        let result = json_value_to_schema(&schema_json);
+        assert!(result.is_ok());
+
+        if let Ok(RefOr::T(Schema::Object(obj))) = result {
+            assert!(obj.properties.contains_key("name"));
+            assert!(obj.properties.contains_key("age"));
+            assert!(obj.required.contains(&"name".to_string()));
+        } else {
+            panic!("Expected Object schema");
+        }
+    }
+
+    #[test]
+    fn test_json_value_to_schema_array() {
+        let schema_json = serde_json::json!({
+            "type": "array",
+            "items": {
+                "type": "string"
+            }
+        });
+
+        let result = json_value_to_schema(&schema_json);
+        assert!(result.is_ok());
+
+        if let Ok(RefOr::T(Schema::Array(_))) = result {
+        } else {
+            panic!("Expected Array schema");
+        }
+    }
+
+    #[test]
+    fn test_json_value_to_schema_nested_object() {
+        let schema_json = serde_json::json!({
+            "type": "object",
+            "properties": {
+                "user": {
+                    "type": "object",
+                    "properties": {
+                        "name": { "type": "string" },
+                        "email": { "type": "string" }
+                    }
+                }
+            }
+        });
+
+        let result = json_value_to_schema(&schema_json);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_json_schema_to_request_body() {
+        let schema_json = serde_json::json!({
+            "type": "object",
+            "properties": {
+                "title": { "type": "string" },
+                "count": { "type": "integer" }
+            },
+            "required": ["title"]
+        });
+
+        let result = json_schema_to_request_body(&schema_json);
+        assert!(result.is_ok());
+
+        let request_body = result.unwrap();
+        assert!(request_body.content.contains_key("application/json"));
+        assert!(matches!(request_body.required, Some(utoipa::openapi::Required::True)));
+    }
+
+    #[test]
+    fn test_json_schema_to_request_body_array() {
+        let schema_json = serde_json::json!({
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "id": { "type": "integer" }
+                }
+            }
+        });
+
+        let result = json_schema_to_request_body(&schema_json);
+        assert!(result.is_ok());
+
+        let request_body = result.unwrap();
+        assert!(request_body.content.contains_key("application/json"));
+    }
+
+    #[test]
+    fn test_json_schema_to_response() {
+        let schema_json = serde_json::json!({
+            "type": "object",
+            "properties": {
+                "id": { "type": "integer" },
+                "name": { "type": "string" }
+            }
+        });
+
+        let result = json_schema_to_response(&schema_json);
+        assert!(result.is_ok());
+
+        let response = result.unwrap();
+        assert!(response.content.contains_key("application/json"));
+        assert_eq!(response.description, "Successful response");
+    }
+
+    #[test]
+    fn test_json_schema_to_response_array() {
+        let schema_json = serde_json::json!({
+            "type": "array",
+            "items": {
+                "type": "string"
+            }
+        });
+
+        let result = json_schema_to_response(&schema_json);
+        assert!(result.is_ok());
+
+        let response = result.unwrap();
+        assert!(response.content.contains_key("application/json"));
+    }
+
+    #[test]
+    fn test_json_value_to_schema_string_with_format() {
+        let schema_json = serde_json::json!({
+            "type": "string",
+            "format": "date-time"
+        });
+
+        let result = json_value_to_schema(&schema_json);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_json_schema_to_request_body_empty_object() {
+        let schema_json = serde_json::json!({
+            "type": "object",
+            "properties": {}
+        });
+
+        let result = json_schema_to_request_body(&schema_json);
+        assert!(result.is_ok());
+    }
+}

data/vendor/crates/spikard-http/src/openapi/spec_generation.rs

@@ -0,0 +1,195 @@
+//! OpenAPI specification generation and assembly
+
+use crate::RouteMetadata;
+use utoipa::openapi::HttpMethod;
+use utoipa::openapi::security::SecurityScheme;
+use utoipa::openapi::{Components, Info, OpenApi, OpenApiBuilder, PathItem, Paths, RefOr, Response, Responses};
+
+/// Convert route to OpenAPI PathItem
+fn route_to_path_item(route: &RouteMetadata) -> Result<PathItem, String> {
+    let operation = route_to_operation(route)?;
+
+    let http_method = match route.method.to_uppercase().as_str() {
+        "GET" => HttpMethod::Get,
+        "POST" => HttpMethod::Post,
+        "PUT" => HttpMethod::Put,
+        "DELETE" => HttpMethod::Delete,
+        "PATCH" => HttpMethod::Patch,
+        "HEAD" => HttpMethod::Head,
+        "OPTIONS" => HttpMethod::Options,
+        _ => return Err(format!("Unsupported HTTP method: {}", route.method)),
+    };
+
+    let path_item = PathItem::new(http_method, operation);
+
+    Ok(path_item)
+}
+
+/// Convert route to OpenAPI Operation
+fn route_to_operation(route: &RouteMetadata) -> Result<utoipa::openapi::path::Operation, String> {
+    let mut operation = utoipa::openapi::path::Operation::new();
+
+    if let Some(param_schema) = &route.parameter_schema {
+        let parameters =
+            crate::openapi::parameter_extraction::extract_parameters_from_schema(param_schema, &route.path)?;
+        if !parameters.is_empty() {
+            let unwrapped: Vec<_> = parameters
+                .into_iter()
+                .filter_map(|p| if let RefOr::T(param) = p { Some(param) } else { None })
+                .collect();
+            operation.parameters = Some(unwrapped);
+        }
+    }
+
+    if let Some(request_schema) = &route.request_schema {
+        let request_body = crate::openapi::schema_conversion::json_schema_to_request_body(request_schema)?;
+        operation.request_body = Some(request_body);
+    }
+
+    let mut responses = Responses::new();
+    if let Some(response_schema) = &route.response_schema {
+        let response = crate::openapi::schema_conversion::json_schema_to_response(response_schema)?;
+        responses.responses.insert("200".to_string(), RefOr::T(response));
+    } else {
+        responses
+            .responses
+            .insert("200".to_string(), RefOr::T(Response::new("Successful response")));
+    }
+    operation.responses = responses;
+
+    Ok(operation)
+}
+
+/// Assemble OpenAPI specification from routes with auto-detection of security schemes
+pub fn assemble_openapi_spec(
+    routes: &[RouteMetadata],
+    config: &super::OpenApiConfig,
+    server_config: Option<&crate::ServerConfig>,
+) -> Result<OpenApi, String> {
+    let mut info = Info::new(&config.title, &config.version);
+    if let Some(desc) = &config.description {
+        info.description = Some(desc.clone());
+    }
+    if let Some(contact_info) = &config.contact {
+        let mut contact = utoipa::openapi::Contact::default();
+        if let Some(name) = &contact_info.name {
+            contact.name = Some(name.clone());
+        }
+        if let Some(email) = &contact_info.email {
+            contact.email = Some(email.clone());
+        }
+        if let Some(url) = &contact_info.url {
+            contact.url = Some(url.clone());
+        }
+        info.contact = Some(contact);
+    }
+    if let Some(license_info) = &config.license {
+        let mut license = utoipa::openapi::License::new(&license_info.name);
+        if let Some(url) = &license_info.url {
+            license.url = Some(url.clone());
+        }
+        info.license = Some(license);
+    }
+
+    let servers = if config.servers.is_empty() {
+        None
+    } else {
+        Some(
+            config
+                .servers
+                .iter()
+                .map(|s| {
+                    let mut server = utoipa::openapi::Server::new(&s.url);
+                    if let Some(desc) = &s.description {
+                        server.description = Some(desc.clone());
+                    }
+                    server
+                })
+                .collect(),
+        )
+    };
+
+    let mut paths = Paths::new();
+    for route in routes {
+        let path_item = route_to_path_item(route)?;
+        paths.paths.insert(route.path.clone(), path_item);
+    }
+
+    let mut components = Components::new();
+    let mut global_security = Vec::new();
+
+    if let Some(server_cfg) = server_config {
+        if let Some(_jwt_cfg) = &server_cfg.jwt_auth {
+            let jwt_scheme = SecurityScheme::Http(
+                utoipa::openapi::security::HttpBuilder::new()
+                    .scheme(utoipa::openapi::security::HttpAuthScheme::Bearer)
+                    .bearer_format("JWT")
+                    .build(),
+            );
+            components.add_security_scheme("bearerAuth", jwt_scheme);
+
+            let security_req = utoipa::openapi::security::SecurityRequirement::new("bearerAuth", Vec::<String>::new());
+            global_security.push(security_req);
+        }
+
+        if let Some(api_key_cfg) = &server_cfg.api_key_auth {
+            use utoipa::openapi::security::ApiKey;
+            let api_key_scheme = SecurityScheme::ApiKey(ApiKey::Header(utoipa::openapi::security::ApiKeyValue::new(
+                &api_key_cfg.header_name,
+            )));
+            components.add_security_scheme("apiKeyAuth", api_key_scheme);
+
+            let security_req = utoipa::openapi::security::SecurityRequirement::new("apiKeyAuth", Vec::<String>::new());
+            global_security.push(security_req);
+        }
+    }
+
+    if !config.security_schemes.is_empty() {
+        for (name, scheme_info) in &config.security_schemes {
+            let scheme = crate::openapi::security_scheme_info_to_openapi(scheme_info);
+            components.add_security_scheme(name, scheme);
+        }
+    }
+
+    let mut openapi = OpenApiBuilder::new()
+        .info(info)
+        .paths(paths)
+        .components(Some(components))
+        .build();
+
+    if let Some(servers) = servers {
+        openapi.servers = Some(servers);
+    }
+
+    if !global_security.is_empty() {
+        openapi.security = Some(global_security);
+    }
+
+    Ok(openapi)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_route_to_path_item_get() {
+        let route = RouteMetadata {
+            method: "GET".to_string(),
+            path: "/users".to_string(),
+            handler_name: "list_users".to_string(),
+            request_schema: None,
+            response_schema: None,
+            parameter_schema: None,
+            file_params: None,
+            is_async: true,
+            cors: None,
+            body_param_name: None,
+            #[cfg(feature = "di")]
+            handler_dependencies: None,
+        };
+
+        let result = route_to_path_item(&route);
+        assert!(result.is_ok());
+    }
+}

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

@@ -0,0 +1 @@
+pub use spikard_core::parameters::*;

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

@@ -0,0 +1 @@
+pub use spikard_core::problem::*;