protovalidate-buffa 0.7.2

Runtime for protoc-gen-protovalidate-buffa — Validate trait, ValidationError types, rule helpers, and the CelScalar / Duration / Timestamp helpers that compile-time-expanded CEL rules call into. No CEL interpreter at runtime.
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

use buffa_descriptor::generated::descriptor::field_descriptor_proto::Type;

use crate::{FieldPath, FieldType, Subscript, ValidationError, Violation, proto};

pub enum Exposure {
    Diagnostic,
    #[cfg(feature = "connect")]
    Public,
}

impl ValidationError {
    /// Copies all violations into the canonical `buf.validate.Violations` type.
    ///
    /// Requires `protos`. Preserves messages, map keys, indexes, schema paths,
    /// and rule IDs without a size limit. Empty paths, rule IDs and messages are
    /// absent; `for_key` is present only when true. Compilation and evaluation
    /// diagnostics remain on `self`: the schema has no fields for them.
    ///
    /// This diagnostic representation can contain rejected data. For public RPC
    /// request errors, use `into_connect_error` (requires `connect`), which
    /// applies redaction, size limits, and status classification.
    ///
    /// ```
    /// use protovalidate_buffa::{ValidationError, proto};
    /// let error = ValidationError::default();
    /// let details: proto::Violations = error.to_proto();
    /// assert!(details.violations.is_empty());
    /// ```
    #[must_use]
    pub fn to_proto(&self) -> proto::Violations {
        proto::Violations {
            violations: self
                .violations
                .iter()
                .map(|v| convert_violation(v, &Exposure::Diagnostic))
                .collect(),
            ..Default::default()
        }
    }
}

pub fn convert_violation(v: &Violation, exposure: &Exposure) -> proto::Violation {
    proto::Violation {
        field: convert_path(&v.field, exposure).into(),
        rule: convert_path(&v.rule, exposure).into(),
        rule_id: nonempty(&v.rule_id),
        message: match exposure {
            Exposure::Diagnostic => nonempty(&v.message),
            #[cfg(feature = "connect")]
            Exposure::Public => None,
        },
        for_key: v.for_key.then_some(true),
        ..Default::default()
    }
}

fn nonempty(value: &str) -> Option<String> {
    (!value.is_empty()).then(|| value.to_owned())
}

fn convert_path(path: &FieldPath, exposure: &Exposure) -> Option<proto::FieldPath> {
    if path.elements.is_empty() {
        return None;
    }
    Some(proto::FieldPath {
        elements: path
            .elements
            .iter()
            .map(|element| proto::FieldPathElement {
                field_number: element.field_number,
                field_name: element.field_name.as_deref().map(str::to_owned),
                field_type: element.field_type.map(convert_type),
                key_type: element.key_type.map(convert_type),
                value_type: element.value_type.map(convert_type),
                subscript: element
                    .subscript
                    .as_ref()
                    .filter(|subscript| {
                        let _ = subscript; // Also compiled without the connect feature.
                        match exposure {
                            Exposure::Diagnostic => true,
                            // Indexes are structural; map keys contain input data.
                            #[cfg(feature = "connect")]
                            Exposure::Public => matches!(subscript, Subscript::Index(_)),
                        }
                    })
                    .map(convert_subscript),
                ..Default::default()
            })
            .collect(),
        ..Default::default()
    })
}

fn convert_subscript(
    subscript: &Subscript,
) -> proto::__buffa::oneof::field_path_element::Subscript {
    use proto::__buffa::oneof::field_path_element::Subscript as S;
    match subscript {
        Subscript::Index(value) => S::Index(*value),
        Subscript::BoolKey(value) => S::BoolKey(*value),
        Subscript::IntKey(value) => S::IntKey(*value),
        Subscript::UintKey(value) => S::UintKey(*value),
        Subscript::StringKey(value) => S::StringKey(value.to_string()),
    }
}

const fn convert_type(field_type: FieldType) -> Type {
    match field_type {
        FieldType::Double => Type::TYPE_DOUBLE,
        FieldType::Float => Type::TYPE_FLOAT,
        FieldType::Int64 => Type::TYPE_INT64,
        FieldType::Uint64 => Type::TYPE_UINT64,
        FieldType::Int32 => Type::TYPE_INT32,
        FieldType::Fixed64 => Type::TYPE_FIXED64,
        FieldType::Fixed32 => Type::TYPE_FIXED32,
        FieldType::Bool => Type::TYPE_BOOL,
        FieldType::String => Type::TYPE_STRING,
        FieldType::Group => Type::TYPE_GROUP,
        FieldType::Message => Type::TYPE_MESSAGE,
        FieldType::Bytes => Type::TYPE_BYTES,
        FieldType::Uint32 => Type::TYPE_UINT32,
        FieldType::Enum => Type::TYPE_ENUM,
        FieldType::Sfixed32 => Type::TYPE_SFIXED32,
        FieldType::Sfixed64 => Type::TYPE_SFIXED64,
        FieldType::Sint32 => Type::TYPE_SINT32,
        FieldType::Sint64 => Type::TYPE_SINT64,
    }
}