Skip to main content

kernel/graph/
import_records.rs

1// Copyright 2026 Mark AB (markik)
2// SPDX-License-Identifier: MIT OR Apache-2.0
3
4//! Import-record operations.
5//!
6//! Manages the durable `import_records` truth on `Graph`: queries,
7//! membership suppression, replacement, and the two private helpers
8//! that sync between `import_records` and per-node
9//! `NodeImportProvenance` (`sync_node_import_provenance_from_records`
10//! / `rebuild_import_records_from_node_provenance`).
11//!
12//! Also includes `set_node_import_provenance` because it triggers a
13//! rebuild and naturally lives with its sibling import-record
14//! plumbing.
15//!
16//! Extracted from `graph/mod.rs` per the 2026-05-11 kernel
17//! decomposition pass.
18
19use std::collections::{BTreeMap, HashMap};
20
21use uuid::Uuid;
22
23use super::identity::NodeKey;
24use super::{Graph, current_unix_timestamp_secs, normalize_import_records};
25use crate::types::{
26    ImportRecord, ImportRecordMembership, NodeImportProvenance, NodeImportRecordSummary,
27};
28
29impl Graph {
30    pub fn import_records(&self) -> &[ImportRecord] {
31        &self.import_records
32    }
33
34    pub fn import_record_summaries_for_node(&self, key: NodeKey) -> Vec<NodeImportRecordSummary> {
35        let Some(node) = self.get_node(key) else {
36            return Vec::new();
37        };
38        let node_id = node.id.to_string();
39        let mut summaries = self
40            .import_records
41            .iter()
42            .filter(|record| {
43                record
44                    .memberships
45                    .iter()
46                    .any(|membership| membership.node_id == node_id && !membership.suppressed)
47            })
48            .map(|record| NodeImportRecordSummary {
49                record_id: record.record_id.clone(),
50                source_id: record.source_id.clone(),
51                source_label: record.source_label.clone(),
52                imported_at_secs: record.imported_at_secs,
53            })
54            .collect::<Vec<_>>();
55        summaries.sort_by(|left, right| {
56            right
57                .imported_at_secs
58                .cmp(&left.imported_at_secs)
59                .then_with(|| left.source_label.cmp(&right.source_label))
60                .then_with(|| left.record_id.cmp(&right.record_id))
61        });
62        summaries
63    }
64
65    pub fn import_record_member_keys(&self, record_id: &str) -> Vec<NodeKey> {
66        let mut member_keys = self
67            .import_records
68            .iter()
69            .find(|record| record.record_id == record_id)
70            .into_iter()
71            .flat_map(|record| record.memberships.iter())
72            .filter(|membership| !membership.suppressed)
73            .filter_map(|membership| Uuid::parse_str(&membership.node_id).ok())
74            .filter_map(|node_id| self.inner.key_of(&node_id))
75            .collect::<Vec<_>>();
76        member_keys.sort_by_key(|key| key.index());
77        member_keys.dedup();
78        member_keys
79    }
80
81    pub(crate) fn delete_import_record(&mut self, record_id: &str) -> bool {
82        let original_len = self.import_records.len();
83        self.import_records
84            .retain(|record| record.record_id != record_id);
85        if self.import_records.len() == original_len {
86            return false;
87        }
88        self.sync_node_import_provenance_from_records();
89        true
90    }
91
92    pub(crate) fn set_import_record_membership_suppressed(
93        &mut self,
94        record_id: &str,
95        key: NodeKey,
96        suppressed: bool,
97    ) -> bool {
98        let Some(node_id) = self.get_node(key).map(|node| node.id.to_string()) else {
99            return false;
100        };
101        let mut changed = false;
102        for record in &mut self.import_records {
103            if record.record_id != record_id {
104                continue;
105            }
106            for membership in &mut record.memberships {
107                if membership.node_id == node_id {
108                    if membership.suppressed != suppressed {
109                        membership.suppressed = suppressed;
110                        changed = true;
111                    }
112                    break;
113                }
114            }
115        }
116        if changed {
117            self.sync_node_import_provenance_from_records();
118        }
119        changed
120    }
121
122    pub(crate) fn set_import_records(&mut self, mut import_records: Vec<ImportRecord>) -> bool {
123        normalize_import_records(&mut import_records);
124        if self.import_records == import_records {
125            return false;
126        }
127        self.import_records = import_records;
128        self.sync_node_import_provenance_from_records();
129        true
130    }
131
132    pub(crate) fn sync_node_import_provenance_from_records(&mut self) {
133        let mut provenance_by_node = HashMap::<NodeKey, Vec<NodeImportProvenance>>::new();
134        for record in &self.import_records {
135            for membership in record
136                .memberships
137                .iter()
138                .filter(|membership| !membership.suppressed)
139            {
140                let Ok(node_id) = Uuid::parse_str(&membership.node_id) else {
141                    continue;
142                };
143                let Some(node_key) = self.inner.key_of(&node_id) else {
144                    continue;
145                };
146                provenance_by_node
147                    .entry(node_key)
148                    .or_default()
149                    .push(NodeImportProvenance {
150                        source_id: record.source_id.clone(),
151                        source_label: record.source_label.clone(),
152                    });
153            }
154        }
155
156        let node_keys = self.inner.inner().node_indices().collect::<Vec<_>>();
157        for node_key in node_keys {
158            let mut provenance = provenance_by_node.remove(&node_key).unwrap_or_default();
159            provenance.sort();
160            provenance.dedup();
161            self.set_node_facet(node_key, super::node_facets::PROVENANCE_IMPORT, &provenance);
162        }
163    }
164
165    pub(crate) fn rebuild_import_records_from_node_provenance(&mut self, imported_at_secs: u64) {
166        let existing_record_meta = self
167            .import_records
168            .iter()
169            .map(|record| {
170                (
171                    (record.source_id.clone(), record.source_label.clone()),
172                    (record.record_id.clone(), record.imported_at_secs),
173                )
174            })
175            .collect::<HashMap<_, _>>();
176
177        let mut grouped = BTreeMap::<(String, String), Vec<ImportRecordMembership>>::new();
178        let nodes = self
179            .nodes()
180            .map(|(node_key, node)| (node_key, node.id))
181            .collect::<Vec<_>>();
182        for (node_key, node_id) in nodes {
183            let node_id = node_id.to_string();
184            for provenance in self.node_import_provenance(node_key).unwrap_or_default() {
185                grouped
186                    .entry((provenance.source_id, provenance.source_label))
187                    .or_default()
188                    .push(ImportRecordMembership {
189                        node_id: node_id.clone(),
190                        suppressed: false,
191                    });
192            }
193        }
194
195        let mut import_records = grouped
196            .into_iter()
197            .map(|((source_id, source_label), memberships)| {
198                let (record_id, imported_at_secs) = existing_record_meta
199                    .get(&(source_id.clone(), source_label.clone()))
200                    .cloned()
201                    .unwrap_or_else(|| (format!("import-record:{}", source_id), imported_at_secs));
202                ImportRecord {
203                    record_id,
204                    source_id,
205                    source_label,
206                    imported_at_secs,
207                    memberships,
208                }
209            })
210            .collect::<Vec<_>>();
211        normalize_import_records(&mut import_records);
212        self.import_records = import_records;
213        self.sync_node_import_provenance_from_records();
214    }
215
216    pub(crate) fn set_node_import_provenance(
217        &mut self,
218        key: NodeKey,
219        import_provenance: Vec<NodeImportProvenance>,
220    ) -> bool {
221        if self.inner.node(key).is_none() {
222            return false;
223        }
224        let mut normalized = import_provenance;
225        normalized.sort();
226        normalized.dedup();
227        if self.node_import_provenance(key).unwrap_or_default() == normalized {
228            return false;
229        }
230        self.set_node_facet(key, super::node_facets::PROVENANCE_IMPORT, &normalized);
231        self.rebuild_import_records_from_node_provenance(current_unix_timestamp_secs());
232        true
233    }
234}