vespertide_macro/
lib.rs

1// MigrationOptions and MigrationError are now in vespertide-core
2
3mod loader;
4
5use proc_macro::TokenStream;
6use quote::quote;
7use syn::parse::{Parse, ParseStream};
8use syn::{Expr, Ident, Token, parse_macro_input};
9use vespertide_query::build_plan_queries;
10
11struct MacroInput {
12    pool: Expr,
13    version_table: Option<String>,
14}
15
16impl Parse for MacroInput {
17    fn parse(input: ParseStream) -> syn::Result<Self> {
18        let pool = input.parse()?;
19        let mut version_table = None;
20
21        while !input.is_empty() {
22            input.parse::<Token![,]>()?;
23            if input.is_empty() {
24                break;
25            }
26
27            let key: Ident = input.parse()?;
28            if key == "version_table" {
29                input.parse::<Token![=]>()?;
30                let value: syn::LitStr = input.parse()?;
31                version_table = Some(value.value());
32            } else {
33                return Err(syn::Error::new(
34                    key.span(),
35                    "unsupported option for vespertide_migration!",
36                ));
37            }
38        }
39
40        Ok(MacroInput {
41            pool,
42            version_table,
43        })
44    }
45}
46
47/// Zero-runtime migration entry point.
48#[proc_macro]
49pub fn vespertide_migration(input: TokenStream) -> TokenStream {
50    let input = parse_macro_input!(input as MacroInput);
51    let pool = &input.pool;
52    let version_table = input
53        .version_table
54        .unwrap_or_else(|| "vespertide_version".to_string());
55
56    // Load migration files and build SQL at compile time
57    let migrations = match loader::load_migrations_at_compile_time() {
58        Ok(migrations) => migrations,
59        Err(e) => {
60            return syn::Error::new(
61                proc_macro2::Span::call_site(),
62                format!("Failed to load migrations at compile time: {}", e),
63            )
64            .to_compile_error()
65            .into();
66        }
67    };
68
69    // Build SQL for each migration
70    let mut migration_blocks = Vec::new();
71    for migration in &migrations {
72        let version = migration.version;
73        let queries = match build_plan_queries(migration) {
74            Ok(queries) => queries,
75            Err(e) => {
76                return syn::Error::new(
77                    proc_macro2::Span::call_site(),
78                    format!(
79                        "Failed to build queries for migration version {}: {}",
80                        version, e
81                    ),
82                )
83                .to_compile_error()
84                .into();
85            }
86        };
87
88        // Statically embed SQL text and bind parameters (as values)
89        let sql_statements: Vec<_> = queries
90            .iter()
91            .map(|q| {
92                let sql = &q.sql;
93                let binds = &q.binds;
94                let value_tokens = binds.iter().map(|b| {
95                    quote! { sea_orm::Value::String(Some(#b.to_string())) }
96                });
97                quote! { (#sql, vec![#(#value_tokens),*]) }
98            })
99            .collect();
100
101        // Generate version guard and SQL execution block
102        let block = quote! {
103            if version < #version {
104                // Begin transaction
105                let txn = __pool.begin().await.map_err(|e| {
106                    ::vespertide::MigrationError::DatabaseError(format!("Failed to begin transaction: {}", e))
107                })?;
108
109                // Execute SQL statements
110                #(
111                    {
112                        let (sql, values) = #sql_statements;
113                        let stmt = sea_orm::Statement::from_sql_and_values(backend, sql, values);
114                        txn.execute_raw(stmt).await.map_err(|e| {
115                            ::vespertide::MigrationError::DatabaseError(format!("Failed to execute SQL: {}", e))
116                        })?;
117                    }
118                )*
119
120                // Insert version record for this migration
121                let stmt = sea_orm::Statement::from_sql_and_values(
122                    backend,
123                    &format!("INSERT INTO {} (version) VALUES (?)", version_table),
124                    vec![sea_orm::Value::Int(Some(#version as i32))],
125                );
126                txn.execute_raw(stmt).await.map_err(|e| {
127                    ::vespertide::MigrationError::DatabaseError(format!("Failed to insert version: {}", e))
128                })?;
129
130                // Commit transaction
131                txn.commit().await.map_err(|e| {
132                    ::vespertide::MigrationError::DatabaseError(format!("Failed to commit transaction: {}", e))
133                })?;
134            }
135        };
136
137        migration_blocks.push(block);
138    }
139
140    // Emit final generated async block
141    let generated = quote! {
142        async {
143            use sea_orm::{ConnectionTrait, TransactionTrait};
144            let __pool = #pool;
145            let version_table = #version_table;
146            let backend = __pool.get_database_backend();
147
148            // Create version table if it does not exist
149            // Table structure: version (INTEGER PRIMARY KEY), created_at (timestamp)
150            let create_table_sql = format!(
151                "CREATE TABLE IF NOT EXISTS {} (version INTEGER PRIMARY KEY, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP)",
152                version_table
153            );
154            let stmt = sea_orm::Statement::from_string(backend, create_table_sql);
155            __pool.execute_raw(stmt).await.map_err(|e| {
156                ::vespertide::MigrationError::DatabaseError(format!("Failed to create version table: {}", e))
157            })?;
158
159            // Read current maximum version (latest applied migration)
160            let stmt = sea_orm::Statement::from_string(
161                backend,
162                format!("SELECT MAX(version) as version FROM {}", version_table),
163            );
164            let version_result = __pool.query_one_raw(stmt).await.map_err(|e| {
165                ::vespertide::MigrationError::DatabaseError(format!("Failed to read version: {}", e))
166            })?;
167
168            let mut version = version_result
169                .and_then(|row| row.try_get::<i32>("", "version").ok())
170                .unwrap_or(0) as u32;
171
172            // Execute each migration block
173            #(#migration_blocks)*
174
175            Ok::<(), ::vespertide::MigrationError>(())
176        }
177    };
178
179    generated.into()
180}
vespertide_macro/lib.rs

vespertide_macro/
lib.rs
