evenframe 0.1.6

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

//! Validate command - validates configuration and types.

use crate::cli::{Cli, ValidateArgs};
use crate::config_builders;
use crate::workspace_scanner::WorkspaceScanner;
use evenframe_core::{config::EvenframeConfig, error::Result};
use tracing::{error, info, warn};

/// Runs the validate command.
pub async fn run(_cli: &Cli, args: ValidateArgs) -> Result<()> {
    info!("Validating Evenframe configuration and types");

    let mut has_errors = false;

    // Validate configuration
    if !args.types_only {
        info!("Checking configuration...");
        match EvenframeConfig::new() {
            Ok(config) => {
                info!("  Configuration file: OK");
                info!("    Output path: {}", config.typesync.output_path);
                info!(
                    "    Generators: arktype={}, effect={}, macroforge={}, flatbuffers={}, protobuf={}",
                    config.typesync.should_generate_arktype_types,
                    config.typesync.should_generate_effect_types,
                    config.typesync.should_generate_macroforge_types,
                    config.typesync.should_generate_flatbuffers_types,
                    config.typesync.should_generate_protobuf_types
                );
            }
            Err(e) => {
                error!("  Configuration file: FAILED");
                error!("    Error: {}", e);
                has_errors = true;
            }
        }
    }

    // Validate types
    if !args.config_only {
        info!("Checking types...");
        match validate_types() {
            Ok((enums, tables, objects)) => {
                info!("  Types: OK");
                info!("    Enums: {}", enums);
                info!("    Tables: {}", tables);
                info!("    Objects: {}", objects);
            }
            Err(e) => {
                error!("  Types: FAILED");
                error!("    Error: {}", e);
                has_errors = true;
            }
        }
    }

    // Check database connectivity
    if args.check_db {
        info!("Checking database connectivity...");
        match check_database().await {
            Ok(_) => {
                info!("  Database: OK");
            }
            Err(e) => {
                warn!("  Database: FAILED");
                warn!("    Error: {}", e);
                // Don't fail validation for DB connectivity issues
            }
        }
    }

    if has_errors {
        error!("Validation failed with errors");
    } else {
        info!("Validation passed");
    }

    Ok(())
}

fn validate_types() -> Result<(usize, usize, usize)> {
    let config = EvenframeConfig::new()?;

    let scanner =
        WorkspaceScanner::new(config.general.apply_aliases, config.general.expand_macros)?;
    let types = scanner.scan_for_evenframe_types()?;

    if types.is_empty() {
        warn!("No Evenframe types found in workspace");
    }

    let build_config = config_builders::BuildConfig::from_toml()?;
    let (enums, tables, objects) = config_builders::build_all_configs(&build_config)?;
    Ok((enums.len(), tables.len(), objects.len()))
}

async fn check_database() -> Result<()> {
    evenframe_core::schemasync::check_database_connectivity().await
}