relay-knowledge 1.1.17

Graph-database-based knowledge graph project.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use std::collections::{BTreeMap, BTreeSet};

use crate::domain::CodebaseViewSnapshot;

use super::{
    builder::{SectionRefs, ViewBuilder},
    rules::{domain_confidence, domain_token, path_domain, route_domain},
};

pub(super) fn derive_business_domains(builder: &mut ViewBuilder, snapshot: &CodebaseViewSnapshot) {
    let mut domains = BTreeMap::<String, Vec<String>>::new();
    let mut labels = BTreeMap::new();
    let mut declared = BTreeSet::new();
    for domain in &snapshot.declared_business_domains {
        let evidence_id = builder.evidence(
            "business_glossary",
            &domain.source_path,
            Some(domain.id.clone()),
            None,
            Some("declared_domain".to_owned()),
            format!("authored business domain evidence {}", domain.evidence_id),
        );
        labels.insert(domain.id.clone(), domain.name.clone());
        declared.insert(domain.id.clone());
        domains
            .entry(domain.id.clone())
            .or_default()
            .push(evidence_id);
    }
    for route in &snapshot.routes {
        if let Some(domain) = route_domain(&route.url) {
            let evidence_id = builder.evidence(
                "route",
                &route.path,
                Some(route.handler_name.clone()),
                Some(route.line_range.clone()),
                Some(route.http_method.clone()),
                format!("{} {}", route.http_method, route.url),
            );
            domains.entry(domain).or_default().push(evidence_id);
        }
    }
    for flag in &snapshot.feature_flags {
        if let Some(domain) = domain_token(&flag.name) {
            let evidence_id = builder.evidence(
                "feature_flag",
                &flag.path,
                Some(flag.name.clone()),
                Some(flag.line_range.clone()),
                Some(flag.edge_kind.clone()),
                format!("feature flag {}", flag.source_key),
            );
            domains.entry(domain).or_default().push(evidence_id);
        }
    }
    for file in &snapshot.files {
        if let Some(domain) = path_domain(&file.path) {
            let evidence_id = builder.evidence(
                "path",
                &file.path,
                None,
                None,
                None,
                "domain-like path segment",
            );
            domains.entry(domain).or_default().push(evidence_id);
        }
    }
    let mut ordered = domains.into_iter().collect::<Vec<_>>();
    ordered.sort_by(|left, right| right.1.len().cmp(&left.1.len()).then(left.0.cmp(&right.0)));
    if ordered.len() > builder.limit {
        builder.mark_node_budget_truncated();
    }
    for (domain, evidence_ids) in ordered.into_iter().take(builder.limit) {
        let is_declared = declared.contains(&domain);
        let confidence = if is_declared {
            1.0
        } else {
            domain_confidence(evidence_ids.len())
        };
        let label = labels
            .get(&domain)
            .cloned()
            .unwrap_or_else(|| domain.clone());
        let node_id = builder.node(
            format!("domain:{domain}"),
            label.clone(),
            "business_domain",
            None,
            confidence,
            evidence_ids.first().cloned(),
        );
        builder.section(
            format!("section:domain:{domain}"),
            format!("{label} domain"),
            if is_declared {
                format!("{label} is declared by the repository business glossary and reinforced by {} total evidence signal(s).", evidence_ids.len())
            } else {
                format!("{label} is a candidate business domain from {} route, feature flag, or path signal(s).", evidence_ids.len())
            },
            confidence,
            SectionRefs {
                node_ids: node_id.into_iter().collect(),
                evidence_ids,
                ..SectionRefs::default()
            },
        );
    }
}