modelstruct_derive 0.1.0

A Rust crate that provides a derive macro Model to automatically generate SQL CREATE TABLE IF NOT EXISTS statements from struct definitions.
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

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, Data, DeriveInput, Type, PathArguments, GenericArgument};

/// Maps Rust types to SQL types
fn rust_type_to_sql(ty: &Type) -> Option<String> {
    match ty {
        Type::Path(type_path) => {
            let path = &type_path.path;
            let segments = &path.segments;
            
            if segments.is_empty() {
                return None;
            }
            
            let last_segment = &segments[segments.len() - 1];
            let ident = &last_segment.ident;
            
            // Handle Option<T>
            if ident == "Option" {
                if let PathArguments::AngleBracketed(args) = &last_segment.arguments {
                    if let Some(GenericArgument::Type(inner_type)) = args.args.first() {
                        if let Some(sql_type) = rust_type_to_sql(inner_type) {
                            return Some(format!("{} NULL", sql_type));
                        }
                    }
                }
                return None;
            }
            
            // Map basic types
            match ident.to_string().as_str() {
                "i8" | "i16" | "i32" => Some("INTEGER".to_string()),
                "i64" => Some("BIGINT".to_string()),
                "u8" | "u16" | "u32" => Some("INTEGER".to_string()),
                "u64" => Some("BIGINT".to_string()),
                "f32" | "f64" => Some("REAL".to_string()),
                "bool" => Some("BOOLEAN".to_string()),
                "String" => Some("TEXT".to_string()),
                "str" => Some("TEXT".to_string()),
                _ => None,
            }
        }
        _ => None,
    }
}

/// Derive macro for generating SQL table creation code
#[proc_macro_derive(Model)]
pub fn derive_model(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let name = &input.ident;
    
    let fields = match &input.data {
        Data::Struct(data) => &data.fields,
        _ => panic!("Model derive macro only supports structs"),
    };
    
    let mut column_definitions = Vec::new();
    
    for field in fields.iter() {
        let field_name = field.ident.as_ref().unwrap();
        let field_type = &field.ty;
        
        if let Some(sql_type) = rust_type_to_sql(field_type) {
            column_definitions.push(format!("    {} {}", field_name, sql_type));
        } else {
            panic!("Unsupported field type for field '{}'", field_name);
        }
    }
    
    let table_name = name.to_string().to_lowercase();
    let columns = column_definitions.join(",\n");
    let sql_statement = format!("CREATE TABLE IF NOT EXISTS {} (\n{}\n);", table_name, columns);
    
    let expanded = quote! {
        impl modelstruct::Model for #name {
            fn create_table_sql() -> String {
                #sql_statement.to_string()
            }
            
            fn table_name() -> String {
                #table_name.to_string()
            }
        }
    };
    
    TokenStream::from(expanded)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_basic_types() {
        assert_eq!(rust_type_to_sql(&syn::parse_str::<Type>("i32").unwrap()), Some("INTEGER".to_string()));
        assert_eq!(rust_type_to_sql(&syn::parse_str::<Type>("String").unwrap()), Some("TEXT".to_string()));
        assert_eq!(rust_type_to_sql(&syn::parse_str::<Type>("bool").unwrap()), Some("BOOLEAN".to_string()));
    }
    
    #[test]
    fn test_option_types() {
        assert_eq!(rust_type_to_sql(&syn::parse_str::<Type>("Option<i32>").unwrap()), Some("INTEGER NULL".to_string()));
        assert_eq!(rust_type_to_sql(&syn::parse_str::<Type>("Option<String>").unwrap()), Some("TEXT NULL".to_string()));
    }
}