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![],
};
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![],
};
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),
};
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);
}
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![],
});
}
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 {
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, "post" => 0.7, "put" => 0.6, "delete" => 0.5, _ => 0.8,
},
frequency: 1.0 + complexity, 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();
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(),
});
}
}
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> {
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
}
}