oblivion_codegen/
lib.rs

1//! # Oblivion Macros
2//!
3//! Oblivion use Rust macros to implement the business function processing and routing system,
4//! which allows you to use synchronous or asynchronous functions.
5
6use proc_macro::TokenStream;
7use quote::quote;
8use syn::{parse_macro_input, ItemFn};
9
10enum ReturnType {
11    ServerResponse,
12    String,
13    Json,
14    Result(Box<Self>),
15}
16
17fn extract_result_return_type(segment: &syn::PathSegment) -> Option<ReturnType> {
18    assert!(segment.ident == "Result");
19    match &segment.arguments {
20        syn::PathArguments::AngleBracketed(args) => {
21            let ok_type = args.args[0].clone();
22
23            if let syn::GenericArgument::Type(syn::Type::Path(type_path)) = ok_type {
24                assert!(type_path.path.segments.len() == 1);
25                match type_path.path.segments[0].ident.to_string().as_str() {
26                    "ServerResponse" => {
27                        Some(ReturnType::Result(Box::new(ReturnType::ServerResponse)))
28                    }
29                    "String" => Some(ReturnType::Result(Box::new(ReturnType::String))),
30                    "Value" => Some(ReturnType::Result(Box::new(ReturnType::Json))),
31                    _ => None,
32                }
33            } else {
34                None
35            }
36        }
37        _ => None,
38    }
39}
40
41/// ## Oblivion Macro for Route Handler
42#[proc_macro_attribute]
43pub fn async_route(_: TokenStream, item: TokenStream) -> TokenStream {
44    let input = parse_macro_input!(item as ItemFn);
45
46    let func_name = &input.sig.ident;
47    let func_args = &input.sig.inputs;
48    let func_return = match &input.sig.output {
49        syn::ReturnType::Default => {
50            return TokenStream::from(
51                quote! { compile_error!("Handler function must have a return type"); },
52            )
53        }
54        syn::ReturnType::Type(_, ty) => ty,
55    };
56
57    let return_type = match &input.sig.output {
58        syn::ReturnType::Default => {
59            return TokenStream::from(
60                quote! { compile_error!("Handler function must have a return type"); },
61            )
62        }
63        syn::ReturnType::Type(_, ty) => match ty.as_ref() {
64            syn::Type::Path(type_path) => {
65                if type_path.path.segments.len() == 1 {
66                    match type_path.path.segments[0].ident.to_string().as_str() {
67                        "ServerResponse" => ReturnType::ServerResponse,
68                        "String" => ReturnType::String,
69                        "Value" => ReturnType::Json,
70                        "Result" => {
71                            let extracted_type =
72                                extract_result_return_type(&type_path.path.segments[0]);
73                            if extracted_type.is_none() {
74                                return TokenStream::from(
75                                    quote! { compile_error!("Unsupported [Result] return type")},
76                                );
77                            }
78                            extracted_type.unwrap()
79                        }
80                        _ => {
81                            return TokenStream::from(
82                                quote! { compile_error!("Unsupported path like return type"); },
83                            )
84                        }
85                    }
86                } else {
87                    return TokenStream::from(
88                        quote! { compile_error!("Unsupported complex path like return type"); },
89                    );
90                }
91            }
92            _ => return TokenStream::from(quote! { compile_error!("Unsupported return type"); }),
93        },
94    };
95    let input_block = &input.block;
96    let func_block = match return_type {
97        ReturnType::ServerResponse => quote! {
98            Box::pin(async move {
99                #input_block
100            })
101        },
102        ReturnType::String | ReturnType::Json => quote! {
103            Box::pin(async move {
104                let result = async move {
105                    #input_block
106                }.await;
107                Ok(result.into())
108            })
109        },
110        ReturnType::Result(return_type) => match *return_type {
111            ReturnType::String | ReturnType::Json => quote! {
112                Box::pin(async move {
113                    let result: #func_return = async move {
114                        #input_block
115                    }.await;
116                    Ok(result?.into())
117                })
118            },
119            ReturnType::ServerResponse => {
120                return TokenStream::from(
121                    quote! { compile_error!("Unsupported [ServerResponse] in [Result] return type")},
122                )
123            }
124            ReturnType::Result(_) => {
125                return TokenStream::from(
126                    quote! { compile_error!("Unsupported complex [Result] return type")},
127                )
128            }
129        },
130    };
131
132    let expanded = quote! {
133        use oblivion::prelude::*;
134
135        pub fn #func_name(#func_args) -> ServerResponse {
136            #func_block
137        }
138    };
139
140    TokenStream::from(expanded)
141}
142
143#[proc_macro_attribute]
144pub fn internal_handler(_input: TokenStream, item: TokenStream) -> TokenStream {
145    let input = parse_macro_input!(item as ItemFn);
146
147    let func_name = &input.sig.ident;
148    let func_args = &input.sig.inputs;
149    let func_block = &input.block;
150    let func_return = &input.sig.output;
151
152    let expanded = quote! {
153        pub fn #func_name(#func_args) #func_return {
154            Box::pin(async move { #func_block })
155        }
156    };
157
158    TokenStream::from(expanded)
159}