Skip to main content

hyprstream_rpc_derive/codegen/
mod.rs

1//! Code generation from parsed Cap'n Proto schemas using quote!.
2
3pub 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
15/// Generate client-only code from a parsed schema.
16///
17/// Emits data structs, response enum, client struct, scoped clients, client
18/// traits, JSON dispatch, and metadata. Does NOT emit server-side handlers or
19/// service implementation code.
20/// Compiles to all targets including wasm32.
21pub 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    // Scoped response enums + parsers (e.g., InferClientResponseVariant with parse_scoped_response)
58    let scoped_response_types =
59        scoped::generate_scoped_response_types(service_name, &resolved, types_crate);
60
61    // Schema metadata, JSON dispatch, and render_doc() for client-side
62    // documentation and schema-driven tooling.
63    let metadata_code =
64        metadata::generate_metadata_client_with_dispatch(service_name, &resolved, types_crate);
65
66    // Transport-agnostic dispatch function — routes method calls by name
67    let portable_dispatch =
68        dispatch::generate_portable_dispatch(service_name, &resolved, types_crate);
69
70    // Client struct (cfg-gated: concrete on native, dyn on wasm)
71    let client_struct = client::generate_client(service_name, &resolved, types_crate);
72
73    // Scoped client structs (same cfg-gated pattern)
74    let scoped_clients =
75        scoped::generate_portable_scoped_clients(service_name, &resolved, types_crate);
76
77    // Public client-side traits live with the generated clients.  Keeping these
78    // traits in the contract crate lets consumers depend on a single
79    // permissively licensed surface while service crates generate only their
80    // handlers and wire dispatch.
81    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    // Generated 9P/VFS node table (#539 T2) — must compile to wasm32 too.
86    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
108/// Generate server-side dispatch code against contracts that were generated in
109/// another crate.
110///
111/// This is the counterpart to [`generate_client_only`].  It deliberately emits
112/// no data structs, response enums, client implementations, or JSON client
113/// dispatchers: those remain owned by the permissively licensed contract crate.
114/// The invocation module imports the contract crate's generated client module
115/// (for handler parameter/response types) and Cap'n Proto module, then emits
116/// only the handler traits, wire dispatch, metadata, and VFS projection needed
117/// by an implementation/service crate.
118pub 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        // A data-only schema has no server dispatch surface.  Its contracts
127        // are already exported by the contract crate, so there is nothing to
128        // emit here.
129        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        // Keep contract ownership in the permissively licensed crate.  These
136        // imports are intentionally private: this module exposes server
137        // traits/dispatch only, never a second public client implementation.
138        use #types_crate::#client_mod::*;
139        use #types_crate::#capnp_mod;
140    };
141    let handler = handler::generate_handler(service_name, &resolved, scope_handlers);
142    // Scoped metadata functions are emitted alongside the server surface, so
143    // the local tree must point at those functions (not at the contract crate's
144    // client-only metadata module).
145    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
156/// Generate all service code from a parsed schema.
157///
158/// When `types_crate` is `Some`, generates client-only code (no handler/dispatch)
159/// and resolves capnp module paths through the external crate.
160pub 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        // Data-only schema: only emit data structs (no client, handler, metadata)
173        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    // Skip handler generation when types_crate is set (client-only mode)
191    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    // Generated 9P/VFS node table (#539 T2).
198    let vfs_mount = vfs::generate_mount(service_name, &resolved);
199
200    // Handler code resolves the Cap'n Proto module in the invocation module's
201    // scope.  Existing full-service invocations keep their capnp modules at
202    // crate root, so import that module before emitting the handler.
203    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}