ngyn_macros/
lib.rs

1extern crate proc_macro;
2
3mod common {
4    pub mod handler;
5    pub mod service;
6    pub mod state;
7}
8mod core {
9    pub mod dto;
10    pub mod param;
11    pub mod query;
12}
13
14use crate::core::dto::dto_macro;
15use crate::core::param::param_macro;
16use crate::core::query::query_macro;
17use common::handler::handler_macro;
18use common::service::service_macro;
19use proc_macro::TokenStream;
20
21/// Attribute macro to define a route handler function with optional gates and middlewares
22/// options in async functions.
23#[proc_macro_attribute]
24pub fn handler(args: TokenStream, input: TokenStream) -> TokenStream {
25    handler_macro(args, input)
26}
27
28#[proc_macro_derive(Dto)]
29/// The `Dto` derive macro is used to generate a DTO struct.
30///
31/// ### Example
32/// ```rust ignore
33/// #[derive(Dto)]
34/// struct MyDto {
35///     // fields
36/// }
37/// ```
38pub fn dto_derive_dto(input: TokenStream) -> TokenStream {
39    dto_macro(input)
40}
41
42#[proc_macro_derive(Service)]
43/// The `Service` derive macro is used to generate a Service.
44///
45/// ### Example
46/// ```rust ignore
47/// #[derive(Service)]
48/// struct MyService {
49///     // fields
50/// }
51/// ```
52pub fn service_derive_dto(input: TokenStream) -> TokenStream {
53    service_macro(input)
54}
55
56#[proc_macro_derive(Query)]
57/// The `Query` derive macro is used to derive a struct that can be used to parse query parameters.
58///
59/// ### Example
60/// ```rust ignore
61/// #[derive(Query)]
62/// struct MyQuery {
63///    page: u32,
64///   limit: u32,
65/// }
66/// ```
67pub fn query_derive_macro(input: TokenStream) -> TokenStream {
68    query_macro(input)
69}
70
71#[proc_macro_derive(Param)]
72/// The `Param` derive macro is used to derive a struct that can be used to parse route parameters.
73///
74/// ### Example
75/// ```rust ignore
76/// #[derive(Param)]
77/// struct MyParam {
78///   id: u32,
79/// }
80/// ```
81pub fn param_derive_macro(input: TokenStream) -> TokenStream {
82    param_macro(input)
83}
84
85#[proc_macro_derive(AppState)]
86/// The `AppState` derive macro is used to derive a struct that can be used as a state in a server.
87///
88/// ### Example
89/// ```rust ignore
90/// #[derive(AppState)]
91/// struct MyState {
92///    // fields
93/// }
94/// ```
95pub fn app_state_derive_macro(input: TokenStream) -> TokenStream {
96    common::state::derive_app_state_macro(input)
97}