Skip to main content

dreamwell_engine/waymark/
errors.rs

1use serde::{Deserialize, Serialize};
2use std::fmt;
3
4#[derive(Debug, Clone, Serialize, Deserialize)]
5pub enum WaymarkError {
6    Authoring(AuthoringError),
7    Semantic(SemanticError),
8    Topology(TopologyError),
9    Compatibility(CompatibilityError),
10    Canonical(CanonicalError),
11}
12
13#[derive(Debug, Clone, Serialize, Deserialize)]
14pub enum AuthoringError {
15    UnknownTag(String),
16    UnknownSignal(String),
17    UnknownReceiver(String),
18    UnknownFunction(String),
19    InvalidPropertyType { key: String, expected: String, got: String },
20    InvalidTemplateReference(String),
21}
22
23#[derive(Debug, Clone, Serialize, Deserialize)]
24pub enum SemanticError {
25    ConflictingTags(Vec<String>),
26    MissingRequiredReceiver(String),
27    InvalidSignalReceiverBinding { signal: String, receiver: String },
28    GraphConstraintViolation(String),
29}
30
31#[derive(Debug, Clone, Serialize, Deserialize)]
32pub enum TopologyError {
33    InvalidParentChildRelation { parent: String, child: String },
34    InvalidTransition { from: String, to: String },
35    InvalidTopologyBinding(String),
36    IllegalCrossLayerReference(String),
37}
38
39#[derive(Debug, Clone, Serialize, Deserialize)]
40pub enum CompatibilityError {
41    PackVersionMismatch(String),
42    SchemaVersionMismatch(String),
43    ReducerContractMismatch(String),
44    UnsupportedRegistryVersion(String),
45}
46
47#[derive(Debug, Clone, Serialize, Deserialize)]
48pub enum CanonicalError {
49    UnstableCanonicalOrdering(String),
50    MissingVersionedIdentity(String),
51    UnhashableDelta(String),
52}
53
54impl fmt::Display for WaymarkError {
55    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
56        match self {
57            Self::Authoring(e) => write!(f, "waymark_authoring: {e:?}"),
58            Self::Semantic(e) => write!(f, "waymark_semantic: {e:?}"),
59            Self::Topology(e) => write!(f, "waymark_topology: {e:?}"),
60            Self::Compatibility(e) => write!(f, "waymark_compatibility: {e:?}"),
61            Self::Canonical(e) => write!(f, "waymark_canonical: {e:?}"),
62        }
63    }
64}
65
66impl std::error::Error for WaymarkError {}
67
68#[cfg(test)]
69mod tests {
70    use super::*;
71
72    #[test]
73    fn error_display_authoring() {
74        let e = WaymarkError::Authoring(AuthoringError::UnknownTag("foo".into()));
75        assert!(e.to_string().contains("waymark_authoring"));
76    }
77
78    #[test]
79    fn error_display_semantic() {
80        let e = WaymarkError::Semantic(SemanticError::ConflictingTags(vec!["a".into()]));
81        assert!(e.to_string().contains("waymark_semantic"));
82    }
83
84    #[test]
85    fn error_display_topology() {
86        let e = WaymarkError::Topology(TopologyError::InvalidTopologyBinding("x".into()));
87        assert!(e.to_string().contains("waymark_topology"));
88    }
89
90    #[test]
91    fn error_serde_roundtrip() {
92        let e = WaymarkError::Canonical(CanonicalError::UnhashableDelta("test".into()));
93        let json = serde_json::to_string(&e).unwrap();
94        let _: WaymarkError = serde_json::from_str(&json).unwrap();
95    }
96}