schemadoc-diff 0.1.20

OpenApi diff library and breaking changes detector
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

pub mod added_required_body_property_check;
pub mod added_required_parameter_check;
pub mod added_required_request_body_check;
pub mod removed_media_type_check;
pub mod removed_operation_check;
pub mod removed_response_property_check;
pub mod removed_schema_enum_value_check;
pub mod updated_schema_type_check;

use crate::path_pointer::PathPointer;
use crate::schema_diff::HttpSchemaDiff;

use crate::visitor::{DiffVisitor, MergedVisitor};

use crate::checker::added_required_body_property_check::AddedRequiredBodyPropertyCheck;
use crate::checker::added_required_parameter_check::AddedRequiredParameterCheck;
use crate::checker::added_required_request_body_check::AddedRequiredRequestBodyCheck;
use crate::checker::removed_media_type_check::RemovedMediaTypeCheck;
use crate::checker::removed_operation_check::RemovedOperationCheck;
use crate::checker::removed_response_property_check::RemovedResponsePropertyCheck;
use crate::checker::removed_schema_enum_value_check::RemovedSchemaEnumValueCheck;
use crate::checker::updated_schema_type_check::UpdatedSchemaTypeCheck;

#[derive(Debug)]
pub struct ValidationIssue {
    pub path: PathPointer,
    pub breaking: bool,
    pub kind: &'static str,
}

impl ValidationIssue {
    pub fn new(path: PathPointer, kind: &'static str, breaking: bool) -> Self {
        Self {
            path,
            kind,
            breaking,
        }
    }
}

pub trait HasBreakingChange {
    fn has_breaking_changes(&self) -> bool;
}

impl HasBreakingChange for &[ValidationIssue] {
    fn has_breaking_changes(&self) -> bool {
        self.iter().any(|x| x.breaking)
    }
}

impl HasBreakingChange for &[&ValidationIssue] {
    fn has_breaking_changes(&self) -> bool {
        self.iter().any(|x| x.breaking)
    }
}

trait ValidationIssuer<'s> {
    fn id(&self) -> &'static str;
    fn visitor(&self) -> &dyn DiffVisitor<'s>;
    fn issues(&self) -> Option<Vec<ValidationIssue>>;
}

pub fn validate(
    diff: &HttpSchemaDiff,
    checkers: &[&str],
) -> Vec<ValidationIssue> {
    let removed_operation = Box::<RemovedOperationCheck>::default();
    let removed_media_type = Box::<RemovedMediaTypeCheck>::default();
    let changed_schema_type = Box::<UpdatedSchemaTypeCheck>::default();
    let removed_schema_enum_value =
        Box::<RemovedSchemaEnumValueCheck>::default();
    let added_required_parameter =
        Box::<AddedRequiredParameterCheck>::default();
    let removed_response_property =
        Box::<RemovedResponsePropertyCheck>::default();
    let added_required_request_body =
        Box::<AddedRequiredRequestBodyCheck>::default();
    let added_required_body_property =
        Box::<AddedRequiredBodyPropertyCheck>::default();

    let available_issuers: Vec<&dyn ValidationIssuer> = vec![
        &*removed_operation,
        &*removed_media_type,
        &*changed_schema_type,
        &*added_required_parameter,
        &*removed_response_property,
        &*removed_schema_enum_value,
        &*added_required_request_body,
        &*added_required_body_property,
    ];

    let issuers: Vec<_> = if checkers.contains(&"*") {
        available_issuers
    } else {
        available_issuers
            .into_iter()
            .filter(|issuer| checkers.contains(&issuer.id()))
            .collect()
    };

    let visitors: Vec<_> = issuers.iter().map(|v| v.visitor()).collect();

    {
        let visitor = MergedVisitor::new(visitors.as_slice());
        crate::visitor::dispatch_visitor(diff, &visitor);
    }

    let results: Vec<_> = issuers
        .into_iter()
        .filter_map(|v| v.issues())
        .flatten()
        .collect();

    results
}