pub mod dependencies;
pub mod env;
pub mod version;
use std::collections::BTreeMap;
use std::path::Path;
use serde::{Deserialize, Serialize};
use crate::models::Language;
pub use self::dependencies::ManifestInfo;
#[allow(unused_imports)]
pub use self::env::{ConnectionMatch, InfraScanResult};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct DirectoryAnalysis {
pub manifest: ManifestInfo,
pub runtime_version: Option<String>,
pub env_vars: BTreeMap<String, String>,
pub infra_scan: InfraScanResult,
}
pub fn analyze_directory(dir_path: &Path, language: &Language) -> DirectoryAnalysis {
let manifest = analyze_manifests(dir_path);
let runtime_version = extract_version(dir_path, language);
let env_vars = analyze_env_files(dir_path);
let infra_scan = env::detect_infra_connections(&env_vars);
DirectoryAnalysis {
manifest,
runtime_version,
env_vars,
infra_scan,
}
}
pub fn analyze_manifests(dir_path: &Path) -> ManifestInfo {
dependencies::parse_directory_manifests(dir_path)
}
pub fn extract_version(dir_path: &Path, language: &Language) -> Option<String> {
version::extract_runtime_version(dir_path, language)
}
pub fn analyze_env_files(dir_path: &Path) -> BTreeMap<String, String> {
env::parse_env_files(dir_path)
}
pub fn scan_project_env_infra(dir_path: &Path) -> InfraScanResult {
let env = env::parse_env_files(dir_path);
env::detect_infra_connections(&env)
}
#[cfg(test)]
mod tests {
use super::*;
use std::fs;
use tempfile::TempDir;
fn create_file(dir: &Path, name: &str, content: &str) {
fs::write(dir.join(name), content).expect("failed to create test file");
}
#[test]
fn analyze_manifests_package_json() {
let tmp = TempDir::new().unwrap();
let root = tmp.path();
create_file(
root,
"package.json",
r#"{"name":"my-api","dependencies":{"express":"^4.18.0"},"devDependencies":{"jest":"^29.0"}}"#,
);
let info = analyze_manifests(root);
assert_eq!(info.package_name.as_deref(), Some("my-api"));
assert!(info.dependencies.contains(&"express".to_string()));
assert!(info.dev_dependencies.contains(&"jest".to_string()));
}
#[test]
fn analyze_manifests_empty_dir() {
let tmp = TempDir::new().unwrap();
let info = analyze_manifests(tmp.path());
assert!(info.package_name.is_none());
assert!(info.dependencies.is_empty());
}
#[test]
fn extract_version_node_nvmrc() {
let tmp = TempDir::new().unwrap();
create_file(tmp.path(), ".nvmrc", "20.11.0\n");
let version = extract_version(tmp.path(), &Language::NodeJs);
assert_eq!(version.as_deref(), Some("20"));
}
#[test]
fn extract_version_python_version_file() {
let tmp = TempDir::new().unwrap();
create_file(tmp.path(), ".python-version", "3.12.1\n");
let version = extract_version(tmp.path(), &Language::Python);
assert_eq!(version.as_deref(), Some("3.12"));
}
#[test]
fn extract_version_no_file_returns_none() {
let tmp = TempDir::new().unwrap();
let version = extract_version(tmp.path(), &Language::NodeJs);
assert!(version.is_none());
}
#[test]
fn extract_version_unknown_language_returns_none() {
let tmp = TempDir::new().unwrap();
create_file(tmp.path(), ".nvmrc", "20\n");
let version = extract_version(tmp.path(), &Language::Unknown("zig".into()));
assert!(version.is_none());
}
#[test]
fn analyze_env_files_priority_local_overrides_env() {
let tmp = TempDir::new().unwrap();
let root = tmp.path();
create_file(root, ".env", "FOO=base\nBAR=from_env\n");
create_file(root, ".env.local", "FOO=local_override\n");
let env = analyze_env_files(root);
assert_eq!(env.get("FOO").map(|s| s.as_str()), Some("local_override"));
assert_eq!(env.get("BAR").map(|s| s.as_str()), Some("from_env"));
}
#[test]
fn analyze_env_files_empty_dir() {
let tmp = TempDir::new().unwrap();
let env = analyze_env_files(tmp.path());
assert!(env.is_empty());
}
#[test]
fn analyze_env_files_deterministic_order() {
let tmp = TempDir::new().unwrap();
let root = tmp.path();
create_file(root, ".env", "Z=1\nA=2\nM=3\n");
let env = analyze_env_files(root);
let keys: Vec<&String> = env.keys().collect();
let mut sorted = keys.clone();
sorted.sort();
assert_eq!(keys, sorted);
}
#[test]
fn scan_project_env_infra_detects_postgres() {
let tmp = TempDir::new().unwrap();
create_file(
tmp.path(),
".env",
"DATABASE_URL=postgres://user:pass@localhost:5432/mydb\n",
);
let result = scan_project_env_infra(tmp.path());
assert!(
!result.url_matches.is_empty(),
"expected at least one URL match"
);
let pg = result
.url_matches
.iter()
.find(|m| m.variable == "DATABASE_URL");
assert!(pg.is_some(), "expected DATABASE_URL match");
assert_eq!(pg.unwrap().scheme, "postgres://");
}
#[test]
fn scan_project_env_infra_known_keys() {
let tmp = TempDir::new().unwrap();
create_file(tmp.path(), ".env", "REDIS_HOST=localhost\n");
let result = scan_project_env_infra(tmp.path());
assert!(
result.known_infra_keys.contains(&"REDIS_HOST".to_string()),
"expected REDIS_HOST in known keys"
);
}
#[test]
fn scan_project_env_infra_empty_dir() {
let tmp = TempDir::new().unwrap();
let result = scan_project_env_infra(tmp.path());
assert!(result.url_matches.is_empty());
assert!(result.known_infra_keys.is_empty());
}
#[test]
fn analyze_directory_full_project() {
let tmp = TempDir::new().unwrap();
let root = tmp.path();
create_file(
root,
"package.json",
r#"{"name":"full-app","scripts":{"start":"node index.js"}}"#,
);
create_file(root, "index.js", "console.log('hello');\n");
create_file(root, ".nvmrc", "20\n");
create_file(root, ".env", "DATABASE_URL=postgres://localhost/app\n");
let analysis = analyze_directory(root, &Language::NodeJs);
assert_eq!(analysis.manifest.package_name.as_deref(), Some("full-app"));
assert_eq!(analysis.runtime_version.as_deref(), Some("20"));
assert!(analysis.env_vars.contains_key("DATABASE_URL"));
assert!(!analysis.infra_scan.url_matches.is_empty());
assert!(analysis
.infra_scan
.url_matches
.iter()
.any(|m| m.variable == "DATABASE_URL"));
}
#[test]
fn analyze_directory_empty_dir_returns_safe_defaults() {
let tmp = TempDir::new().unwrap();
let root = tmp.path();
let analysis = analyze_directory(root, &Language::NodeJs);
assert!(analysis.manifest.package_name.is_none());
assert!(analysis.manifest.dependencies.is_empty());
assert!(analysis.runtime_version.is_none());
assert!(analysis.env_vars.is_empty());
assert!(analysis.infra_scan.url_matches.is_empty());
assert!(analysis.infra_scan.known_infra_keys.is_empty());
}
#[test]
fn analyze_directory_reuses_env_for_infra() {
let tmp = TempDir::new().unwrap();
let root = tmp.path();
create_file(
root,
".env",
"DATABASE_URL=postgres://localhost/app\nREDIS_HOST=localhost\n",
);
let analysis = analyze_directory(root, &Language::NodeJs);
assert!(analysis.env_vars.contains_key("DATABASE_URL"));
assert!(analysis.env_vars.contains_key("REDIS_HOST"));
assert!(analysis
.infra_scan
.url_matches
.iter()
.any(|m| m.variable == "DATABASE_URL"));
assert!(analysis
.infra_scan
.known_infra_keys
.contains(&"REDIS_HOST".to_string()));
}
#[test]
fn directory_analysis_serde_roundtrip() {
let mut env_vars = BTreeMap::new();
env_vars.insert("DATABASE_URL".into(), "postgres://localhost/app".into());
let analysis = DirectoryAnalysis {
manifest: ManifestInfo {
package_name: Some("test-app".into()),
dependencies: vec!["express".into()],
dev_dependencies: vec!["jest".into()],
scripts: std::collections::HashMap::from([(
"start".into(),
"node index.js".into(),
)]),
entrypoint: Some("index.js".into()),
raw_content: std::collections::HashMap::new(),
},
runtime_version: Some("20".into()),
env_vars,
infra_scan: InfraScanResult {
url_matches: vec![ConnectionMatch {
variable: "DATABASE_URL".into(),
scheme: "postgres://".into(),
value: "postgres://localhost/app".into(),
}],
known_infra_keys: vec![],
},
};
let json = serde_json::to_string(&analysis).unwrap();
let deserialized: DirectoryAnalysis = serde_json::from_str(&json).unwrap();
assert_eq!(analysis, deserialized);
}
}