use proc_macro::TokenStream;
use proc_macro2::TokenStream as TokenStream2;
use quote::{ToTokens, format_ident, quote};
use syn::{
Expr, FnArg, GenericArgument, Ident, ItemFn, LitBool, LitStr, Meta, Pat, PathArguments,
ReturnType, Token, Type,
parse::{Parse, ParseStream},
};
#[proc_macro_attribute]
pub fn api_get(attr: TokenStream, item: TokenStream) -> TokenStream {
expand("get", attr, item)
}
#[proc_macro_attribute]
pub fn api_post(attr: TokenStream, item: TokenStream) -> TokenStream {
expand("post", attr, item)
}
#[proc_macro_attribute]
pub fn api_put(attr: TokenStream, item: TokenStream) -> TokenStream {
expand("put", attr, item)
}
#[proc_macro_attribute]
pub fn api_delete(attr: TokenStream, item: TokenStream) -> TokenStream {
expand("delete", attr, item)
}
#[proc_macro_attribute]
pub fn api_patch(attr: TokenStream, item: TokenStream) -> TokenStream {
expand("patch", attr, item)
}
fn expand(method: &str, attr: TokenStream, item: TokenStream) -> TokenStream {
let args = syn::parse_macro_input!(attr as ApiArgs);
let mut func = syn::parse_macro_input!(item as ItemFn);
let dioxus_attr = dioxus_route_attr(method, &args.path, &args.forward);
if args.openapi == Some(false) {
return quote! {
#dioxus_attr
#func
}
.into();
}
let tag = match &args.tag {
Some(t) => t.clone(),
None => {
return syn::Error::new_spanned(
&func.sig.ident,
"api_* macros require `tag = \"...\"` (or `openapi = false`)",
)
.to_compile_error()
.into();
}
};
let path_lit = &args.path;
let path_value = path_lit.value();
let fn_ident = func.sig.ident.clone();
let openapi_fn = format_ident!("__openapi_{}", fn_ident);
let body_struct = format_ident!("__openapi_body_{}", fn_ident);
let operation_id = fn_ident.to_string();
let path_params = parse_path_params(&path_value);
let arg_map = fn_arg_map(&func);
let mut param_tokens = Vec::new();
for name in &path_params {
let Some((_, (ty, _))) = arg_map.iter().find(|(n, _)| n == name) else {
return syn::Error::new_spanned(
&func.sig.ident,
format!("path parameter `{{{name}}}` has no matching function argument"),
)
.to_compile_error()
.into();
};
let name_lit = LitStr::new(name, proc_macro2::Span::call_site());
param_tokens.push(quote! {
(#name_lit = #ty, Path, description = #name_lit)
});
}
let body_fields: Vec<_> = arg_map
.iter()
.filter(|(name, _)| !path_params.iter().any(|p| p == name))
.map(|(name, (ty, _))| {
let ident = format_ident!("{}", name);
(ident, ty.clone())
})
.collect();
let has_body = matches!(method, "post" | "put" | "patch")
&& !body_fields.is_empty()
&& args.request_body.is_none();
let request_body_override = args.request_body.clone();
let extracted_ok = match extract_result_ok(&func.sig.output) {
Ok(ty) => ty,
Err(e) => return e.to_compile_error().into(),
};
let (response_ty, content_type) = resolve_response(
args.response.clone(),
args.content_type.clone(),
extracted_ok,
);
let method_ident = format_ident!("{}", method);
let docs: Vec<_> = func
.attrs
.iter()
.filter(|a| a.path().is_ident("doc"))
.cloned()
.collect();
let _ = &mut func;
let body_struct_tokens = if has_body {
let fields = body_fields.iter().map(|(ident, ty)| {
quote! { pub #ident: #ty }
});
quote! {
#[cfg(feature = "server")]
#[derive(utoipa::ToSchema)]
#[allow(non_camel_case_types)]
#[doc(hidden)]
pub struct #body_struct {
#(#fields,)*
}
}
} else {
quote! {}
};
let request_body_tokens = if let Some(ty) = request_body_override {
quote! { request_body = #ty, }
} else if has_body {
quote! { request_body = #body_struct, }
} else {
quote! {}
};
let params_tokens = if param_tokens.is_empty() {
quote! {}
} else {
quote! { params( #(#param_tokens),* ), }
};
let content_type_tokens = match &content_type {
Some(ct) => quote! { content_type = #ct, },
None => quote! {},
};
let responses_tokens = match response_ty {
None => quote! {
responses(
(status = 200, description = "OK"),
(status = 500, description = "Server error")
)
},
Some(Type::Tuple(t)) if t.elems.is_empty() => quote! {
responses(
(status = 200, description = "OK"),
(status = 500, description = "Server error")
)
},
Some(ty) => quote! {
responses(
(status = 200, description = "OK", #content_type_tokens body = #ty),
(status = 500, description = "Server error")
)
},
};
let path_type = format_ident!("__path_{}", openapi_fn);
quote! {
#dioxus_attr
#func
#body_struct_tokens
#[cfg(feature = "server")]
#(#docs)*
#[utoipa::path(
#method_ident,
path = #path_lit,
operation_id = #operation_id,
tag = #tag,
#params_tokens
#request_body_tokens
#responses_tokens
)]
#[doc(hidden)]
pub fn #openapi_fn() {}
#[cfg(feature = "server")]
::dioxus_openapi::inventory::submit! {
::dioxus_openapi::RegisteredPath {
append: |paths| ::dioxus_openapi::append_tagged_path::<#path_type>(paths),
schemas: |schemas| {
<#path_type as ::utoipa::__dev::SchemaReferences>::schemas(schemas);
},
}
}
}
.into()
}
fn dioxus_route_attr(method: &str, path: &LitStr, forward: &[TokenStream2]) -> TokenStream2 {
let forward = forward.iter();
match method {
"get" => quote! { #[::dioxus::prelude::get(#path #(, #forward)*)] },
"post" => quote! { #[::dioxus::prelude::post(#path #(, #forward)*)] },
"put" => quote! { #[::dioxus::prelude::put(#path #(, #forward)*)] },
"delete" => quote! { #[::dioxus::prelude::delete(#path #(, #forward)*)] },
"patch" => quote! { #[::dioxus::prelude::patch(#path #(, #forward)*)] },
other => {
let msg = format!("unsupported method {other}");
quote! { compile_error!(#msg) }
}
}
}
fn is_openapi_key(ident: &Ident) -> bool {
matches!(
ident.to_string().as_str(),
"tag" | "request_body" | "response" | "content_type" | "openapi"
)
}
struct ApiArgs {
path: LitStr,
tag: Option<LitStr>,
request_body: Option<Type>,
response: Option<Type>,
content_type: Option<LitStr>,
openapi: Option<bool>,
forward: Vec<TokenStream2>,
}
impl Parse for ApiArgs {
fn parse(input: ParseStream) -> syn::Result<Self> {
let path: LitStr = input.parse()?;
let mut tag = None;
let mut request_body = None;
let mut response = None;
let mut content_type = None;
let mut openapi = None;
let mut forward = Vec::new();
while !input.is_empty() {
input.parse::<Token![,]>()?;
if input.is_empty() {
break;
}
if input.peek(Ident) && input.peek2(Token![=]) {
let ident: Ident = input.fork().parse()?;
if is_openapi_key(&ident) {
let meta: Meta = input.parse()?;
let Meta::NameValue(nv) = meta else {
return Err(syn::Error::new_spanned(
ident,
"expected `key = value` for OpenAPI options",
));
};
let key = nv
.path
.get_ident()
.ok_or_else(|| syn::Error::new_spanned(&nv.path, "expected ident key"))?;
match key.to_string().as_str() {
"tag" => tag = Some(expr_to_lit_str(&nv.value)?),
"request_body" => request_body = Some(expr_to_type(&nv.value)?),
"response" => response = Some(expr_to_type(&nv.value)?),
"content_type" => content_type = Some(expr_to_lit_str(&nv.value)?),
"openapi" => openapi = Some(expr_to_bool(&nv.value)?),
_ => unreachable!("filtered by is_openapi_key"),
}
continue;
}
forward.push(parse_forward_item(input)?);
continue;
}
if input.fork().parse::<FnArg>().is_ok() {
let arg: FnArg = input.parse()?;
forward.push(arg.into_token_stream());
continue;
}
forward.push(parse_forward_item(input)?);
}
Ok(Self {
path,
tag,
request_body,
response,
content_type,
openapi,
forward,
})
}
}
fn parse_forward_item(input: ParseStream) -> syn::Result<TokenStream2> {
let mut out = TokenStream2::new();
while !input.is_empty() {
if input.peek(Token![,]) {
break;
}
let tt: proc_macro2::TokenTree = input.parse()?;
out.extend(std::iter::once(tt));
}
if out.is_empty() {
return Err(input.error("expected attribute argument to forward to Dioxus"));
}
Ok(out)
}
fn expr_to_lit_str(expr: &Expr) -> syn::Result<LitStr> {
match expr {
Expr::Lit(syn::ExprLit {
lit: syn::Lit::Str(s),
..
}) => Ok(s.clone()),
_ => Err(syn::Error::new_spanned(expr, "expected string literal")),
}
}
fn expr_to_bool(expr: &Expr) -> syn::Result<bool> {
match expr {
Expr::Lit(syn::ExprLit {
lit: syn::Lit::Bool(LitBool { value, .. }),
..
}) => Ok(*value),
_ => Err(syn::Error::new_spanned(expr, "expected bool literal")),
}
}
fn expr_to_type(expr: &Expr) -> syn::Result<Type> {
syn::parse2(quote! { #expr })
}
fn parse_path_params(path: &str) -> Vec<String> {
let mut out = Vec::new();
let mut rest = path;
while let Some(start) = rest.find('{') {
rest = &rest[start + 1..];
let Some(end) = rest.find('}') else { break };
let name = &rest[..end];
let name = name.strip_prefix('*').unwrap_or(name);
if !name.is_empty() {
out.push(name.to_string());
}
rest = &rest[end + 1..];
}
out
}
fn fn_arg_map(func: &ItemFn) -> Vec<(String, (Type, usize))> {
let mut out = Vec::new();
for (i, arg) in func.sig.inputs.iter().enumerate() {
let FnArg::Typed(pat_ty) = arg else {
continue;
};
let Pat::Ident(pat_ident) = pat_ty.pat.as_ref() else {
continue;
};
out.push((pat_ident.ident.to_string(), ((*pat_ty.ty).clone(), i)));
}
out
}
fn extract_result_ok(ret: &ReturnType) -> syn::Result<Option<Type>> {
let ReturnType::Type(_, ty) = ret else {
return Ok(None);
};
let Type::Path(type_path) = ty.as_ref() else {
return Ok(Some(ty.as_ref().clone()));
};
let last = type_path
.path
.segments
.last()
.ok_or_else(|| syn::Error::new_spanned(ty, "empty return type path"))?;
if last.ident != "Result" {
return Ok(Some(ty.as_ref().clone()));
}
let PathArguments::AngleBracketed(args) = &last.arguments else {
return Ok(None);
};
let mut generics = args.args.iter().filter_map(|a| match a {
GenericArgument::Type(t) => Some(t.clone()),
_ => None,
});
Ok(generics.next())
}
fn type_last_ident(ty: &Type) -> Option<&Ident> {
let Type::Path(type_path) = ty else {
return None;
};
type_path.path.segments.last().map(|s| &s.ident)
}
fn first_type_arg(ty: &Type) -> Option<Type> {
let Type::Path(type_path) = ty else {
return None;
};
let last = type_path.path.segments.last()?;
let PathArguments::AngleBracketed(args) = &last.arguments else {
return None;
};
args.args.iter().find_map(|a| match a {
GenericArgument::Type(t) => Some(t.clone()),
_ => None,
})
}
fn resolve_response(
response_override: Option<Type>,
content_type_override: Option<LitStr>,
extracted_ok: Option<Type>,
) -> (Option<Type>, Option<LitStr>) {
if let Some(ty) = response_override {
return (Some(ty), content_type_override);
}
let Some(ok) = extracted_ok else {
return (None, content_type_override);
};
if type_last_ident(&ok).is_some_and(|id| id == "ServerEvents") {
let inner = first_type_arg(&ok).unwrap_or(ok);
let ct = content_type_override
.unwrap_or_else(|| LitStr::new("text/event-stream", proc_macro2::Span::call_site()));
return (Some(inner), Some(ct));
}
(Some(ok), content_type_override)
}