db-derive-impl 0.1.8

Derive proc-macro for db-derive
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

use {
    crate::sql,
    darling::{ast::Data, util::Ignored, FromDeriveInput},
    proc_macro2::TokenStream,
    syn::{DeriveInput, Generics, Ident},
};

#[derive(Debug, darling::FromDeriveInput)]
#[darling(attributes(query), supports(struct_named))]
pub struct Query {
    #[darling(default)]
    sql: Option<String>,

    #[cfg(feature = "postgresql")]
    #[darling(default)]
    postgres: Option<String>,

    #[cfg(feature = "sqlite")]
    #[darling(default)]
    sqlite: Option<String>,

    #[darling(default)]
    builder: bool,

    data: Data<Ignored, QueryField>,
    generics: Generics,
}

#[derive(Debug, darling::FromField)]
pub struct QueryField {
    ident: Option<Ident>,
}

impl Query {
    // query!(GetTagById => "SELECT Id, Name FROM Tag WHERE Id = {id: String};")
    // pub fn function(_input: DeriveInput) -> TokenStream {
    //     quote::quote! {}
    // }

    pub fn derive(input: DeriveInput) -> TokenStream {
        let query = Query::from_derive_input(&input).unwrap();

        let mut new_generics = query.generics.clone();

        new_generics.params.push(syn::parse_quote!('__query));

        let (_, type_generics, _) = query.generics.split_for_impl();
        let (impl_generics, _, where_clause) = new_generics.split_for_impl();

        let ident = &input.ident;

        let sql = sql::new_impl(
            ident,
            query.generics.clone(),
            query.sql,
            query.postgres,
            query.sqlite,
        );

        quote::quote! {
            #sql

            impl #impl_generics ::db_derive::prelude::Query<'__query> for #ident #type_generics #where_clause {}
        }
    }
}