rust-db-blueprint 0.1.0

A Rust code generator — reads YAML draft files and generates Axum + SQLx models, migrations, handlers, routes, requests, tests, and seeds
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

use crate::models::Column;

pub struct Rules;

impl Rules {
    /// Translate a column definition into Laravel validation rules
    pub fn from_column(column: &Column) -> Vec<String> {
        let mut rules = vec![];

        // Required rule
        if !column.has_modifier("nullable") {
            rules.push("required".to_string());
        } else {
            rules.push("nullable".to_string());
        }

        // Type-based rules
        match column.data_type.as_str() {
            "string" | "char" => {
                rules.push("string".to_string());
                if let Some(attr) = column.attributes.first() {
                    if let Ok(max) = attr.parse::<usize>() {
                        rules.push(format!("max:{}", max));
                    }
                }
            }
            "text" | "longtext" | "mediumtext" => {
                rules.push("string".to_string());
            }
            "integer" | "bigInteger" | "smallInteger" | "tinyInteger" | "mediumInteger" => {
                rules.push("integer".to_string());
            }
            "unsignedInteger" | "unsignedBigInteger" | "unsignedSmallInteger"
            | "unsignedTinyInteger" | "unsignedMediumInteger" => {
                rules.push("integer".to_string());
            }
            "boolean" => {
                rules.push("boolean".to_string());
            }
            "float" | "double" => {
                rules.push("numeric".to_string());
            }
            "decimal" => {
                rules.push("numeric".to_string());
            }
            "date" => {
                rules.push("date".to_string());
            }
            "datetime" | "timestamp" | "datetimeTz" | "timestampTz" => {
                rules.push("date".to_string());
            }
            "email" => {
                rules.push("email".to_string());
            }
            "ipAddress" => {
                rules.push("ip".to_string());
            }
            "macAddress" => {
                rules.push("regex:/^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/".to_string());
            }
            "url" => {
                rules.push("url".to_string());
            }
            "uuid" => {
                rules.push("uuid".to_string());
            }
            "ulid" => {
                rules.push("string".to_string());
            }
            "json" | "jsonb" => {
                rules.push("json".to_string());
            }
            "enum" => {
                rules.push("string".to_string());
                if !column.attributes.is_empty() {
                    let values: Vec<String> = column.attributes
                        .iter()
                        .flat_map(|a| a.split(','))
                        .map(|v| v.trim().to_string())
                        .collect();
                    rules.push(format!("in:{}", values.join(",")));
                }
            }
            _ => {}
        }

        // Unique rule
        if column.has_modifier("unique") {
            rules.push(format!("unique:{}", column.name));
        }

        rules
    }
}