byteorm 0.1.6

A lightweight ORM for Rust
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
131
132
133
134
135
136

// src/parser.rs
use pest::iterators::Pair;
use crate::ast::*;
use crate::{Rule, SchemaParser};
use pest::Parser;

pub fn parse_schema(src: &str) -> Result<Schema, String> {
    SchemaParser::parse(Rule::schema, src)
        .map_err(|e| format!("Parse error: {}", e))
        .and_then(|mut pairs| {
            let schema_pair = pairs.next().ok_or("Empty schema")?;
            Ok(build_ast(schema_pair))
        })
}

pub(crate) fn build_ast(pair: Pair<Rule>) -> Schema {
    let mut models = Vec::new();
    for inner in pair.into_inner() {
        match inner.as_rule() {
            Rule::model_decl => models.push(parse_model(inner)),
            _ => (),
        }
    }
    Schema { models }
}

fn parse_model(pair: Pair<Rule>) -> Model {
    let mut pairs = pair.into_inner();
    let name = pairs.next().unwrap().as_str().to_string();
    let mut fields = Vec::new();
    for pair in pairs {
        if matches!(pair.as_rule(), Rule::field_decl) {
            fields.push(parse_field(pair));
        }
    }
    Model { name, fields }
}

fn parse_field(pair: Pair<Rule>) -> Field {
    let mut pairs = pair.into_inner();
    let name = pairs.next().unwrap().as_str().to_string();
    let mut raw_type_name = pairs.next().unwrap().as_str().to_string();

    let mut modifiers = Vec::new();
    let mut attributes = Vec::new();

    let mut is_nullable = false;
    if raw_type_name.ends_with('?') {
        is_nullable = true;
        raw_type_name = raw_type_name.trim_end_matches('?').to_string();
    }

    for pair in pairs {
        match pair.as_rule() {
            Rule::modifier => {
                if let Ok(m) = parse_modifier(pair) {
                    modifiers.push(m);
                }
            }
            Rule::attr => attributes.push(parse_attribute(pair)),
            _ => (),
        }
    }

    if is_nullable {
        modifiers.push(Modifier::Nullable);
    } else if !modifiers.iter().any(|m| matches!(m, Modifier::NotNull | Modifier::PrimaryKey)) {
        modifiers.push(Modifier::NotNull);
    }

    Field {
        name,
        type_name: raw_type_name,
        modifiers,
        attributes,
    }
}

fn parse_modifier(pair: Pair<Rule>) -> Result<Modifier, String> {
    let mut inner = pair.into_inner();
    let mod_name = inner.next().unwrap().as_str();
    let args = inner.next().map(|p| {
        p.into_inner()
            .next()
            .map(|ac| ac.as_str().trim().to_string())
            .unwrap_or_default()
    });

    match mod_name {
        "PrimaryKey" => Ok(Modifier::PrimaryKey),
        "NotNull" => Ok(Modifier::NotNull),
        "Nullable" => Ok(Modifier::Nullable),
        "Unique" => Ok(Modifier::Unique),
        "ForeignKey" => parse_foreign_key(args),
        _ => Err(format!("Unknown modifier: {}", mod_name)),
    }
}

fn parse_foreign_key(args: Option<String>) -> Result<Modifier, String> {
    let arg_str = args.ok_or("ForeignKey requires arguments")?;
    
    if let Some(dot_pos) = arg_str.find('.') {
        let model = arg_str[..dot_pos].trim().to_string();
        let field = arg_str[dot_pos + 1..].trim().to_string();
        return Ok(Modifier::ForeignKey {
            model,
            field: Some(field),
        });
    }

    if let Some(paren_pos) = arg_str.find('(') {
        let model = arg_str[..paren_pos].trim().to_string();
        if let Some(close_pos) = arg_str.find(')') {
            let field = arg_str[paren_pos + 1..close_pos].trim().to_string();
            return Ok(Modifier::ForeignKey {
                model,
                field: Some(field),
            });
        }
    }

    Ok(Modifier::ForeignKey {
        model: arg_str,
        field: None,
    })
}

fn parse_attribute(pair: Pair<Rule>) -> Attribute {
    let mut inner = pair.into_inner();
    let name = inner.next().unwrap().as_str().to_string();
    let args = inner.next().map(|p| {
        p.as_str().to_string()
    });
    Attribute { name, args }
}