prost-protovalidate 0.3.0

Runtime validation for Protocol Buffer messages using buf.validate rules
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
122
123
124
125
126
127
128
129
130
131

use prost_reflect::DynamicMessage;

use crate::config::ValidationConfig;
use crate::error::{self, Error};

use super::Evaluator;
use super::prepend_rule_prefix;
use super::value::ValueEval;

/// Evaluator for map fields.
/// Iterates key-value pairs and applies rules to keys and values.
pub(crate) struct MapEval {
    /// Rules for map keys.
    pub key_rules: ValueEval,
    /// Rules for map values.
    pub value_rules: ValueEval,
}

impl Evaluator for MapEval {
    fn tautology(&self) -> bool {
        self.key_rules.tautology() && self.value_rules.tautology()
    }

    fn evaluate(
        &self,
        msg: &DynamicMessage,
        val: &prost_reflect::Value,
        cfg: &ValidationConfig,
    ) -> Result<(), Error> {
        let Some(map) = val.as_map() else {
            return Ok(());
        };

        let mut acc: Option<Error> = None;

        for (key, value) in map {
            let key_str = map_key_to_string(key);

            // Validate key
            if !self.key_rules.tautology() {
                let key_path = format!("[{key_str}]");
                let key_value = key.clone().into();
                let (direct, nested) = self
                    .key_rules
                    .evaluate_value_split(msg, &key_value, cfg, &key_path);
                // Only direct (key-level) violations get "map.keys" rule prefix.
                let direct = mark_key_violations(direct);
                let direct = prepend_rule_prefix(direct, "map.keys");
                let nested = mark_key_violations(nested);
                let (cont, new_acc) = error::merge_violations(acc, direct, cfg.fail_fast);
                acc = new_acc;
                if !cont {
                    break;
                }
                let (cont, new_acc) = error::merge_violations(acc, nested, cfg.fail_fast);
                acc = new_acc;
                if !cont {
                    break;
                }
            }

            // Validate value
            if !self.value_rules.tautology() {
                let val_path = format!("[{key_str}]");
                let (direct, nested) = self
                    .value_rules
                    .evaluate_value_split(msg, value, cfg, &val_path);
                // Only direct (value-level) violations get "map.values" rule prefix.
                let direct = prepend_rule_prefix(direct, "map.values");
                let (cont, new_acc) = error::merge_violations(acc, direct, cfg.fail_fast);
                acc = new_acc;
                if !cont {
                    break;
                }
                let (cont, new_acc) = error::merge_violations(acc, nested, cfg.fail_fast);
                acc = new_acc;
                if !cont {
                    break;
                }
            }
        }

        match acc {
            Some(err) => Err(err),
            None => Ok(()),
        }
    }
}

fn map_key_to_string(key: &prost_reflect::MapKey) -> String {
    match key {
        prost_reflect::MapKey::Bool(b) => b.to_string(),
        prost_reflect::MapKey::I32(n) => n.to_string(),
        prost_reflect::MapKey::I64(n) => n.to_string(),
        prost_reflect::MapKey::U32(n) => n.to_string(),
        prost_reflect::MapKey::U64(n) => n.to_string(),
        prost_reflect::MapKey::String(s) => {
            serde_json::to_string(s).unwrap_or_else(|_| "\"\"".to_string())
        }
    }
}

fn mark_key_violations(result: Result<(), Error>) -> Result<(), Error> {
    match result {
        Ok(()) => Ok(()),
        Err(Error::Validation(mut ve)) => {
            for violation in ve.violations_mut() {
                violation.mark_for_key();
            }
            Err(Error::Validation(ve))
        }
        Err(other) => Err(other),
    }
}

#[cfg(test)]
mod tests {
    use pretty_assertions::assert_eq;

    use super::map_key_to_string;

    #[test]
    fn map_key_to_string_round_trips_json_escaped_strings() {
        let raw = "line\n\t\"quote\"\\slash";
        let key = prost_reflect::MapKey::String(raw.to_string());
        let rendered = map_key_to_string(&key);
        let decoded: String =
            serde_json::from_str(&rendered).expect("rendered map key should be valid JSON");
        assert_eq!(decoded, raw);
    }
}