dactyl-db-macros 0.2.1

Proc macros for dactyl-db. Implements the `query!` compile-time analyzer.
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

//! `dactyl::query!` proc macro.
//!
//! Lexically analyzes the SQL literal at compile time so:
//
//!   1. Hard-coded constructs are visible to the analyzer before the crate
//!      is built.
//!   2. The literal is rewritten (currently identity) at compile time so the
//!      runtime path stays allocation-light.
//!   3. Empty literals fail to compile with a clear message.
//!
//! The expanded form returns a `String` containing the (rewritten) SQL.
//! Callers wire it into `dactyl::query` directly:
//!
//! ```ignore
//! let rows = dactyl_db::query(&dactyl_db::query!("select id, title from todos"), &[])?;
//! ```

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, LitStr};

/// `dactyl::query!("literal")` — returns the rewritten SQL as a `String`.
#[proc_macro]
pub fn query(input: TokenStream) -> TokenStream {
    let literal = parse_macro_input!(input as LitStr);
    let text = literal.value();

    if text.trim().is_empty() {
        return syn::Error::new_spanned(literal, "`query!` requires a non-empty SQL literal")
            .to_compile_error()
            .into();
    }

    let rewritten = rewrite(&text);

    let expanded = quote! {{
        // Compile-time lexer: hard-fails on unparseable input. The runtime
        // call is a no-op identity rewrite, kept so the contract is uniform
        // with non-literal queries.
        let __text: &str = #rewritten;
        ::dactyl_db::__private::analyze(__text).sql
    }};

    expanded.into()
}

/// Identity rewrite — placeholder for the real rewriter. Kept as a
/// function so swapping in the structured rewriter is a one-line change.
fn rewrite(input: &str) -> String {
    input.to_string()
}