use std::collections::BTreeMap;
use serde::{Deserialize, Deserializer, Serialize};
use super::{EndpointContract, EndpointPathPattern, EndpointPermissions};
impl<P: Copy + 'static> EndpointContract<P> {
#[must_use]
pub fn document(self, permission_to_string: impl Fn(P) -> String) -> EndpointContractDocument {
EndpointContractDocument {
method: self.method().as_str().to_owned(),
path: self.path().as_str().to_owned(),
path_kind: match self.path() {
EndpointPathPattern::Exact(_) => "exact",
EndpointPathPattern::Template(_) => "template",
}
.to_owned(),
auth: self.auth().as_str().to_owned(),
permissions: document_permissions(self.permissions(), permission_to_string),
risk: self.risk().as_str().to_owned(),
idempotency: self.idempotency().as_str().to_owned(),
pagination: self.pagination().as_str().to_owned(),
rate_limit: self.rate_limit().as_str().to_owned(),
audit: self.audit().as_str().to_owned(),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[non_exhaustive]
pub struct EndpointContractDocument {
pub method: String,
pub path: String,
pub path_kind: String,
pub auth: String,
pub permissions: EndpointPermissionsDocument,
pub risk: String,
pub idempotency: String,
pub pagination: String,
pub rate_limit: String,
pub audit: String,
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[non_exhaustive]
pub struct EndpointPermissionsDocument {
pub mode: String,
pub values: Vec<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[non_exhaustive]
pub struct EndpointContractSnapshot {
schema_version: u32,
summary: EndpointContractSnapshotSummary,
endpoints: Vec<EndpointContractDocument>,
}
impl EndpointContractSnapshot {
pub const SCHEMA_VERSION: u32 = 3;
#[must_use]
pub fn new(mut endpoints: Vec<EndpointContractDocument>) -> Self {
endpoints.sort_by(|left, right| {
(&left.path, &left.method)
.cmp(&(&right.path, &right.method))
.then_with(|| left.cmp(right))
});
Self {
schema_version: Self::SCHEMA_VERSION,
summary: EndpointContractSnapshotSummary::from_documents(&endpoints),
endpoints,
}
}
#[must_use]
pub fn from_contracts<P: Copy + 'static>(
endpoints: &[EndpointContract<P>],
permission_to_string: impl Fn(P) -> String,
) -> Self {
Self::new(
endpoints
.iter()
.map(|endpoint| endpoint.document(&permission_to_string))
.collect(),
)
}
#[must_use]
pub const fn schema_version(&self) -> u32 {
self.schema_version
}
#[must_use]
pub const fn summary(&self) -> &EndpointContractSnapshotSummary {
&self.summary
}
#[must_use]
pub fn endpoints(&self) -> &[EndpointContractDocument] {
&self.endpoints
}
pub fn to_pretty_json(&self) -> Result<String, serde_json::Error> {
serde_json::to_string_pretty(self)
}
}
impl<'de> Deserialize<'de> for EndpointContractSnapshot {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
#[derive(Deserialize)]
struct Wire {
schema_version: u32,
summary: EndpointContractSnapshotSummary,
endpoints: Vec<EndpointContractDocument>,
}
let wire = Wire::deserialize(deserializer)?;
if wire.schema_version != Self::SCHEMA_VERSION {
return Err(serde::de::Error::custom(
"unsupported endpoint snapshot schema version",
));
}
let snapshot = Self::new(wire.endpoints);
if snapshot.summary != wire.summary {
return Err(serde::de::Error::custom(
"endpoint snapshot summary does not match its endpoints",
));
}
Ok(snapshot)
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct EndpointContractSnapshotSummary {
pub total: usize,
pub by_auth: BTreeMap<String, usize>,
pub by_risk: BTreeMap<String, usize>,
pub by_audit: BTreeMap<String, usize>,
pub by_rate_limit: BTreeMap<String, usize>,
pub permissioned: usize,
pub paginated: usize,
pub idempotency_required: usize,
}
impl EndpointContractSnapshotSummary {
#[must_use]
pub fn from_documents(endpoints: &[EndpointContractDocument]) -> Self {
let mut summary = Self::new(endpoints.len());
for endpoint in endpoints {
increment(&mut summary.by_auth, &endpoint.auth);
increment(&mut summary.by_risk, &endpoint.risk);
increment(&mut summary.by_audit, &endpoint.audit);
increment(&mut summary.by_rate_limit, &endpoint.rate_limit);
if endpoint.permissions.mode != "none" {
summary.permissioned += 1;
}
if endpoint.pagination != "none" {
summary.paginated += 1;
}
if endpoint.idempotency == "required" {
summary.idempotency_required += 1;
}
}
summary
}
fn new(total: usize) -> Self {
Self {
total,
by_auth: BTreeMap::new(),
by_risk: BTreeMap::new(),
by_audit: BTreeMap::new(),
by_rate_limit: BTreeMap::new(),
permissioned: 0,
paginated: 0,
idempotency_required: 0,
}
}
}
fn document_permissions<P: Copy + 'static>(
permissions: EndpointPermissions<P>,
permission_to_string: impl Fn(P) -> String,
) -> EndpointPermissionsDocument {
let (mode, values): (&str, &[P]) = match &permissions {
EndpointPermissions::None => ("none", &[]),
EndpointPermissions::One(permission) => ("one", std::slice::from_ref(permission)),
EndpointPermissions::Any(values) => ("any", values),
EndpointPermissions::All(values) => ("all", values),
};
EndpointPermissionsDocument {
mode: mode.to_owned(),
values: values.iter().copied().map(permission_to_string).collect(),
}
}
fn increment(values: &mut BTreeMap<String, usize>, key: &str) {
*values.entry(key.to_owned()).or_default() += 1;
}