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

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 repeated (list) fields.
/// Iterates items and applies per-item rules.
pub(crate) struct ListEval {
    /// Per-item evaluator.
    pub item_rules: ValueEval,
}

impl Evaluator for ListEval {
    fn tautology(&self) -> bool {
        self.item_rules.tautology()
    }

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

        let mut acc: Option<Error> = None;

        for (i, item) in list.iter().enumerate() {
            let item_path = format!("[{i}]");
            let (direct, nested) = self
                .item_rules
                .evaluate_value_split(msg, item, cfg, &item_path);
            // Only direct (item-level) violations get the "repeated.items" rule prefix.
            // Nested (embedded message) violations keep their own rule paths.
            let direct = prepend_rule_prefix(direct, "repeated.items");
            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(()),
        }
    }
}