cratestack-cli 0.6.5

Rust-native schema-first framework for typed HTTP APIs, generated clients, and backend services.
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

use std::collections::BTreeMap;

use cratestack_core::{Field, TypeArity};

use super::arity::{arity_label, classify_arity_change};
use super::{Change, Severity};

pub(super) fn diff_fields(
    model_name: &str,
    prev: &[Field],
    next: &[Field],
    changes: &mut Vec<Change>,
) {
    let prev_by_name = index(prev);
    let next_by_name = index(next);

    for name in prev_by_name.keys() {
        if !next_by_name.contains_key(name) {
            changes.push(Change {
                severity: Severity::Breaking,
                category: "field_removed",
                subject: format!("{model_name}.{name}"),
                message: format!("field `{model_name}.{name}` was removed"),
            });
        }
    }

    for (name, next_field) in &next_by_name {
        match prev_by_name.get(name) {
            None => push_added_field(changes, model_name, name, next_field),
            Some(prev_field) => {
                diff_matched_field(model_name, name, prev_field, next_field, changes)
            }
        }
    }
}

fn index(fields: &[Field]) -> BTreeMap<&str, &Field> {
    fields
        .iter()
        .map(|field| (field.name.as_str(), field))
        .collect()
}

fn push_added_field(changes: &mut Vec<Change>, model_name: &str, name: &str, field: &Field) {
    let breaks_construction =
        field.ty.arity == TypeArity::Required && !has_default(field) && !is_server_only(field);

    if breaks_construction {
        changes.push(Change {
            severity: Severity::Breaking,
            category: "field_added_required",
            subject: format!("{model_name}.{name}"),
            message: format!(
                "field `{model_name}.{name}` was added as a required field with no default \
                 — existing client payloads that omit it will be rejected"
            ),
        });
        return;
    }

    changes.push(Change {
        severity: Severity::Additive,
        category: "field_added",
        subject: format!("{model_name}.{name}"),
        message: format!("field `{model_name}.{name}` was added"),
    });
}

fn diff_matched_field(
    model_name: &str,
    name: &str,
    prev: &Field,
    next: &Field,
    changes: &mut Vec<Change>,
) {
    if prev.ty.name != next.ty.name {
        changes.push(Change {
            severity: Severity::Breaking,
            category: "field_retyped",
            subject: format!("{model_name}.{name}"),
            message: format!(
                "field `{model_name}.{name}` type changed from `{}` to `{}`",
                prev.ty.name, next.ty.name
            ),
        });
        return;
    }

    if prev.ty.arity != next.ty.arity {
        let severity = classify_arity_change(prev.ty.arity, next.ty.arity);
        changes.push(Change {
            severity,
            category: "field_arity_changed",
            subject: format!("{model_name}.{name}"),
            message: format!(
                "field `{model_name}.{name}` arity changed from {} to {}",
                arity_label(prev.ty.arity),
                arity_label(next.ty.arity)
            ),
        });
    }
}

fn has_default(field: &Field) -> bool {
    field
        .attributes
        .iter()
        .any(|attribute| attribute.raw.starts_with("@default"))
}

fn is_server_only(field: &Field) -> bool {
    field
        .attributes
        .iter()
        .any(|attribute| attribute.raw == "@server_only")
}