uf-valence-codegen 0.1.1

Valence schema codegen (caller-supplied roots)
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

//! Turn one schema source file into formatted Rust: merge traits, validate, run all generators.
//!
//! Used by [`crate::generate_models`] and by unit tests. Submodules: `parser`, `schema`,
//! `validation`, `generators`.

use proc_macro2::TokenStream;
use std::collections::HashMap;
use std::fs;
use std::path::Path;

mod generators;
pub mod parser;
mod schema;
mod utils;
mod validation;

#[cfg(test)]
mod tests;

/// Read a `valence_schema!` file, merge any listed traits, validate, and return pretty-printed Rust source.
pub fn generate_from_schema_file(
    path: &Path,
    trait_defs: &HashMap<String, parser::ParsedTraitDef>,
) -> Result<String, Box<dyn std::error::Error>> {
    let content = fs::read_to_string(path)?;

    let mut parsed_file = parser::extract_schema_from_macro(&content)?;

    // Merge trait fields and connections into the schema
    for trait_name in &parsed_file.schema.traits.clone() {
        if let Some(trait_def) = trait_defs.get(trait_name) {
            for field in &trait_def.fields {
                if !parsed_file
                    .schema
                    .fields
                    .iter()
                    .any(|f| f.name == field.name)
                {
                    let mut merged = field.clone();
                    if merged.field_type.starts_with("enum:") && merged.enum_type.is_none() {
                        merged.enum_type = Some(format!(
                            "{}{}",
                            trait_name,
                            utils::to_pascal_case(&merged.name)
                        ));
                    }
                    parsed_file.schema.fields.push(merged);
                }
            }
            for conn in &trait_def.connections {
                if !parsed_file
                    .schema
                    .connections
                    .iter()
                    .any(|c| c.name == conn.name)
                {
                    let mut merged = conn.clone();
                    merged.from_table = parsed_file.schema.name.clone();
                    parsed_file.schema.connections.push(merged);
                }
            }
        }
    }

    validation::validate_connections_and_fields(&parsed_file.schema)
        .map_err(|e| format!("Schema validation failed: {e}"))?;

    let schema = schema::SchemaContext::from_parsed(parsed_file)?;

    let mut tokens = TokenStream::new();

    tokens.extend(generators::generate_struct(&schema)?);
    tokens.extend(generators::generate_connections(&schema)?);
    tokens.extend(generators::generate_side_effects(&schema)?);
    tokens.extend(generators::generate_iters(&schema)?);
    tokens.extend(generators::generate_crud_operations(&schema)?);
    tokens.extend(generators::generate_query_builder(&schema)?);
    tokens.extend(generators::generate_schema_metadata_method(&schema)?);

    // Generate trait impl blocks for each trait this schema implements
    tokens.extend(generators::generate_trait_impls(&schema, trait_defs)?);

    Ok(prettyplease::unparse(&syn::parse_file(
        &tokens.to_string(),
    )?))
}

/// Read a `valence_trait_schema!` file and return pretty-printed trait/query definition Rust source.
pub fn generate_from_trait_file(path: &Path) -> Result<String, Box<dyn std::error::Error>> {
    let content = fs::read_to_string(path)?;
    let trait_def = parser::extract_trait_from_file(&content)?;

    let tokens = generators::generate_trait_definition(&trait_def)?;

    Ok(prettyplease::unparse(&syn::parse_file(
        &tokens.to_string(),
    )?))
}