st/inputs/

openapi.rs

//! OpenAPI/Swagger specification input adapter
//!
//! Transforms API specs into navigable context trees

use super::*;
use anyhow::Result;
use async_trait::async_trait;
use serde_json;

pub struct OpenApiAdapter;

#[async_trait]
impl InputAdapter for OpenApiAdapter {
    fn name(&self) -> &'static str {
        "OpenAPI"
    }

    fn supported_formats(&self) -> Vec<&'static str> {
        vec!["openapi", "swagger", "oas", "api"]
    }

    async fn can_handle(&self, input: &InputSource) -> bool {
        match input {
            InputSource::Path(path) => {
                if let Some(ext) = path.extension() {
                    let ext = ext.to_string_lossy().to_lowercase();
                    return ext == "yaml" || ext == "yml" || ext == "json";
                }
                false
            }
            InputSource::Url(url) => {
                url.contains("swagger") || url.contains("openapi") || url.ends_with("/api-docs")
            }
            InputSource::Raw { format_hint, .. } => format_hint
                .as_ref()
                .map(|h| h == "openapi" || h == "swagger")
                .unwrap_or(false),
            _ => false,
        }
    }

    async fn parse(&self, input: InputSource) -> Result<ContextNode> {
        let spec = match input {
            InputSource::Path(path) => {
                let content = std::fs::read_to_string(&path)?;
                if path
                    .extension()
                    .map(|e| e == "yaml" || e == "yml")
                    .unwrap_or(false)
                {
                    serde_yaml::from_str(&content)?
                } else {
                    serde_json::from_str(&content)?
                }
            }
            InputSource::Url(url) => {
                let response = reqwest::get(url).await?;
                response.json::<serde_json::Value>().await?
            }
            InputSource::Raw { data, .. } => serde_json::from_slice(&data)?,
            _ => anyhow::bail!("Invalid input for OpenAPI adapter"),
        };

        self.parse_openapi_spec(&spec)
    }
}

impl OpenApiAdapter {
    fn parse_openapi_spec(&self, spec: &serde_json::Value) -> Result<ContextNode> {
        let title = spec
            .get("info")
            .and_then(|i| i.get("title"))
            .and_then(|t| t.as_str())
            .unwrap_or("API");

        let version = spec
            .get("info")
            .and_then(|i| i.get("version"))
            .and_then(|v| v.as_str())
            .unwrap_or("1.0.0");

        let mut root = ContextNode {
            id: "api_root".to_string(),
            name: format!("{} v{}", title, version),
            node_type: NodeType::ApiSchema,
            quantum_state: None,
            children: vec![],
            metadata: spec.get("info").cloned().unwrap_or_default(),
            entanglements: vec![],
        };

        // Parse paths
        if let Some(paths) = spec.get("paths").and_then(|p| p.as_object()) {
            let mut path_nodes = Vec::new();

            for (path, methods) in paths {
                let mut path_node = ContextNode {
                    id: path.clone(),
                    name: path.clone(),
                    node_type: NodeType::ApiEndpoint,
                    quantum_state: None,
                    children: vec![],
                    metadata: serde_json::json!({}),
                    entanglements: vec![],
                };

                // Parse methods
                if let Some(methods_obj) = methods.as_object() {
                    for (method, details) in methods_obj {
                        if ["get", "post", "put", "delete", "patch", "head", "options"]
                            .contains(&method.as_str())
                        {
                            let operation_id = details
                                .get("operationId")
                                .and_then(|o| o.as_str())
                                .unwrap_or(method);

                            let mut method_node = ContextNode {
                                id: format!("{}_{}", path, method),
                                name: format!("{} {}", method.to_uppercase(), operation_id),
                                node_type: NodeType::ApiEndpoint,
                                quantum_state: Some(
                                    self.calculate_endpoint_quantum_state(method, details),
                                ),
                                children: vec![],
                                metadata: details.clone(),
                                entanglements: self
                                    .find_endpoint_entanglements(path, method, details),
                            };

                            // Add parameter nodes
                            if let Some(params) =
                                details.get("parameters").and_then(|p| p.as_array())
                            {
                                for param in params {
                                    let param_name = param
                                        .get("name")
                                        .and_then(|n| n.as_str())
                                        .unwrap_or("param");

                                    method_node.children.push(ContextNode {
                                        id: format!("{}_{}_{}", path, method, param_name),
                                        name: format!("param: {}", param_name),
                                        node_type: NodeType::ApiSchema,
                                        quantum_state: None,
                                        children: vec![],
                                        metadata: param.clone(),
                                        entanglements: vec![],
                                    });
                                }
                            }

                            path_node.children.push(method_node);
                        }
                    }
                }

                path_nodes.push(path_node);
            }

            // Group by path segments
            root.children.push(ContextNode {
                id: "endpoints".to_string(),
                name: "Endpoints".to_string(),
                node_type: NodeType::Directory,
                quantum_state: None,
                children: self.organize_by_path_segments(path_nodes),
                metadata: serde_json::json!({}),
                entanglements: vec![],
            });
        }

        // Parse schemas/components
        if let Some(components) = spec.get("components").or_else(|| spec.get("definitions")) {
            root.children.push(self.parse_schemas(components)?);
        }

        Ok(root)
    }

    fn calculate_endpoint_quantum_state(
        &self,
        method: &str,
        details: &serde_json::Value,
    ) -> QuantumState {
        // Calculate quantum properties based on endpoint characteristics
        let complexity = details
            .get("parameters")
            .and_then(|p| p.as_array())
            .map(|a| a.len())
            .unwrap_or(0) as f64;

        let has_security = details.get("security").is_some();

        QuantumState {
            amplitude: match method {
                "get" => 0.9,    // READ operations are stable
                "post" => 0.7,   // CREATE operations
                "put" => 0.6,    // UPDATE operations
                "delete" => 0.5, // DELETE operations are disruptive
                _ => 0.8,
            },
            frequency: 1.0 + complexity, // More params = higher frequency
            phase: if has_security {
                std::f64::consts::PI / 2.0
            } else {
                0.0
            },
            collapse_probability: if method == "delete" { 0.9 } else { 0.3 },
        }
    }

    fn find_endpoint_entanglements(
        &self,
        path: &str,
        _method: &str,
        details: &serde_json::Value,
    ) -> Vec<Entanglement> {
        let mut entanglements = Vec::new();

        // Find schema references
        if let Some(schema_ref) = details
            .get("requestBody")
            .and_then(|r| r.get("content"))
            .and_then(|c| c.get("application/json"))
            .and_then(|j| j.get("schema"))
            .and_then(|s| s.get("$ref"))
            .and_then(|r| r.as_str())
        {
            if let Some(schema_name) = schema_ref.split('/').next_back() {
                entanglements.push(Entanglement {
                    target_id: format!("schema_{}", schema_name),
                    strength: 0.9,
                    relationship: "uses_schema".to_string(),
                });
            }
        }

        // Find related endpoints (same resource)
        let resource = path.split('/').nth(1).unwrap_or("");
        if !resource.is_empty() {
            entanglements.push(Entanglement {
                target_id: format!("resource_{}", resource),
                strength: 0.7,
                relationship: "same_resource".to_string(),
            });
        }

        entanglements
    }

    fn organize_by_path_segments(&self, paths: Vec<ContextNode>) -> Vec<ContextNode> {
        // For simplicity, return as-is
        // In real implementation, would group by common path prefixes
        paths
    }

    fn parse_schemas(&self, components: &serde_json::Value) -> Result<ContextNode> {
        let mut schemas_node = ContextNode {
            id: "schemas".to_string(),
            name: "Schemas".to_string(),
            node_type: NodeType::Directory,
            quantum_state: None,
            children: vec![],
            metadata: serde_json::json!({}),
            entanglements: vec![],
        };

        if let Some(schemas) = components.get("schemas").and_then(|s| s.as_object()) {
            for (name, schema) in schemas {
                schemas_node.children.push(ContextNode {
                    id: format!("schema_{}", name),
                    name: name.clone(),
                    node_type: NodeType::ApiSchema,
                    quantum_state: None,
                    children: self.parse_schema_properties(schema),
                    metadata: schema.clone(),
                    entanglements: vec![],
                });
            }
        }

        Ok(schemas_node)
    }

    fn parse_schema_properties(&self, schema: &serde_json::Value) -> Vec<ContextNode> {
        let mut props = Vec::new();

        if let Some(properties) = schema.get("properties").and_then(|p| p.as_object()) {
            for (prop_name, prop_schema) in properties {
                props.push(ContextNode {
                    id: format!("prop_{}", prop_name),
                    name: prop_name.clone(),
                    node_type: NodeType::ApiSchema,
                    quantum_state: None,
                    children: vec![],
                    metadata: prop_schema.clone(),
                    entanglements: vec![],
                });
            }
        }

        props
    }
}