evenframe_derive 0.1.4

Derive macros for Evenframe - automatic database schema and CRUD generation
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use proc_macro::TokenStream;
use syn::{Data, DeriveInput, parse_macro_input};
mod deserialization_impl;
mod enum_impl;
mod imports;
mod struct_impl;
mod union_impl;

/// Which pipeline(s) the derived type participates in.
/// This is a local mirror used to generate the correct `::evenframe::types::Pipeline` tokens.
#[derive(Clone, Copy)]
pub(crate) enum PipelineKind {
    Both,
    Typesync,
    Schemasync,
}

impl PipelineKind {
    pub fn to_tokens(self) -> proc_macro2::TokenStream {
        use quote::quote;
        match self {
            PipelineKind::Both => quote! { ::evenframe::types::Pipeline::Both },
            PipelineKind::Typesync => quote! { ::evenframe::types::Pipeline::Typesync },
            PipelineKind::Schemasync => quote! { ::evenframe::types::Pipeline::Schemasync },
        }
    }
}

/// For structs it generates both:
/// - A `table_schema()` function returning a `helpers::TableSchema`
#[proc_macro_derive(
    Evenframe,
    attributes(
        edge,
        define_field_statement,
        format,
        permissions,
        mock_data,
        validators,
        relation,
        event,
        doccom,
        macroforge_derive,
        annotation,
        unique
    )
)]
pub fn evenframe_derive(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    match input.data {
        Data::Struct(_) => struct_impl::generate_struct_impl(input, PipelineKind::Both).into(),
        Data::Enum(_) => enum_impl::generate_enum_impl(input, PipelineKind::Both).into(),
        _ => syn::Error::new(
            input.ident.span(),
            "Evenframe can only be used on structs and enums",
        )
        .to_compile_error()
        .into(),
    }
}

/// Derive macro for unions of persistable structs
/// Each variant must contain exactly one persistable struct type
#[proc_macro_derive(EvenframeUnion, attributes(macroforge_derive, annotation))]
pub fn evenframe_union_derive(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    match input.data {
        Data::Enum(_) => union_impl::generate_union_impl(input).into(),
        _ => syn::Error::new(
            input.ident.span(),
            "EvenframeUnion can only be used on enums",
        )
        .to_compile_error()
        .into(),
    }
}

/// Derive macro for types that only participate in TypeScript type generation.
#[proc_macro_derive(
    Typesync,
    attributes(
        edge,
        define_field_statement,
        format,
        permissions,
        mock_data,
        validators,
        relation,
        event,
        doccom,
        macroforge_derive,
        annotation,
        unique
    )
)]
pub fn typesync_derive(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    match input.data {
        Data::Struct(_) => struct_impl::generate_struct_impl(input, PipelineKind::Typesync).into(),
        Data::Enum(_) => enum_impl::generate_enum_impl(input, PipelineKind::Typesync).into(),
        _ => syn::Error::new(
            input.ident.span(),
            "Typesync can only be used on structs and enums",
        )
        .to_compile_error()
        .into(),
    }
}

/// Derive macro for types that only participate in database schema synchronization.
#[proc_macro_derive(
    Schemasync,
    attributes(
        edge,
        define_field_statement,
        format,
        permissions,
        mock_data,
        validators,
        relation,
        event,
        doccom,
        macroforge_derive,
        annotation,
        unique
    )
)]
pub fn schemasync_derive(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    match input.data {
        Data::Struct(_) => {
            struct_impl::generate_struct_impl(input, PipelineKind::Schemasync).into()
        }
        Data::Enum(_) => enum_impl::generate_enum_impl(input, PipelineKind::Schemasync).into(),
        _ => syn::Error::new(
            input.ident.span(),
            "Schemasync can only be used on structs and enums",
        )
        .to_compile_error()
        .into(),
    }
}