Skip to main content

arcature_macros/
lib.rs

1//! Proc-macro crate for Arcature.
2//!
3//! Provides the attribute/derive macros that power the Arcature developer
4//! experience:
5//! - `#[model(table = "users")]` — a SeaORM entity model with the query facade.
6//! - `#[request]` — a validated request struct (with `#[validate(...)]` rules).
7//! - `#[controller]` — an Axum controller with route metadata.
8//! - `#[derive(Job)]` — a typed background job with a `JobModel` const.
9//! - `#[derive(Event)]` — a typed in-process event for the `Dispatcher`.
10//! - `#[listener(Event)]` — an event listener with dispatch metadata.
11//!
12//! Each macro lives in its own file (one file, one macro). This `lib.rs` is
13//! only the dispatch surface: it declares each macro's `#[proc_macro_*]`
14//! entry point and forwards to its implementation module. All expansions
15//! reference Arcature APIs via absolute `::arcature::` paths that resolve in
16//! the downstream app crate. This crate must NOT depend on `arcature` (would
17//! create a cycle); it depends only on `syn`, `quote`, and `proc-macro2`.
18//!
19//! That cycle is also why every example in this crate's module docs is
20//! tagged ```` ```ignore ````. The examples show what a developer writes and
21//! what the macro expands to, and both name `::arcature::` items that no
22//! doctest compiled here can resolve. The examples that *are* compiled live
23//! in `arcature` itself, on the items these macros generate impls for.
24
25mod application;
26mod command;
27mod component;
28mod controller;
29mod diagnostic;
30mod event;
31mod field_shape;
32mod job;
33mod job_handler;
34mod listener;
35mod middleware;
36mod model;
37mod module;
38mod page;
39mod page_macro;
40mod policy;
41mod provider;
42mod redirect;
43mod request;
44mod request_cache;
45mod resource;
46mod route_model;
47mod routes;
48mod schema;
49mod service;
50mod signature;
51mod test_attr;
52mod util;
53
54use proc_macro::TokenStream;
55
56use crate::diagnostic::MacroResult;
57
58/// Converts a macro implementation's [`MacroResult`] into the token stream
59/// the compiler consumes: the expansion on success, a `compile_error!`
60/// invocation carrying the `ARC-M<NNN>` code on failure. No Arcature macro
61/// panics on an ordinary syntax mistake.
62fn finish(result: MacroResult) -> TokenStream {
63    match result {
64        Ok(tokens) => tokens.into(),
65        Err(error) => error.to_compile_error().into(),
66    }
67}
68
69/// `#[model(table = "users")]` — see `model.rs`.
70#[proc_macro_attribute]
71pub fn model(attr: TokenStream, item: TokenStream) -> TokenStream {
72    model::model(attr, item)
73}
74
75/// `#[request]` — see `request.rs`.
76#[proc_macro_attribute]
77pub fn request(attr: TokenStream, item: TokenStream) -> TokenStream {
78    finish(request::request(attr.into(), item.into()))
79}
80
81/// `#[controller]` — see `controller.rs`.
82#[proc_macro_attribute]
83pub fn controller(attr: TokenStream, item: TokenStream) -> TokenStream {
84    finish(controller::controller(attr.into(), item.into()))
85}
86
87/// `#[derive(Job)]` — see `job.rs`.
88#[proc_macro_derive(Job, attributes(job))]
89pub fn derive_job(input: TokenStream) -> TokenStream {
90    job::derive_job(input)
91}
92
93/// `#[derive(Event)]` — see `event.rs`.
94#[proc_macro_derive(Event)]
95pub fn derive_event(input: TokenStream) -> TokenStream {
96    event::derive_event(input)
97}
98
99/// `#[listener(Event)]` — see `listener.rs`.
100#[proc_macro_attribute]
101pub fn listener(attr: TokenStream, item: TokenStream) -> TokenStream {
102    listener::listener(attr, item)
103}
104
105/// `#[derive(DxComponent)]` — see `component.rs`.
106#[proc_macro_derive(DxComponent, attributes(component))]
107pub fn derive_dx_component(input: TokenStream) -> TokenStream {
108    finish(component::derive(input.into()))
109}
110
111/// `#[service]` — see `service.rs`.
112#[proc_macro_attribute]
113pub fn service(attr: TokenStream, item: TokenStream) -> TokenStream {
114    finish(service::service(attr.into(), item.into()))
115}
116
117/// `#[provider]` — see `provider.rs`.
118#[proc_macro_attribute]
119pub fn provider(attr: TokenStream, item: TokenStream) -> TokenStream {
120    finish(provider::provider(attr.into(), item.into()))
121}
122
123/// `#[policy(Model)]` — see `policy.rs`.
124#[proc_macro_attribute]
125pub fn policy(attr: TokenStream, item: TokenStream) -> TokenStream {
126    finish(policy::policy(attr.into(), item.into()))
127}
128
129/// `#[middleware]` — see `middleware.rs`.
130#[proc_macro_attribute]
131pub fn middleware(attr: TokenStream, item: TokenStream) -> TokenStream {
132    finish(middleware::middleware(attr.into(), item.into()))
133}
134
135/// `#[command("name")]` — see `command.rs`.
136#[proc_macro_attribute]
137pub fn command(attr: TokenStream, item: TokenStream) -> TokenStream {
138    finish(command::command(attr.into(), item.into()))
139}
140
141/// `#[job_handler]` — see `job_handler.rs`.
142#[proc_macro_attribute]
143pub fn job_handler(attr: TokenStream, item: TokenStream) -> TokenStream {
144    finish(job_handler::job_handler(attr.into(), item.into()))
145}
146
147/// `#[route_model(entity = ..., key_type = ...)]` — see `route_model.rs`.
148#[proc_macro_attribute]
149pub fn route_model(attr: TokenStream, item: TokenStream) -> TokenStream {
150    finish(route_model::route_model(attr.into(), item.into()))
151}
152
153/// `#[request_cache(name = "...", key = "...")]` — see `request_cache.rs`.
154#[proc_macro_attribute]
155pub fn request_cache(attr: TokenStream, item: TokenStream) -> TokenStream {
156    finish(self::request_cache::request_cache(attr.into(), item.into()))
157}
158
159/// `#[resource]` — see `resource.rs`.
160#[proc_macro_attribute]
161pub fn resource(attr: TokenStream, item: TokenStream) -> TokenStream {
162    finish(resource::resource(attr.into(), item.into()))
163}
164
165/// `#[arcature::test(app = ...)]` — see `test_attr.rs`.
166#[proc_macro_attribute]
167pub fn test(attr: TokenStream, item: TokenStream) -> TokenStream {
168    finish(test_attr::test_attr(attr.into(), item.into()))
169}
170
171/// `#[page("users/show")]` — see `page.rs`.
172#[proc_macro_attribute]
173pub fn page(attr: TokenStream, item: TokenStream) -> TokenStream {
174    finish(page::page(attr.into(), item.into()))
175}
176
177/// `page_macro!(ShowUserPage { .. })` — see `page_macro.rs`. Named
178/// `page_macro` rather than `page` because attribute and function-like
179/// macros share one namespace, and `#[page("name")]` already owns `page`.
180#[proc_macro]
181pub fn page_macro(input: TokenStream) -> TokenStream {
182    finish(self::page_macro::page_macro(input.into()))
183}
184
185/// `application! { pub App { .. } }` — see `application/mod.rs`.
186#[proc_macro]
187pub fn application(input: TokenStream) -> TokenStream {
188    finish(self::application::application(input.into()))
189}
190
191/// `module! { pub Accounts { .. } }` — see `module/mod.rs`.
192#[proc_macro]
193pub fn module(input: TokenStream) -> TokenStream {
194    finish(self::module::module(input.into()))
195}
196
197/// `routes! { pub app { .. } }` — see `routes/mod.rs`.
198#[proc_macro]
199pub fn routes(input: TokenStream) -> TokenStream {
200    finish(self::routes::routes(input.into()))
201}
202
203/// `redirect!(route::...)` — see `redirect.rs`.
204#[proc_macro]
205pub fn redirect(input: TokenStream) -> TokenStream {
206    finish(redirect::redirect(input.into()))
207}