prax-orm-cli 0.11.1

CLI tool for the Prax ORM
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
128
129
130

//! CLI error types and result alias.

use miette::Diagnostic;
use thiserror::Error;

/// Result type alias for CLI operations
pub type CliResult<T> = Result<T, CliError>;

/// CLI error types
#[derive(Error, Debug, Diagnostic)]
pub enum CliError {
    /// IO error
    #[error("IO error: {0}")]
    #[diagnostic(code(prax::io))]
    Io(#[from] std::io::Error),

    /// Configuration error
    #[error("Configuration error: {0}")]
    #[diagnostic(code(prax::config))]
    Config(String),

    /// Schema parsing error
    #[error("Schema error: {0}")]
    #[diagnostic(code(prax::schema))]
    Schema(String),

    /// Validation error
    #[error("Validation error: {0}")]
    #[diagnostic(code(prax::validation))]
    Validation(String),

    /// Migration error
    #[error("Migration error: {0}")]
    #[diagnostic(code(prax::migration))]
    Migration(String),

    /// Database error
    #[error("Database error: {0}")]
    #[diagnostic(code(prax::database))]
    Database(String),

    /// Command error
    #[error("Command error: {0}")]
    #[diagnostic(code(prax::command))]
    Command(String),

    /// Format error
    #[error("Format error: {0}")]
    #[diagnostic(code(prax::format))]
    Format(String),

    /// Code generation error
    #[error("Codegen error: {0}")]
    #[diagnostic(code(prax::codegen))]
    Codegen(String),
}

impl From<toml::de::Error> for CliError {
    fn from(err: toml::de::Error) -> Self {
        CliError::Config(format!("Failed to parse TOML: {}", err))
    }
}

impl From<toml::ser::Error> for CliError {
    fn from(err: toml::ser::Error) -> Self {
        CliError::Config(format!("Failed to serialize TOML: {}", err))
    }
}

impl From<prax_schema::LoadError> for CliError {
    fn from(e: prax_schema::LoadError) -> Self {
        use prax_schema::SchemaError;
        // Resolve SourceId references to file paths for human-readable output.
        let resolved = render_schema_error(&e.error, &e.sources);
        match &e.error {
            SchemaError::ValidationFailed { .. } => CliError::Validation(resolved),
            _ => CliError::Schema(resolved),
        }
    }
}

impl From<prax_schema::SchemaError> for CliError {
    fn from(e: prax_schema::SchemaError) -> Self {
        use prax_schema::SchemaError;
        match &e {
            SchemaError::ValidationFailed { .. } => CliError::Validation(e.to_string()),
            _ => CliError::Schema(e.to_string()),
        }
    }
}

/// Render a SchemaError with file paths resolved from the SourceMap.
fn render_schema_error(err: &prax_schema::SchemaError, sources: &prax_schema::SourceMap) -> String {
    use prax_schema::SchemaError;
    use std::fmt::Write;

    let mut out = err.to_string();
    match err {
        SchemaError::ParseInFile { source, inner } => {
            if let Some(p) = sources.path_of(*source) {
                let _ = write!(out, "\n  in: {}\n  detail: {}", p.display(), inner);
            }
        }
        SchemaError::DuplicateAcrossFiles { first, second, .. }
        | SchemaError::MultipleDatasource { first, second } => {
            if let (Some(a), Some(b)) = (
                sources.path_of(first.source),
                sources.path_of(second.source),
            ) {
                let _ = write!(
                    out,
                    "\n  first:  {} (bytes {}..{})\n  second: {} (bytes {}..{})",
                    a.display(),
                    first.span.start,
                    first.span.end,
                    b.display(),
                    second.span.start,
                    second.span.end,
                );
            }
        }
        SchemaError::ValidationFailed { errors, .. } => {
            for (i, e) in errors.iter().enumerate() {
                let _ = write!(out, "\n  {}. {}", i + 1, render_schema_error(e, sources));
            }
        }
        _ => {}
    }
    out
}