use std::collections::BTreeMap;
use serde::{Deserialize, Serialize};
use super::{
EndpointContract, EndpointIdempotency, EndpointPagination, 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, 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, Serialize, Deserialize)]
#[non_exhaustive]
pub struct EndpointPermissionsDocument {
pub mode: String,
pub values: Vec<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct EndpointContractSnapshot {
pub schema_version: u32,
pub summary: EndpointContractSnapshotSummary,
pub endpoints: Vec<EndpointContractDocument>,
}
impl EndpointContractSnapshot {
pub const SCHEMA_VERSION: u32 = 1;
#[must_use]
pub fn new(endpoints: Vec<EndpointContractDocument>) -> Self {
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 + Copy,
) -> Self {
Self {
schema_version: Self::SCHEMA_VERSION,
summary: EndpointContractSnapshotSummary::from_contracts(endpoints),
endpoints: endpoints
.iter()
.map(|endpoint| endpoint.document(permission_to_string))
.collect(),
}
}
pub fn to_pretty_json(&self) -> Result<String, serde_json::Error> {
serde_json::to_string_pretty(self)
}
}
#[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_contracts<P: Copy + 'static>(endpoints: &[EndpointContract<P>]) -> Self {
let mut summary = Self::new(endpoints.len());
for endpoint in endpoints {
increment(&mut summary.by_auth, endpoint.auth().as_str());
increment(&mut summary.by_risk, endpoint.risk().as_str());
increment(&mut summary.by_audit, endpoint.audit().as_str());
increment(&mut summary.by_rate_limit, endpoint.rate_limit().as_str());
if !endpoint.permissions().is_public() {
summary.permissioned += 1;
}
if endpoint.pagination() != EndpointPagination::None {
summary.paginated += 1;
}
if endpoint.idempotency() == EndpointIdempotency::Required {
summary.idempotency_required += 1;
}
}
summary
}
#[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 != "public" {
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 {
match permissions {
EndpointPermissions::Public => EndpointPermissionsDocument {
mode: "public".to_owned(),
values: Vec::new(),
},
EndpointPermissions::One(permission) => EndpointPermissionsDocument {
mode: "one".to_owned(),
values: vec![permission_to_string(permission)],
},
EndpointPermissions::Any(permissions) => EndpointPermissionsDocument {
mode: "any".to_owned(),
values: permissions
.iter()
.copied()
.map(permission_to_string)
.collect(),
},
EndpointPermissions::All(permissions) => EndpointPermissionsDocument {
mode: "all".to_owned(),
values: permissions
.iter()
.copied()
.map(permission_to_string)
.collect(),
},
}
}
fn increment(values: &mut BTreeMap<String, usize>, key: &str) {
*values.entry(key.to_owned()).or_default() += 1;
}