Skip to main content

appstruct_ir/
json.rs

1use crate::{AppIr, IR_VERSION};
2use serde_json::Value;
3use std::error::Error;
4use std::fmt;
5
6#[derive(Debug)]
7pub enum IrJsonError {
8    InvalidJson(serde_json::Error),
9    MissingVersion,
10    UnsupportedVersion { found: u64 },
11}
12
13impl fmt::Display for IrJsonError {
14    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
15        match self {
16            Self::InvalidJson(error) => write!(formatter, "invalid IR JSON: {error}"),
17            Self::MissingVersion => formatter.write_str("IR JSON is missing integer `ir_version`"),
18            Self::UnsupportedVersion { found } => write!(
19                formatter,
20                "unsupported IR version {found}; expected {IR_VERSION}; recompile the App Spec"
21            ),
22        }
23    }
24}
25
26impl Error for IrJsonError {
27    fn source(&self) -> Option<&(dyn Error + 'static)> {
28        match self {
29            Self::InvalidJson(error) => Some(error),
30            Self::MissingVersion | Self::UnsupportedVersion { .. } => None,
31        }
32    }
33}
34
35impl From<serde_json::Error> for IrJsonError {
36    fn from(error: serde_json::Error) -> Self {
37        Self::InvalidJson(error)
38    }
39}
40
41/// Parse the current IR format without upgrading historical representations.
42///
43/// # Errors
44///
45/// Rejects invalid JSON, missing versions, and every version other than `IR_VERSION`.
46pub fn from_json(source: &str) -> Result<AppIr, IrJsonError> {
47    let value: Value = serde_json::from_str(source)?;
48    let version = value
49        .get("ir_version")
50        .and_then(Value::as_u64)
51        .ok_or(IrJsonError::MissingVersion)?;
52    if version != u64::from(IR_VERSION) {
53        return Err(IrJsonError::UnsupportedVersion { found: version });
54    }
55    serde_json::from_value(value).map_err(IrJsonError::from)
56}
57
58#[cfg(test)]
59mod tests {
60    use super::*;
61    const GOLDEN: &str = include_str!("../../../tests/golden/m0-app-ir.json");
62
63    #[test]
64    fn current_ir_round_trips_without_migration() {
65        let ir = from_json(GOLDEN).unwrap();
66        assert_eq!(ir.ir_version, IR_VERSION);
67        assert_eq!(from_json(&serde_json::to_string(&ir).unwrap()).unwrap(), ir);
68    }
69
70    #[test]
71    fn current_format_requires_always_serialized_fields() {
72        for field in ["billing", "database"] {
73            let mut value: Value = serde_json::from_str(GOLDEN).unwrap();
74            value.as_object_mut().unwrap().remove(field);
75            assert!(from_json(&value.to_string()).is_err());
76        }
77        let mut value: Value = serde_json::from_str(GOLDEN).unwrap();
78        value["database"]
79            .as_object_mut()
80            .unwrap()
81            .remove("dev_migration");
82        assert!(from_json(&value.to_string()).is_err());
83    }
84
85    #[test]
86    fn rejects_missing_older_and_future_versions() {
87        for found in [
88            0,
89            7,
90            11,
91            u64::from(IR_VERSION - 1),
92            u64::from(IR_VERSION + 1),
93            u64::MAX,
94        ] {
95            let mut value: Value = serde_json::from_str(GOLDEN).unwrap();
96            value["ir_version"] = Value::from(found);
97            assert!(matches!(
98                from_json(&value.to_string()),
99                Err(IrJsonError::UnsupportedVersion { .. })
100            ));
101        }
102        assert!(matches!(from_json("{}"), Err(IrJsonError::MissingVersion)));
103        let error = from_json("{").unwrap_err();
104        assert!(error.source().is_some());
105        assert!(error.to_string().contains("invalid IR JSON"));
106    }
107}