evenframe 0.1.4

A unified framework for TypeScript type generation and database schema synchronization
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
116
117
118
119
120
121
122
123
124
125
126
127

//! test-plugin command — runs output rule plugins against project types
//! and prints what they produce as JSON for scripted assertions.

use crate::cli::{Cli, TestPluginArgs};
use crate::config_builders;
use evenframe_core::{
    config::EvenframeConfig,
    error::Result,
    types::{ForeignTypeRegistry, StructConfig, TaggedUnion},
};
use std::collections::HashMap;
use tracing::info;

pub async fn run(_cli: &Cli, args: TestPluginArgs) -> Result<()> {
    let config = EvenframeConfig::new()?;
    let build_config = config_builders::BuildConfig::from_toml()?;

    let (enums, tables, objects) = config_builders::build_all_configs(&build_config)?;
    let (enums, tables, objects) = config_builders::filter_for_typesync(enums, tables, objects);
    let structs = config_builders::merge_tables_and_objects(&tables, &objects);

    let registry = ForeignTypeRegistry::from_config(&config.general.foreign_types);

    let mut results: Vec<serde_json::Value> = Vec::new();

    for (name, sc) in &structs {
        if let Some(ref filter) = args.type_name
            && !name.contains(filter)
        {
            continue;
        }

        let has_override =
            sc.output_override.is_some() || sc.fields.iter().any(|f| f.output_override.is_some());

        if args.changed_only && !has_override {
            continue;
        }

        let mut entry = serde_json::json!({
            "name": name,
            "kind": "Struct",
            "has_override": has_override,
        });

        if let Some(ref ov) = sc.output_override {
            entry["override_derives"] = serde_json::json!(ov.macroforge_derives);
            entry["override_annotations"] = serde_json::json!(ov.annotations);
        }

        let mut single = HashMap::new();
        single.insert(name.clone(), sc.clone());
        let empty_enums: HashMap<String, TaggedUnion> = HashMap::new();
        let generated = evenframe_core::typesync::macroforge::generate_macroforge_type_string(
            &single,
            &empty_enums,
            false,
            evenframe_core::typesync::config::ArrayStyle::default(),
            &registry,
        );
        entry["generated_typesync"] = serde_json::Value::String(generated);

        let mut field_entries: Vec<serde_json::Value> = Vec::new();
        for field in &sc.fields {
            if let Some(ref ov) = field.output_override {
                field_entries.push(serde_json::json!({
                    "field_name": field.field_name,
                    "override_annotations": ov.annotations,
                }));
            }
        }
        if !field_entries.is_empty() {
            entry["field_overrides"] = serde_json::Value::Array(field_entries);
        }

        results.push(entry);
    }

    for (name, eu) in &enums {
        if let Some(ref filter) = args.type_name
            && !name.contains(filter)
        {
            continue;
        }

        let has_override = eu.output_override.is_some();
        if args.changed_only && !has_override {
            continue;
        }

        let mut entry = serde_json::json!({
            "name": name,
            "kind": "Enum",
            "has_override": has_override,
        });

        if let Some(ref ov) = eu.output_override {
            entry["override_derives"] = serde_json::json!(ov.macroforge_derives);
            entry["override_annotations"] = serde_json::json!(ov.annotations);
        }

        let empty_structs: HashMap<String, StructConfig> = HashMap::new();
        let mut single_enum = HashMap::new();
        single_enum.insert(name.clone(), eu.clone());
        let generated = evenframe_core::typesync::macroforge::generate_macroforge_type_string(
            &empty_structs,
            &single_enum,
            false,
            evenframe_core::typesync::config::ArrayStyle::default(),
            &registry,
        );
        entry["generated_typesync"] = serde_json::Value::String(generated);

        results.push(entry);
    }

    let count = results.len();
    let override_count = results.iter().filter(|r| r["has_override"] == true).count();
    let output_json = serde_json::to_string_pretty(&results)?;
    println!("{}", output_json);
    info!(
        "{} types processed ({} with overrides)",
        count, override_count
    );

    Ok(())
}