Skip to main content

qualia_core_db/semantic_instruments/resolve/
registry.rs

1//! Installed-release index (SI-05).
2//!
3//! Local catalog only. Collecting a release is distinct from activating it:
4//! `closed == false` may be stored; activation requires verified closure.
5//! Duplicate `release_id` is rejected unless `content_digest` is identical
6//! (idempotent). No network fetch.
7
8use std::collections::BTreeMap;
9
10use super::dependency::DependencyLock;
11use crate::semantic_instruments::errors::InstrumentError;
12
13/// A collected release. `closed` means required deps were verified, not merely present.
14#[derive(Debug, Clone, PartialEq, Eq)]
15pub struct InstalledRelease {
16    pub release_id: String,
17    pub content_digest: String,
18    pub lock: DependencyLock,
19    pub closed: bool,
20}
21
22/// Deterministic in-memory index keyed by `release_id`.
23#[derive(Debug, Clone, Default)]
24pub struct LocalRegistry {
25    by_id: BTreeMap<String, InstalledRelease>,
26}
27
28impl LocalRegistry {
29    /// Creates a default `LocalRegistry`.
30    pub fn new() -> Self {
31        Self {
32            by_id: BTreeMap::new(),
33        }
34    }
35
36    /// Store a collected release. Open records (`closed == false`) are allowed.
37    ///
38    /// Duplicate `release_id` is `Canonical("already installed")` unless the
39    /// digest matches (idempotent no-op). Empty digest is `MissingField`.
40    pub fn install(&mut self, release: InstalledRelease) -> Result<(), InstrumentError> {
41        if release.release_id.is_empty() {
42            return Err(InstrumentError::MissingField("release_id"));
43        }
44        if release.content_digest.is_empty() {
45            return Err(InstrumentError::MissingField("content_digest"));
46        }
47        if let Some(existing) = self.by_id.get(&release.release_id) {
48            if existing.content_digest == release.content_digest {
49                return Ok(());
50            }
51            return Err(InstrumentError::Canonical("already installed".into()));
52        }
53        self.by_id.insert(release.release_id.clone(), release);
54        Ok(())
55    }
56
57    /// Looks up an entry; `None` when absent.
58    pub fn lookup(&self, release_id: &str) -> Option<&InstalledRelease> {
59        self.by_id.get(release_id)
60    }
61
62    /// Drop a collected release. Receipt history is not this index.
63    pub fn uninstall(&mut self, release_id: &str) -> Option<InstalledRelease> {
64        self.by_id.remove(release_id)
65    }
66
67    /// Fail closed: activation requires `closed == true` (all required deps verified).
68    pub fn activate(&self, release_id: &str) -> Result<&InstalledRelease, InstrumentError> {
69        let release = self
70            .by_id
71            .get(release_id)
72            .ok_or(InstrumentError::RequiredMissing)?;
73        if !release.closed {
74            return Err(InstrumentError::NotClosed);
75        }
76        Ok(release)
77    }
78}
79
80#[cfg(test)]
81mod tests {
82    use super::*;
83
84    const UNIT_CONVERT: &str = "https://ns.webizen.org/demo/unit-convert/releases/1.0.0";
85    const DIGEST: &str = "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
86
87    fn empty_lock(release_id: &str) -> DependencyLock {
88        DependencyLock {
89            release_id: release_id.into(),
90            entries: Vec::new(),
91        }
92    }
93
94    fn closed_unit_convert() -> InstalledRelease {
95        InstalledRelease {
96            release_id: UNIT_CONVERT.into(),
97            content_digest: DIGEST.into(),
98            lock: empty_lock(UNIT_CONVERT),
99            closed: true,
100        }
101    }
102
103    #[test]
104    fn install_then_lookup() {
105        let mut reg = LocalRegistry::new();
106        reg.install(closed_unit_convert()).unwrap();
107        let found = reg.lookup(UNIT_CONVERT).expect("stored");
108        assert_eq!(found.release_id, UNIT_CONVERT);
109        assert_eq!(found.content_digest, DIGEST);
110        assert!(found.lock.is_empty());
111        assert!(found.closed);
112    }
113
114    #[test]
115    fn activate_closed_release_ok() {
116        let mut reg = LocalRegistry::new();
117        // Empty lock + closed is valid: unit-convert has no required deps.
118        reg.install(closed_unit_convert()).unwrap();
119        let active = reg.activate(UNIT_CONVERT).unwrap();
120        assert_eq!(active.release_id, UNIT_CONVERT);
121        assert!(active.closed);
122    }
123
124    #[test]
125    fn activate_open_release_is_not_closed() {
126        let mut reg = LocalRegistry::new();
127        let mut open = closed_unit_convert();
128        open.closed = false;
129        reg.install(open).unwrap();
130        assert!(reg.lookup(UNIT_CONVERT).is_some());
131        assert_eq!(reg.activate(UNIT_CONVERT), Err(InstrumentError::NotClosed));
132    }
133
134    #[test]
135    fn activate_missing_is_required_missing() {
136        let reg = LocalRegistry::new();
137        assert_eq!(
138            reg.activate(UNIT_CONVERT),
139            Err(InstrumentError::RequiredMissing)
140        );
141    }
142
143    #[test]
144    fn empty_digest_is_missing_field() {
145        let mut reg = LocalRegistry::new();
146        let mut release = closed_unit_convert();
147        release.content_digest.clear();
148        assert_eq!(
149            reg.install(release),
150            Err(InstrumentError::MissingField("content_digest"))
151        );
152        assert!(reg.lookup(UNIT_CONVERT).is_none());
153    }
154
155    #[test]
156    fn uninstall_drops_lookup_not_history() {
157        let mut reg = LocalRegistry::new();
158        reg.install(closed_unit_convert()).unwrap();
159        assert!(reg.uninstall(UNIT_CONVERT).is_some());
160        assert!(reg.lookup(UNIT_CONVERT).is_none());
161        assert!(reg.uninstall(UNIT_CONVERT).is_none());
162    }
163
164    #[test]
165    fn duplicate_id_rejects_unless_digest_identical() {
166        let mut reg = LocalRegistry::new();
167        reg.install(closed_unit_convert()).unwrap();
168        // Idempotent: same id + same digest is a no-op.
169        reg.install(closed_unit_convert()).unwrap();
170        let mut other = closed_unit_convert();
171        other.content_digest =
172            "sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb".into();
173        match reg.install(other) {
174            Err(InstrumentError::Canonical(msg)) => assert_eq!(msg, "already installed"),
175            other => panic!("expected Canonical already installed, got {other:?}"),
176        }
177        assert_eq!(reg.lookup(UNIT_CONVERT).unwrap().content_digest, DIGEST);
178    }
179}