hyprstream_rpc_derive/codegen/
mod.rs1pub mod client;
4pub mod data;
5pub mod dispatch;
6pub mod handler;
7pub mod leaf;
8pub mod metadata;
9pub mod scoped;
10pub mod vfs;
11
12use crate::resolve::ResolvedSchema;
13use crate::schema::types::ParsedSchema;
14
15pub fn generate_client_only(
22 service_name: &str,
23 schema: &ParsedSchema,
24 types_crate: Option<&syn::Path>,
25) -> proc_macro2::TokenStream {
26 let resolved = ResolvedSchema::from(schema);
27 let is_data_only = resolved.raw.request_variants.is_empty();
28
29 let data_structs = data::generate_data_structs(&resolved, service_name, types_crate);
30
31 if is_data_only {
32 return quote::quote! { #data_structs };
33 }
34
35 let pascal = crate::util::to_pascal_case(service_name);
36 let response_type = quote::format_ident!("{}ResponseVariant", pascal);
37 let capnp_mod_ident = quote::format_ident!("{}_capnp", service_name);
38 let capnp_mod: proc_macro2::TokenStream = match types_crate {
39 Some(tc) => quote::quote! { #tc::#capnp_mod_ident },
40 None => quote::quote! { crate::#capnp_mod_ident },
41 };
42 let resp_type = quote::format_ident!(
43 "{}",
44 crate::util::to_snake_case(&format!("{pascal}Response"))
45 );
46
47 let response_enum = client::generate_response_enum(service_name, &resolved, types_crate);
48 let parse_response = client::generate_parse_response_fn(
49 &response_type,
50 &capnp_mod,
51 &resp_type,
52 &resolved.raw.response_variants,
53 &resolved,
54 types_crate,
55 );
56
57 let scoped_response_types =
59 scoped::generate_scoped_response_types(service_name, &resolved, types_crate);
60
61 let metadata_code =
64 metadata::generate_metadata_client_with_dispatch(service_name, &resolved, types_crate);
65
66 let portable_dispatch =
68 dispatch::generate_portable_dispatch(service_name, &resolved, types_crate);
69
70 let client_struct = client::generate_client(service_name, &resolved, types_crate);
72
73 let scoped_clients =
75 scoped::generate_portable_scoped_clients(service_name, &resolved, types_crate);
76
77 let service_traits = client::generate_service_traits(service_name, &resolved, types_crate);
82 let trait_impls = client::generate_trait_impls(service_name, &resolved, types_crate);
83 let constructors = client::generate_portable_constructors(service_name);
84
85 let vfs_mount = vfs::generate_mount(service_name, &resolved);
87
88 quote::quote! {
89 #data_structs
90 #response_enum
91
92 impl #response_type {
93 #parse_response
94 }
95
96 #scoped_response_types
97 #client_struct
98 #scoped_clients
99 #service_traits
100 #trait_impls
101 #constructors
102 #metadata_code
103 #portable_dispatch
104 #vfs_mount
105 }
106}
107
108pub fn generate_server(
119 service_name: &str,
120 schema: &ParsedSchema,
121 types_crate: &syn::Path,
122 scope_handlers: bool,
123) -> proc_macro2::TokenStream {
124 let resolved = ResolvedSchema::from(schema);
125 if resolved.raw.request_variants.is_empty() {
126 return quote::quote! {};
130 }
131
132 let client_mod = quote::format_ident!("{}_client", service_name);
133 let capnp_mod = quote::format_ident!("{}_capnp", service_name);
134 let imports = quote::quote! {
135 use #types_crate::#client_mod::*;
139 use #types_crate::#capnp_mod;
140 };
141 let handler = handler::generate_handler(service_name, &resolved, scope_handlers);
142 let metadata = metadata::generate_metadata_client_only(service_name, &resolved, None);
146 let vfs_mount = vfs::generate_mount(service_name, &resolved);
147
148 quote::quote! {
149 #imports
150 #handler
151 #metadata
152 #vfs_mount
153 }
154}
155
156pub fn generate_service(
161 service_name: &str,
162 schema: &ParsedSchema,
163 types_crate: Option<&syn::Path>,
164 scope_handlers: bool,
165) -> proc_macro2::TokenStream {
166 let resolved = ResolvedSchema::from(schema);
167 let is_data_only = resolved.raw.request_variants.is_empty();
168
169 let data_structs = data::generate_data_structs(&resolved, service_name, types_crate);
170
171 if is_data_only {
172 return quote::quote! {
174 #data_structs
175 };
176 }
177
178 let metadata_code = metadata::generate_metadata(service_name, &resolved, types_crate);
179
180 let response_enum = client::generate_response_enum(service_name, &resolved, types_crate);
181 let client_struct = client::generate_client(service_name, &resolved, types_crate);
182 let scoped_clients =
183 scoped::generate_portable_scoped_clients(service_name, &resolved, types_crate);
184 let scoped_response_types =
185 scoped::generate_scoped_response_types(service_name, &resolved, types_crate);
186 let service_traits = client::generate_service_traits(service_name, &resolved, types_crate);
187 let trait_impls = client::generate_trait_impls(service_name, &resolved, types_crate);
188 let constructors = client::generate_constructors(service_name);
189
190 let handler = if types_crate.is_none() {
192 handler::generate_handler(service_name, &resolved, scope_handlers)
193 } else {
194 proc_macro2::TokenStream::new()
195 };
196
197 let vfs_mount = vfs::generate_mount(service_name, &resolved);
199
200 let capnp_import = if types_crate.is_none() {
204 let capnp_mod = quote::format_ident!("{}_capnp", service_name);
205 quote::quote! { use crate::#capnp_mod; }
206 } else {
207 quote::quote! {}
208 };
209
210 quote::quote! {
211 #data_structs
212 #response_enum
213 #client_struct
214 #scoped_clients
215 #scoped_response_types
216 #service_traits
217 #trait_impls
218 #constructors
219 #capnp_import
220 #handler
221 #metadata_code
222 #vfs_mount
223 }
224}