1use 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#[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}