use std::{
borrow::Cow,
error::Error,
fmt::{self, Display, Formatter},
};
use schemars::{JsonSchema, Schema, SchemaGenerator, json_schema};
use serde::{Deserialize, Deserializer, Serialize, de::Error as _};
use crate::diagnostic::{PublicEvidence, PublicText};
use super::{HeaderName, JsonPointer, ParameterName};
pub const DEFAULT_MAX_VIOLATIONS: usize = 100;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ViolationReason {
Required,
InvalidFormat,
OutOfRange,
NotAllowed,
Conflict,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ViolationSource {
Body {
pointer: JsonPointer,
},
Query {
parameter: ParameterName,
},
Header {
name: HeaderName,
},
Path {
parameter: ParameterName,
},
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
pub struct Violation {
pub reason: ViolationReason,
pub detail: PublicText,
pub source: ViolationSource,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct ValidationEvidence {
violations: Vec<Violation>,
}
impl ValidationEvidence {
pub fn new(violations: Vec<Violation>) -> Result<Self, ValidationEvidenceError> {
Self::with_max_violations(violations, DEFAULT_MAX_VIOLATIONS)
}
pub fn with_max_violations(
violations: Vec<Violation>,
max_violations: usize,
) -> Result<Self, ValidationEvidenceError> {
if max_violations == 0 {
return Err(ValidationEvidenceError::ZeroLimit);
}
if max_violations > DEFAULT_MAX_VIOLATIONS {
return Err(ValidationEvidenceError::LimitTooLarge { max_violations });
}
if violations.is_empty() {
return Err(ValidationEvidenceError::Empty);
}
if violations.len() > max_violations {
return Err(ValidationEvidenceError::TooMany {
actual: violations.len(),
max_violations,
});
}
Ok(Self { violations })
}
pub fn violations(&self) -> &[Violation] {
&self.violations
}
}
impl PublicEvidence for ValidationEvidence {}
impl<'de> Deserialize<'de> for ValidationEvidence {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize)]
struct WireEvidence {
violations: Vec<Violation>,
}
let wire = WireEvidence::deserialize(deserializer)?;
Self::new(wire.violations).map_err(D::Error::custom)
}
}
impl JsonSchema for ValidationEvidence {
fn schema_name() -> Cow<'static, str> {
"ValidationEvidence".into()
}
fn json_schema(generator: &mut SchemaGenerator) -> Schema {
json_schema!({
"type": "object",
"properties": {
"violations": {
"type": "array",
"items": generator.subschema_for::<Violation>(),
"minItems": 1,
"maxItems": DEFAULT_MAX_VIOLATIONS
}
},
"required": ["violations"]
})
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum ValidationEvidenceError {
ZeroLimit,
LimitTooLarge {
max_violations: usize,
},
Empty,
TooMany {
actual: usize,
max_violations: usize,
},
}
impl Display for ValidationEvidenceError {
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
match self {
Self::ZeroLimit => formatter.write_str("maximum violation count must be positive"),
Self::LimitTooLarge { max_violations } => write!(
formatter,
"maximum violation count {max_violations} exceeds protocol ceiling {DEFAULT_MAX_VIOLATIONS}"
),
Self::Empty => formatter.write_str("validation evidence must contain a violation"),
Self::TooMany {
actual,
max_violations,
} => write!(
formatter,
"validation evidence has {actual} violations; maximum is {max_violations}"
),
}
}
}
impl Error for ValidationEvidenceError {}