artifactize_core/store/
definitions.rs

1//! Typed schema-5 saved graph snapshots, distinct from strict live declarations.
2//! Unknown saved fields survive round-trips; owner schemas and payload extensions stay JSON.
3mod extensions;
4#[cfg(test)]
5mod tests;
6use crate::config::{self, Field, StoredPayload};
7pub use extensions::{Profile, SavedSelection};
8use serde::{Deserialize, Deserializer, Serialize, Serializer};
9use serde_json::{Map, Value};
10use std::{collections::BTreeMap, path::PathBuf};
11
12fn missing<T>(field: &Field<T>) -> bool {
13    matches!(field, Field::Missing)
14}
15
16#[derive(Debug, Clone, Default)]
17pub struct Definitions(pub Option<Graph>);
18impl Definitions {
19    pub fn graph(&self) -> Option<&Graph> {
20        self.0.as_ref()
21    }
22    pub fn from_view(view: &crate::query::GraphView<'_>) -> Result<Self, serde_json::Error> {
23        serde_json::from_value(serde_json::to_value(view)?)
24    }
25}
26impl Serialize for Definitions {
27    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
28        self.0.serialize(serializer)
29    }
30}
31impl<'de> Deserialize<'de> for Definitions {
32    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
33        Option::<Graph>::deserialize(deserializer).map(Self)
34    }
35}
36
37#[derive(Debug, Clone, Default, Serialize, Deserialize)]
38#[serde(rename_all = "camelCase")]
39pub struct Graph {
40    #[serde(default, skip_serializing_if = "missing")]
41    pub version: Field<u32>,
42    #[serde(default, skip_serializing_if = "missing", with = "path_field")]
43    pub repo_path: Field<PathBuf>,
44    #[serde(default, skip_serializing_if = "missing")]
45    pub selection: Field<SavedSelection>,
46    #[serde(default, skip_serializing_if = "Field::missing")]
47    pub artifacts: Field<BTreeMap<crate::types::ArtifactName, Artifact>>,
48    #[serde(default, skip_serializing_if = "missing")]
49    pub evals: Field<Vec<Eval>>,
50    #[serde(default, skip_serializing_if = "missing")]
51    pub relations: Field<Vec<Relation>>,
52    #[serde(default, skip_serializing_if = "missing")]
53    pub components: Field<Vec<Component>>,
54    #[serde(flatten)]
55    pub extra: Map<String, Value>,
56}
57impl Graph {
58    pub fn artifacts(&self) -> impl Iterator<Item = (&crate::types::ArtifactName, &Artifact)> {
59        match &self.artifacts {
60            Field::Value(map) => Some(map),
61            _ => None,
62        }
63        .into_iter()
64        .flatten()
65    }
66    pub fn artifact(&self, id: &str) -> Option<&Artifact> {
67        match &self.artifacts {
68            Field::Value(map) => map.get(id),
69            _ => None,
70        }
71    }
72    pub fn evals(&self) -> &[Eval] {
73        match &self.evals {
74            Field::Value(evals) => evals,
75            _ => &[],
76        }
77    }
78    pub fn relations(&self) -> &[Relation] {
79        match &self.relations {
80            Field::Value(relations) => relations,
81            _ => &[],
82        }
83    }
84    pub fn components(&self) -> &[Component] {
85        match &self.components {
86            Field::Value(components) => components,
87            _ => &[],
88        }
89    }
90}
91
92#[derive(Debug, Clone, Default, Serialize, Deserialize)]
93#[serde(rename_all = "camelCase")]
94pub struct Artifact {
95    #[serde(default, skip_serializing_if = "missing")]
96    pub kind: Field<config::ArtifactKind>,
97    #[serde(default, skip_serializing_if = "missing", with = "path_field")]
98    pub path: Field<PathBuf>,
99    #[serde(default, skip_serializing_if = "missing")]
100    pub children: Field<BTreeMap<config::ChildPrefix, crate::types::ArtifactName>>,
101    #[serde(default, skip_serializing_if = "missing")]
102    pub name: Field<crate::types::ArtifactName>,
103    #[serde(default, skip_serializing_if = "missing")]
104    pub tags: Field<Vec<String>>,
105    #[serde(default, skip_serializing_if = "missing")]
106    pub views: Field<Views>,
107    #[serde(default, skip_serializing_if = "missing")]
108    pub mounts: Field<BTreeMap<config::MountAlias, crate::types::ArtifactName>>,
109    #[serde(default, skip_serializing_if = "missing")]
110    pub basis: Field<bool>,
111    #[serde(default, skip_serializing_if = "missing")]
112    pub fingerprint: Field<Fingerprint>,
113    #[serde(flatten)]
114    pub extra: Map<String, Value>,
115}
116#[derive(Debug, Clone, Default, Serialize, Deserialize)]
117#[serde(rename_all = "camelCase")]
118pub struct Views {
119    #[serde(default, skip_serializing_if = "missing")]
120    pub agent_tools: Field<BTreeMap<config::ToolOperationName, AgentTool>>,
121    #[serde(default, skip_serializing_if = "missing")]
122    pub human_tools: Field<BTreeMap<config::ToolOperationName, HumanTool>>,
123    #[serde(flatten)]
124    pub extra: Map<String, Value>,
125}
126#[derive(Debug, Clone, Serialize, Deserialize)]
127#[serde(untagged)]
128pub enum AgentTool {
129    Command(CommandTool),
130    Builtin(BuiltinTool),
131}
132#[derive(Debug, Clone, Serialize, Deserialize)]
133#[serde(rename_all = "camelCase")]
134pub struct CommandTool {
135    pub description: String,
136    pub input_schema: Value,
137    pub protocol: config::ToolProtocol,
138    pub command: String,
139    pub args: Vec<String>,
140    #[serde(default, skip_serializing_if = "missing", with = "duration_field")]
141    pub timeout_ms: Field<std::time::Duration>,
142    #[serde(default, skip_serializing_if = "missing")]
143    pub execution_paths: Field<Vec<String>>,
144    #[serde(flatten)]
145    pub extra: Map<String, Value>,
146}
147#[derive(Debug, Clone, Serialize, Deserialize)]
148pub struct BuiltinTool {
149    pub builtin: config::Builtin,
150    #[serde(default, skip_serializing_if = "missing")]
151    pub args: Field<Vec<String>>,
152    #[serde(default, skip_serializing_if = "missing")]
153    pub description: Field<String>,
154    #[serde(flatten)]
155    pub extra: Map<String, Value>,
156}
157#[derive(Debug, Clone, Serialize, Deserialize)]
158#[serde(untagged)]
159pub enum HumanTool {
160    Command(HumanCommandTool),
161    Builtin(HumanBuiltinTool),
162}
163#[derive(Debug, Clone, Serialize, Deserialize)]
164#[serde(rename_all = "camelCase")]
165pub struct HumanCommandTool {
166    pub description: String,
167    pub kind: config::HumanToolKind,
168    pub command: String,
169    pub args: Vec<String>,
170    #[serde(flatten)]
171    pub extra: Map<String, Value>,
172}
173#[derive(Debug, Clone, Serialize, Deserialize)]
174pub struct HumanBuiltinTool {
175    pub builtin: config::Builtin,
176    pub description: String,
177    pub kind: config::HumanToolKind,
178    pub args: Vec<String>,
179    #[serde(flatten)]
180    pub extra: Map<String, Value>,
181}
182#[derive(Debug, Clone, Default, Serialize, Deserialize)]
183#[serde(rename_all = "camelCase")]
184pub struct Fingerprint {
185    #[serde(default, skip_serializing_if = "missing")]
186    pub script: Field<Script>,
187    #[serde(default, skip_serializing_if = "missing")]
188    pub files: Field<Vec<String>>,
189    #[serde(default, skip_serializing_if = "missing")]
190    pub ignore: Field<Vec<String>>,
191    #[serde(flatten)]
192    pub extra: Map<String, Value>,
193}
194#[derive(Debug, Clone, Serialize, Deserialize)]
195#[serde(rename_all = "camelCase")]
196pub struct Script {
197    pub command: String,
198    pub args: Vec<String>,
199    #[serde(default, skip_serializing_if = "missing")]
200    pub files: Field<Vec<String>>,
201    #[serde(default, skip_serializing_if = "missing", with = "duration_field")]
202    pub timeout_ms: Field<std::time::Duration>,
203    #[serde(flatten)]
204    pub extra: Map<String, Value>,
205}
206#[derive(Debug, Clone, Serialize, Deserialize)]
207pub struct Eval {
208    pub id: crate::types::EvalId,
209    pub target: crate::types::ArtifactName,
210    #[serde(default, skip_serializing_if = "missing")]
211    pub references: Field<BTreeMap<crate::config::ReferenceName, crate::types::ArtifactName>>,
212    #[serde(default, skip_serializing_if = "missing")]
213    pub deps: Field<Vec<crate::types::ArtifactName>>,
214    #[serde(default, skip_serializing_if = "missing")]
215    pub declaration: Field<Declaration>,
216    #[serde(flatten)]
217    pub extra: Map<String, Value>,
218}
219#[derive(Debug, Clone, Default, Serialize, Deserialize)]
220#[serde(rename_all = "camelCase")]
221pub struct Declaration {
222    #[serde(default, skip_serializing_if = "missing")]
223    pub gate: Field<config::Gate>,
224    #[serde(default, skip_serializing_if = "missing")]
225    pub id: Field<crate::config::LocalEvalId>,
226    #[serde(default, skip_serializing_if = "missing")]
227    pub title: Field<String>,
228    #[serde(default, skip_serializing_if = "missing")]
229    pub profile: Field<Profile>,
230    #[serde(default, skip_serializing_if = "missing")]
231    pub profile_variants: Field<BTreeMap<config::ProfileVariantName, Profile>>,
232    #[serde(default, skip_serializing_if = "missing")]
233    pub payload: Field<StoredPayload>,
234    #[serde(default, skip_serializing_if = "missing")]
235    pub pass_schema: Field<Map<String, Value>>,
236    #[serde(default, skip_serializing_if = "missing")]
237    pub fail_schema: Field<Map<String, Value>>,
238    #[serde(flatten)]
239    pub extra: Map<String, Value>,
240}
241#[derive(Debug, Clone, Default, Serialize, Deserialize)]
242pub struct Component {
243    #[serde(default, skip_serializing_if = "missing")]
244    pub id: Field<crate::graph::ComponentId>,
245    #[serde(default, skip_serializing_if = "missing")]
246    pub artifacts: Field<Vec<crate::types::ArtifactName>>,
247    #[serde(default, skip_serializing_if = "missing")]
248    pub dependencies: Field<Vec<crate::graph::ComponentId>>,
249    #[serde(default, skip_serializing_if = "missing")]
250    pub gates: Field<Vec<crate::types::EvalId>>,
251    #[serde(default, skip_serializing_if = "missing")]
252    pub cyclic: Field<bool>,
253    #[serde(flatten)]
254    pub extra: Map<String, Value>,
255}
256#[derive(Debug, Clone, Serialize)]
257pub struct Relation {
258    pub source: crate::types::ArtifactName,
259    pub target: crate::types::ArtifactName,
260    #[serde(flatten)]
261    pub kind: RelationKind,
262    #[serde(default, skip_serializing_if = "missing")]
263    pub cyclic: Field<bool>,
264    #[serde(flatten)]
265    pub extra: Map<String, Value>,
266}
267impl<'de> Deserialize<'de> for Relation {
268    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
269        // Flattened internally-tagged enums do not consume their fields from a second
270        // flatten map. Split at the saved boundary so reserialization never duplicates kind.
271        let mut fields = Map::<String, Value>::deserialize(deserializer)?;
272        let mut take = |name: &str| {
273            fields
274                .remove(name)
275                .ok_or_else(|| serde::de::Error::custom(format!("missing relation {name}")))
276        };
277        let source = serde_json::from_value(take("source")?).map_err(serde::de::Error::custom)?;
278        let target = serde_json::from_value(take("target")?).map_err(serde::de::Error::custom)?;
279        let kind_name: String =
280            serde_json::from_value(take("kind")?).map_err(serde::de::Error::custom)?;
281        let names: &[&str] = match kind_name.as_str() {
282            "child" => &["path"],
283            "mount" => &["alias"],
284            "instruction" | "dependency" => &["evalId", "name"],
285            "argv" => &["evalId", "index", "name", "path"],
286            _ => &[],
287        };
288        let unknown = names.is_empty();
289        let mut kind = Map::from_iter([("kind".into(), Value::String(kind_name.clone()))]);
290        for name in names {
291            if let Some(value) = fields.remove(*name) {
292                kind.insert((*name).into(), value);
293            }
294        }
295        let kind = if unknown {
296            RelationKind::Unknown { kind: kind_name }
297        } else {
298            let parsed =
299                serde_json::from_value(Value::Object(kind)).map_err(serde::de::Error::custom)?;
300            if matches!(parsed, RelationKind::Unknown { .. }) {
301                return Err(serde::de::Error::custom(format!(
302                    "Invalid saved {kind_name} relation."
303                )));
304            }
305            parsed
306        };
307        let cyclic = match fields.remove("cyclic") {
308            Some(value) => serde_json::from_value(value).map_err(serde::de::Error::custom)?,
309            None => Field::Missing,
310        };
311        Ok(Self {
312            source,
313            target,
314            kind,
315            cyclic,
316            extra: fields,
317        })
318    }
319}
320#[derive(Debug, Clone, Serialize, Deserialize)]
321#[serde(tag = "kind", rename_all = "lowercase")]
322pub enum RelationKind {
323    Child {
324        #[serde(default, skip_serializing_if = "missing")]
325        path: Field<config::ChildPrefix>,
326    },
327    Mount {
328        #[serde(default, skip_serializing_if = "missing")]
329        alias: Field<config::MountAlias>,
330    },
331    Dependency {
332        #[serde(rename = "evalId", default, skip_serializing_if = "missing")]
333        eval_id: Field<crate::types::EvalId>,
334        #[serde(default, skip_serializing_if = "missing")]
335        name: Field<config::ReferenceName>,
336    },
337    Instruction {
338        #[serde(rename = "evalId")]
339        eval_id: crate::types::EvalId,
340        name: config::ReferenceName,
341    },
342    #[serde(rename = "argv")]
343    Argument {
344        #[serde(rename = "evalId")]
345        eval_id: crate::types::EvalId,
346        index: usize,
347        name: config::ReferenceName,
348        path: String,
349    },
350    #[serde(untagged)]
351    Unknown { kind: String },
352}
353
354mod duration_field {
355    use crate::config::Field;
356    use serde::{Deserializer, Serializer};
357    use std::time::Duration;
358    pub fn serialize<S: Serializer>(
359        value: &Field<Duration>,
360        serializer: S,
361    ) -> Result<S::Ok, S::Error> {
362        match value {
363            Field::Value(value) => {
364                let milliseconds = value.as_millis();
365                if !(1..=u128::from(crate::config::validation::MAX_TIMEOUT_MS))
366                    .contains(&milliseconds)
367                    || Duration::from_millis(milliseconds as u64) != *value
368                {
369                    return Err(serde::ser::Error::custom(
370                        "Saved definition timeoutMs must be whole milliseconds from 1 through 2147483647.",
371                    ));
372                }
373                serializer.serialize_u128(milliseconds)
374            }
375            _ => serializer.serialize_none(),
376        }
377    }
378    pub fn deserialize<'de, D: Deserializer<'de>>(
379        deserializer: D,
380    ) -> Result<Field<Duration>, D::Error> {
381        crate::config::validation::milliseconds::deserialize(deserializer)
382            .map(|value| value.map_or(Field::Null, Field::Value))
383    }
384}
385
386pub(super) mod path_field {
387    use crate::config::Field;
388    use serde::{Deserializer, Serializer};
389    use std::path::PathBuf;
390    pub fn serialize<S: Serializer>(
391        value: &Field<PathBuf>,
392        serializer: S,
393    ) -> Result<S::Ok, S::Error> {
394        match value {
395            Field::Value(path) => crate::platform::path_serde::serialize(path, serializer),
396            _ => serializer.serialize_none(),
397        }
398    }
399    pub fn deserialize<'de, D: Deserializer<'de>>(
400        deserializer: D,
401    ) -> Result<Field<PathBuf>, D::Error> {
402        crate::platform::path_serde::option::deserialize(deserializer)
403            .map(|value| value.map_or(Field::Null, Field::Value))
404    }
405}
artifactize_core/store/definitions.rs

artifactize_core/store/
definitions.rs
