evenframe 0.5.0

A unified framework for TypeScript type generation and database schema synchronization
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! Check command - reports whether the scan cache matches the Rust sources.

use crate::cli::CheckArgs;
use evenframe_core::{
    error::{EvenframeError, Result},
    tooling::{BuildConfig, CACHE_REFRESH_COMMAND, CacheStatus, ScanCache},
};
use serde::Serialize;

/// Runs the check command.
pub async fn run(args: CheckArgs) -> Result<()> {
    let config = BuildConfig::discover()?;
    let report = Report::new(
        ScanCache::path(&config.scan_path).display().to_string(),
        ScanCache::status(&config)?,
    );

    if args.json {
        println!("{}", serde_json::to_string_pretty(&report)?);
    } else {
        report.print();
    }

    if !report.in_sync() {
        return Err(EvenframeError::Validation(
            "the scan cache is not current".to_string(),
        ));
    }
    Ok(())
}

/// What the command reports, in both its human and its JSON form.
#[derive(Debug, Serialize)]
struct Report {
    cache_path: String,
    #[serde(flatten)]
    status: ReportStatus,
}

#[derive(Debug, Serialize)]
#[serde(tag = "status", rename_all = "snake_case")]
enum ReportStatus {
    InSync { types: TypeCounts },
    Missing,
    Stale { reason: String },
}

#[derive(Debug, Serialize)]
struct TypeCounts {
    tables: usize,
    objects: usize,
    enums: usize,
}

impl Report {
    fn new(cache_path: String, status: CacheStatus) -> Self {
        let status = match status {
            CacheStatus::Current(cache) => ReportStatus::InSync {
                types: TypeCounts {
                    tables: cache.tables.len(),
                    objects: cache.objects.len(),
                    enums: cache.enums.len(),
                },
            },
            CacheStatus::Absent => ReportStatus::Missing,
            CacheStatus::Stale(reason) => ReportStatus::Stale { reason },
        };
        Self { cache_path, status }
    }

    fn in_sync(&self) -> bool {
        matches!(self.status, ReportStatus::InSync { .. })
    }

    fn print(&self) {
        match &self.status {
            ReportStatus::InSync { types } => {
                println!("Types are in sync with {}", self.cache_path);
                println!(
                    "  tables: {}, objects: {}, enums: {}",
                    types.tables, types.objects, types.enums
                );
            }
            ReportStatus::Missing => {
                println!("No scan cache at {}", self.cache_path);
                println!("  Run `{CACHE_REFRESH_COMMAND}` to write it");
            }
            ReportStatus::Stale { reason } => {
                println!("Types are out of sync: {reason}");
                println!(
                    "  Run `{CACHE_REFRESH_COMMAND}` to refresh {}",
                    self.cache_path
                );
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use evenframe_core::tooling::CACHE_FORMAT_VERSION;
    use evenframe_core::types::StructConfig;
    use std::collections::BTreeMap;

    fn cache_with_one_object() -> ScanCache {
        ScanCache {
            format_version: CACHE_FORMAT_VERSION,
            evenframe_version: "0.0.0".to_string(),
            inputs: BTreeMap::new(),
            enums: BTreeMap::new(),
            tables: BTreeMap::new(),
            objects: BTreeMap::from([("Address".to_string(), StructConfig::default())]),
        }
    }

    fn report(status: CacheStatus) -> Report {
        Report::new(".evenframe/cache.json".to_string(), status)
    }

    #[test]
    fn only_a_current_cache_is_in_sync() {
        assert!(report(CacheStatus::Current(cache_with_one_object())).in_sync());
        assert!(!report(CacheStatus::Absent).in_sync());
        assert!(!report(CacheStatus::Stale("src/lib.rs changed".to_string())).in_sync());
    }

    #[test]
    fn json_carries_the_status_counts_and_reason() {
        let json =
            serde_json::to_value(report(CacheStatus::Current(cache_with_one_object()))).unwrap();
        assert_eq!(json["status"], "in_sync");
        assert_eq!(json["cache_path"], ".evenframe/cache.json");
        assert_eq!(json["types"]["objects"], 1);
        assert_eq!(json["types"]["tables"], 0);

        let json = serde_json::to_value(report(CacheStatus::Absent)).unwrap();
        assert_eq!(json["status"], "missing");

        let json =
            serde_json::to_value(report(CacheStatus::Stale("src/lib.rs changed".to_string())))
                .unwrap();
        assert_eq!(json["status"], "stale");
        assert_eq!(json["reason"], "src/lib.rs changed");
    }
}