lix 0.15.1

Embeddable version control for apps and AI agents.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use serde_json::Value as JsonValue;

use crate::LixError;
use crate::row_pk::RowPk;

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct SchemaKey {
    pub schema_key: String,
}

impl SchemaKey {
    pub fn new(schema_key: impl Into<String>) -> Self {
        Self {
            schema_key: schema_key.into(),
        }
    }
}

pub fn schema_key_from_definition(schema: &JsonValue) -> Result<SchemaKey, LixError> {
    let schema = super::definition::parse_lix_schema(schema)?;
    Ok(SchemaKey::new(schema.key))
}

pub fn schema_from_registered_snapshot(
    snapshot: &JsonValue,
) -> Result<(SchemaKey, JsonValue), LixError> {
    let schema_key = snapshot
        .get("schema_key")
        .and_then(JsonValue::as_str)
        .ok_or_else(|| {
            LixError::new(
                LixError::CODE_SCHEMA_DEFINITION,
                "registered schema snapshot missing string schema_key",
            )
        })?;
    let value = snapshot.get("value").cloned().ok_or_else(|| {
        LixError::new(
            LixError::CODE_SCHEMA_DEFINITION,
            "registered schema snapshot missing value",
        )
    })?;
    let schema = super::definition::parse_lix_schema(&value)?;
    if schema.key != schema_key {
        return Err(LixError::new(
            LixError::CODE_SCHEMA_DEFINITION,
            format!(
                "registered schema schema_key '{schema_key}' does not match value.key '{}'",
                schema.key
            ),
        ));
    }
    Ok((SchemaKey::new(schema_key), value))
}

pub(crate) fn registered_schema_row_pk(schema_key: &str) -> Result<RowPk, LixError> {
    RowPk::from_primary_key_paths(
        &serde_json::json!({ "schema_key": schema_key }),
        &[vec!["schema_key".to_string()]],
    )
    .map_err(|error| {
        LixError::new(
            LixError::CODE_SCHEMA_DEFINITION,
            format!("registered schema identity is invalid for '{schema_key}': {error}"),
        )
    })
}

#[cfg(test)]
mod tests {
    use serde_json::json;

    use super::*;

    fn schema(key: &str) -> JsonValue {
        json!({
            "$schema": "https://lix.dev/schema-v1.json",
            "key": key,
            "columns": [{
                "name": "id",
                "type": "text",
                "nullable": false
            }],
            "primary_key": ["id"]
        })
    }

    #[test]
    fn registered_snapshot_requires_explicit_schema_key() {
        let error = schema_from_registered_snapshot(&json!({
            "value": schema("acme_note")
        }))
        .expect_err("schema_key must not be inferred from value.key");

        assert_eq!(error.code, LixError::CODE_SCHEMA_DEFINITION);
        assert!(error.message.contains("missing string schema_key"));
    }

    #[test]
    fn registered_snapshot_rejects_schema_key_value_key_mismatch() {
        let error = schema_from_registered_snapshot(&json!({
            "schema_key": "acme_task",
            "value": schema("acme_note")
        }))
        .expect_err("the relational key and document key must agree");

        assert_eq!(error.code, LixError::CODE_SCHEMA_DEFINITION);
        assert!(error.message.contains("does not match value.key 'acme_note'"));
    }

    #[test]
    fn registered_snapshot_accepts_matching_schema_key_and_value_key() {
        let (key, value) = schema_from_registered_snapshot(&json!({
            "schema_key": "acme_note",
            "value": schema("acme_note")
        }))
        .expect("matching registry identity must be valid");

        assert_eq!(key.schema_key, "acme_note");
        assert_eq!(value["key"], "acme_note");
    }
}