hyprstream_rpc_derive/codegen/
dispatch.rs1use proc_macro2::TokenStream;
8use quote::{format_ident, quote};
9
10use crate::resolve::ResolvedSchema;
11use crate::schema::types::*;
12use crate::util::*;
13
14pub fn generate_portable_dispatch(
29 service_name: &str,
30 resolved: &ResolvedSchema,
31 types_crate: Option<&syn::Path>,
32) -> TokenStream {
33 let pascal = to_pascal_case(service_name);
34 let response_type = format_ident!("{}ResponseVariant", pascal);
35 let capnp_mod_ident = format_ident!("{}_capnp", service_name);
36 let capnp_mod: TokenStream = match types_crate {
37 Some(tc) => quote! { #tc::#capnp_mod_ident },
38 None => quote! { crate::#capnp_mod_ident },
39 };
40 let req_type = format_ident!("{}", to_snake_case(&format!("{pascal}Request")));
41
42 let scoped_names: Vec<&str> = resolved
43 .raw
44 .scoped_clients
45 .iter()
46 .map(|sc| sc.factory_name.as_str())
47 .collect();
48
49 let is_streaming =
53 |v: &UnionVariant, resp_variants: &[UnionVariant], is_scoped: bool| -> bool {
54 let result_name = if is_scoped {
55 v.name.clone()
56 } else {
57 format!("{}Result", v.name)
58 };
59 resp_variants
60 .iter()
61 .any(|r| r.name == result_name && r.type_name == "StreamInfo")
62 };
63
64 let dispatch_arms: Vec<TokenStream> = resolved
66 .raw
67 .request_variants
68 .iter()
69 .filter(|v| !scoped_names.contains(&v.name.as_str()))
70 .filter(|v| !v.cli_hidden)
71 .filter(|v| !is_streaming(v, &resolved.raw.response_variants, false))
72 .map(|v| generate_dispatch_arm(v, resolved, &capnp_mod, &req_type, &response_type))
73 .collect();
74
75 let streaming_arms: Vec<TokenStream> = resolved
77 .raw
78 .request_variants
79 .iter()
80 .filter(|v| !scoped_names.contains(&v.name.as_str()))
81 .filter(|v| !v.cli_hidden)
82 .filter(|v| is_streaming(v, &resolved.raw.response_variants, false))
83 .map(|v| {
84 generate_streaming_dispatch_arm(v, resolved, &capnp_mod, &req_type, &response_type)
85 })
86 .collect();
87
88 let scoped_dispatch_arms: Vec<TokenStream> = resolved
91 .raw
92 .scoped_clients
93 .iter()
94 .filter(|sc| !sc.inner_request_variants.is_empty())
95 .flat_map(|sc| {
96 let scope_snake = to_snake_case(&sc.factory_name);
97 let scope_init = format_ident!("init_{}", to_snake_case(&sc.factory_name));
98
99 let scope_field_extracts: Vec<TokenStream> = sc.scope_fields.iter().enumerate().map(|(i, f)| {
101 let field_snake = to_snake_case(&f.name);
102 let field_camel = &f.name;
103 let var_name = format_ident!("__scope_val_{}", i);
104 match f.type_name.as_str() {
105 "Text" => quote! {
106 let #var_name = args.get(#field_camel)
107 .or_else(|| args.get(#field_snake))
108 .and_then(|v| v.as_str())
109 .ok_or_else(|| format!("missing scope field '{}' in args", #field_camel))?
110 .to_owned();
111 },
112 _ => quote! {},
113 }
114 }).collect();
115 let scope_field_setters: Vec<TokenStream> = sc.scope_fields.iter().enumerate().map(|(i, f)| {
116 let setter = format_ident!("set_{}", to_snake_case(&f.name));
117 let var_name = format_ident!("__scope_val_{}", i);
118 match f.type_name.as_str() {
119 "Text" => quote! { __scope.#setter(&#var_name); },
120 _ => quote! {},
121 }
122 }).collect();
123
124 let scoped_response_type = format_ident!("{}ResponseVariant", sc.client_name);
126
127 sc.inner_request_variants.iter()
128 .filter(|v| !v.cli_hidden)
129 .filter(|v| !is_streaming(v, &sc.inner_response_variants, true))
130 .map(|v| {
131 let method_snake = to_snake_case(&v.name);
132 let full_name = format!("{}.{}", scope_snake, method_snake);
133 let inner_init = format_ident!("init_{}", to_snake_case(&v.name));
134 let inner_set = format_ident!("set_{}", to_snake_case(&v.name));
135 let ct = resolved.resolve_type(&v.type_name).capnp_type.clone();
136
137 let inner_serialize = match ct {
138 CapnpType::Void => quote! { __scope.#inner_set(()); },
139 CapnpType::Text => quote! {
140 let __val = args.get(#method_snake).or_else(|| args.get("value"))
141 .and_then(|v| v.as_str()).unwrap_or_default();
142 __scope.#inner_set(__val);
143 },
144 _ => {
145 if let Some(sdef) = resolved.find_struct(&v.type_name) {
146 let nuf: Vec<_> = sdef.non_union_fields().collect();
147 let is_void_wrapper = nuf.is_empty()
148 || (nuf.len() == 1 && nuf[0].type_name == "Void");
149 if is_void_wrapper {
150 quote! { __scope.#inner_init(); }
151 } else {
152 quote! {
155 let mut __inner = __scope.#inner_init();
156 hyprstream_rpc::capnp::ToCapnp::write_to(&__scoped_req, &mut __inner);
157 }
158 }
159 } else {
160 quote! { __scope.#inner_init(); }
161 }
162 }
163 };
164
165 let pre_deserialize = match ct.clone() {
167 CapnpType::Struct(_) | CapnpType::Unknown(_) => {
168 if let Some(sdef) = resolved.find_struct(&v.type_name) {
169 let nuf: Vec<_> = sdef.non_union_fields().collect();
170 let is_void_wrapper = nuf.is_empty()
171 || (nuf.len() == 1 && nuf[0].type_name == "Void");
172 if is_void_wrapper {
173 quote! {}
174 } else {
175 let data_name = format_ident!("{}", v.type_name);
176 quote! {
177 let __scoped_req: #data_name = serde_json::from_value(args.clone())
178 .map_err(|e| format!("deserialize {}: {e}", #method_snake))?;
179 }
180 }
181 } else { quote! {} }
182 }
183 _ => quote! {},
184 };
185
186 quote! {
187 #full_name => {
188 #(#scope_field_extracts)*
189 #pre_deserialize
190 let payload = hyprstream_rpc::serialize_message(|msg| {
191 let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
192 req.set_id(request_id);
193 let mut __scope = req.#scope_init();
194 #(#scope_field_setters)*
195 #inner_serialize
196 }).map_err(|e| format!("serialize: {e}"))?;
197 let response_bytes = send(payload).await?;
198 let variant = #scoped_response_type::parse_scoped_response(&response_bytes)
199 .map_err(|e| format!("parse response: {e}"))?;
200 let json = serde_json::to_string(&variant)
201 .map_err(|e| format!("serialize response: {e}"))?;
202 Ok(DispatchResult::Response(json))
203 }
204 }
205 })
206 .collect::<Vec<_>>()
207 })
208 .collect();
209
210 let scoped_streaming_arms: Vec<TokenStream> = resolved
212 .raw
213 .scoped_clients
214 .iter()
215 .filter(|sc| !sc.inner_request_variants.is_empty())
216 .flat_map(|sc| {
217 let scope_snake = to_snake_case(&sc.factory_name);
218 let scope_init = format_ident!("init_{}", to_snake_case(&sc.factory_name));
219
220 let scope_field_extracts: Vec<TokenStream> = sc.scope_fields.iter().enumerate().map(|(i, f)| {
221 let field_snake = to_snake_case(&f.name);
222 let field_camel = &f.name;
223 let var_name = format_ident!("__scope_val_{}", i);
224 match f.type_name.as_str() {
225 "Text" => quote! {
226 let #var_name = args.get(#field_camel)
227 .or_else(|| args.get(#field_snake))
228 .and_then(|v| v.as_str())
229 .ok_or_else(|| format!("missing scope field '{}' in args", #field_camel))?
230 .to_owned();
231 },
232 _ => quote! {},
233 }
234 }).collect();
235 let scope_field_setters: Vec<TokenStream> = sc.scope_fields.iter().enumerate().map(|(i, f)| {
236 let setter = format_ident!("set_{}", to_snake_case(&f.name));
237 let var_name = format_ident!("__scope_val_{}", i);
238 match f.type_name.as_str() {
239 "Text" => quote! { __scope.#setter(&#var_name); },
240 _ => quote! {},
241 }
242 }).collect();
243
244 let scoped_response_type = format_ident!("{}ResponseVariant", sc.client_name);
245
246 sc.inner_request_variants.iter()
247 .filter(|v| !v.cli_hidden)
248 .filter(|v| is_streaming(v, &sc.inner_response_variants, true))
249 .map(|v| {
250 let method_snake = to_snake_case(&v.name);
251 let full_name = format!("{}.{}", scope_snake, method_snake);
252 let inner_init = format_ident!("init_{}", to_snake_case(&v.name));
253 let inner_set = format_ident!("set_{}", to_snake_case(&v.name));
254 let ct = resolved.resolve_type(&v.type_name).capnp_type.clone();
255
256 let inner_serialize = match ct.clone() {
257 CapnpType::Void => quote! { __scope.#inner_set(()); },
258 _ => {
259 if let Some(sdef) = resolved.find_struct(&v.type_name) {
260 let nuf: Vec<_> = sdef.non_union_fields().collect();
261 let is_void_wrapper = nuf.is_empty()
262 || (nuf.len() == 1 && nuf[0].type_name == "Void");
263 if is_void_wrapper {
264 quote! { __scope.#inner_init(); }
265 } else {
266 quote! {
267 let mut __inner = __scope.#inner_init();
268 hyprstream_rpc::capnp::ToCapnp::write_to(&__scoped_req, &mut __inner);
269 }
270 }
271 } else {
272 quote! { __scope.#inner_init(); }
273 }
274 }
275 };
276
277 let pre_deserialize = match ct {
278 CapnpType::Struct(_) | CapnpType::Unknown(_) => {
279 if let Some(sdef) = resolved.find_struct(&v.type_name) {
280 let nuf: Vec<_> = sdef.non_union_fields().collect();
281 let is_void_wrapper = nuf.is_empty()
282 || (nuf.len() == 1 && nuf[0].type_name == "Void");
283 if is_void_wrapper { quote! {} } else {
284 let data_name = format_ident!("{}", v.type_name);
285 quote! {
286 let __scoped_req: #data_name = serde_json::from_value(args.clone())
287 .map_err(|e| format!("deserialize {}: {e}", #method_snake))?;
288 }
289 }
290 } else { quote! {} }
291 }
292 _ => quote! {},
293 };
294
295 let scoped_resp_variant_pascal = format_ident!("{}", to_pascal_case(&v.name));
298
299 quote! {
300 #full_name => {
301 #(#scope_field_extracts)*
302 #pre_deserialize
303 let payload = hyprstream_rpc::serialize_message(|msg| {
304 let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
305 req.set_id(request_id);
306 let mut __scope = req.#scope_init();
307 #(#scope_field_setters)*
308 #inner_serialize
309 }).map_err(|e| format!("serialize: {e}"))?;
310 let response_bytes = send(payload).await?;
311 let variant = #scoped_response_type::parse_scoped_response(&response_bytes)
314 .map_err(|e| format!("parse streaming response: {e}"))?;
315 match variant {
316 #scoped_response_type::#scoped_resp_variant_pascal(stream_info) => Ok(DispatchResult::Stream(stream_info)),
317 _ => Err(format!("expected StreamInfo streaming response for method '{}'", #full_name)),
318 }
319 }
320 }
321 })
322 .collect::<Vec<_>>()
323 })
324 .collect();
325
326 let method_list: Vec<String> = resolved
327 .raw
328 .request_variants
329 .iter()
330 .filter(|v| !scoped_names.contains(&v.name.as_str()) && !v.cli_hidden)
331 .map(|v| to_snake_case(&v.name))
332 .collect();
333 let scoped_method_list: Vec<String> = resolved
334 .raw
335 .scoped_clients
336 .iter()
337 .flat_map(|sc| {
338 let scope_snake = to_snake_case(&sc.factory_name);
339 sc.inner_request_variants
340 .iter()
341 .filter(|v| !v.cli_hidden)
342 .map(move |v| format!("{}.{}", scope_snake, to_snake_case(&v.name)))
343 })
344 .collect();
345 let mut all_methods = method_list;
346 all_methods.extend(scoped_method_list);
347 let methods_str = all_methods.join(", ");
348
349 quote! {
350 pub enum DispatchResult {
352 Response(String),
354 Stream(hyprstream_rpc::stream_info::StreamInfo),
359 }
360
361 pub async fn dispatch<F, Fut>(
367 method: &str,
368 args_json: &str,
369 request_id: u64,
370 send: F,
371 ) -> ::core::result::Result<DispatchResult, String>
372 where
373 F: FnOnce(Vec<u8>) -> Fut,
374 Fut: ::core::future::Future<Output = ::core::result::Result<Vec<u8>, String>>,
375 {
376 let args: serde_json::Value = serde_json::from_str(args_json)
377 .map_err(|e| format!("invalid JSON: {e}"))?;
378
379 match method {
380 #(#dispatch_arms)*
381 #(#scoped_dispatch_arms)*
382 #(#streaming_arms)*
383 #(#scoped_streaming_arms)*
384 _ => Err(format!("unknown method '{}', available: {}", method, #methods_str)),
385 }
386 }
387 }
388}
389
390fn generate_dispatch_arm(
392 v: &UnionVariant,
393 resolved: &ResolvedSchema,
394 capnp_mod: &TokenStream,
395 req_type: &proc_macro2::Ident,
396 response_type: &proc_macro2::Ident,
397) -> TokenStream {
398 let method_name_str = to_snake_case(&v.name);
399 let ct = resolved.resolve_type(&v.type_name).capnp_type.clone();
400 let set_method = format_ident!("set_{}", to_snake_case(&v.name));
401 let init_method = format_ident!("init_{}", to_snake_case(&v.name));
402
403 let serialize_body = match ct {
405 CapnpType::Void => {
406 quote! {
407 let payload = hyprstream_rpc::serialize_message(|msg| {
408 let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
409 req.set_id(request_id);
410 req.#set_method(());
411 }).map_err(|e| format!("serialize: {e}"))?;
412 }
413 }
414 CapnpType::Text => {
415 quote! {
416 let value = args.as_str()
417 .or_else(|| args[#method_name_str].as_str())
418 .or_else(|| args["value"].as_str())
419 .unwrap_or_default();
420 let payload = hyprstream_rpc::serialize_message(|msg| {
421 let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
422 req.set_id(request_id);
423 req.#set_method(value);
424 }).map_err(|e| format!("serialize: {e}"))?;
425 }
426 }
427 CapnpType::Struct(_) | CapnpType::Unknown(_) => {
428 if let Some(sdef) = resolved.find_struct(&v.type_name) {
429 let nuf: Vec<_> = sdef.non_union_fields().collect();
430 let is_void_wrapper =
431 nuf.is_empty() || (nuf.len() == 1 && nuf[0].type_name == "Void");
432
433 if is_void_wrapper {
434 quote! {
435 let payload = hyprstream_rpc::serialize_message(|msg| {
436 let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
437 req.set_id(request_id);
438 req.#init_method();
439 }).map_err(|e| format!("serialize: {e}"))?;
440 }
441 } else {
442 let data_name = format_ident!("{}", v.type_name);
443 quote! {
444 let __req: #data_name = serde_json::from_value(args.clone())
445 .map_err(|e| format!("deserialize {}: {e}", #method_name_str))?;
446 let payload = hyprstream_rpc::serialize_message(|msg| {
447 let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
448 req.set_id(request_id);
449 let mut __inner = req.#init_method();
450 hyprstream_rpc::capnp::ToCapnp::write_to(&__req, &mut __inner);
451 }).map_err(|e| format!("serialize: {e}"))?;
452 }
453 }
454 } else {
455 let err = format!("struct type not found: {}", v.type_name);
456 return quote! { #method_name_str => Err(#err.to_owned()), };
457 }
458 }
459 CapnpType::Bool => {
460 quote! {
461 let __value = args
462 .get(#method_name_str)
463 .or_else(|| args.get("value"))
464 .cloned()
465 .ok_or_else(|| format!("missing argument for {}", #method_name_str))?;
466 let value: bool = serde_json::from_value(__value)
467 .map_err(|e| format!("deserialize {}: {e}", #method_name_str))?;
468 let payload = hyprstream_rpc::serialize_message(|msg| {
469 let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
470 req.set_id(request_id);
471 req.#set_method(value);
472 }).map_err(|e| format!("serialize: {e}"))?;
473 }
474 }
475 _ if ct.is_numeric() => {
476 let rust_ty = rust_type_tokens(&ct.rust_owned_type());
477 quote! {
478 let __value = args
479 .get(#method_name_str)
480 .or_else(|| args.get("value"))
481 .cloned()
482 .ok_or_else(|| format!("missing argument for {}", #method_name_str))?;
483 let value: #rust_ty = serde_json::from_value(__value)
484 .map_err(|e| format!("deserialize {}: {e}", #method_name_str))?;
485 let payload = hyprstream_rpc::serialize_message(|msg| {
486 let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
487 req.set_id(request_id);
488 req.#set_method(value);
489 }).map_err(|e| format!("serialize: {e}"))?;
490 }
491 }
492 _ => {
493 return quote! { #method_name_str => Err(format!("unsupported argument type for {}", #method_name_str)), };
495 }
496 };
497
498 quote! {
499 #method_name_str => {
500 #serialize_body
501 let response_bytes = send(payload).await?;
502 let variant = #response_type::parse_response(&response_bytes)
503 .map_err(|e| format!("parse response: {e}"))?;
504 let json = serde_json::to_string(&variant)
505 .map_err(|e| format!("serialize response: {e}"))?;
506 Ok(DispatchResult::Response(json))
507 }
508 }
509}
510
511fn generate_streaming_dispatch_arm(
513 v: &UnionVariant,
514 resolved: &ResolvedSchema,
515 capnp_mod: &TokenStream,
516 req_type: &proc_macro2::Ident,
517 response_type: &proc_macro2::Ident,
518) -> TokenStream {
519 let method_name_str = to_snake_case(&v.name);
520 let ct = resolved.resolve_type(&v.type_name).capnp_type.clone();
521 let set_method = format_ident!("set_{}", to_snake_case(&v.name));
522 let init_method = format_ident!("init_{}", to_snake_case(&v.name));
523
524 let serialize_body = match ct {
526 CapnpType::Void => quote! {
527 let payload = hyprstream_rpc::serialize_message(|msg| {
528 let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
529 req.set_id(request_id);
530 req.#set_method(());
531 }).map_err(|e| format!("serialize: {e}"))?;
532 },
533 CapnpType::Bool => {
534 quote! {
535 let __value = args
536 .get(#method_name_str)
537 .or_else(|| args.get("value"))
538 .cloned()
539 .ok_or_else(|| format!("missing argument for {}", #method_name_str))?;
540 let value: bool = serde_json::from_value(__value)
541 .map_err(|e| format!("deserialize {}: {e}", #method_name_str))?;
542 let payload = hyprstream_rpc::serialize_message(|msg| {
543 let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
544 req.set_id(request_id);
545 req.#set_method(value);
546 }).map_err(|e| format!("serialize: {e}"))?;
547 }
548 }
549 _ if ct.is_numeric() => {
550 let rust_ty = rust_type_tokens(&ct.rust_owned_type());
551 quote! {
552 let __value = args
553 .get(#method_name_str)
554 .or_else(|| args.get("value"))
555 .cloned()
556 .ok_or_else(|| format!("missing argument for {}", #method_name_str))?;
557 let value: #rust_ty = serde_json::from_value(__value)
558 .map_err(|e| format!("deserialize {}: {e}", #method_name_str))?;
559 let payload = hyprstream_rpc::serialize_message(|msg| {
560 let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
561 req.set_id(request_id);
562 req.#set_method(value);
563 }).map_err(|e| format!("serialize: {e}"))?;
564 }
565 }
566 _ => {
567 if let Some(sdef) = resolved.find_struct(&v.type_name) {
568 let nuf: Vec<_> = sdef.non_union_fields().collect();
569 let is_void_wrapper =
570 nuf.is_empty() || (nuf.len() == 1 && nuf[0].type_name == "Void");
571 if is_void_wrapper {
572 quote! {
573 let payload = hyprstream_rpc::serialize_message(|msg| {
574 let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
575 req.set_id(request_id);
576 req.#init_method();
577 }).map_err(|e| format!("serialize: {e}"))?;
578 }
579 } else {
580 let data_name = format_ident!("{}", v.type_name);
581 quote! {
582 let __req: #data_name = serde_json::from_value(args.clone())
583 .map_err(|e| format!("deserialize {}: {e}", #method_name_str))?;
584 let payload = hyprstream_rpc::serialize_message(|msg| {
585 let mut req = msg.init_root::<#capnp_mod::#req_type::Builder>();
586 req.set_id(request_id);
587 let mut __inner = req.#init_method();
588 hyprstream_rpc::capnp::ToCapnp::write_to(&__req, &mut __inner);
589 }).map_err(|e| format!("serialize: {e}"))?;
590 }
591 }
592 } else {
593 let err = format!("struct type not found: {}", v.type_name);
594 return quote! { #method_name_str => Err(#err.to_owned()), };
595 }
596 }
597 };
598
599 let resp_variant_pascal = format_ident!("{}", to_pascal_case(&format!("{}Result", v.name)));
603 quote! {
604 #method_name_str => {
605 #serialize_body
606 let response_bytes = send(payload).await?;
607 let variant = #response_type::parse_response(&response_bytes)
609 .map_err(|e| format!("parse streaming response: {e}"))?;
610 match variant {
611 #response_type::#resp_variant_pascal(stream_info) => Ok(DispatchResult::Stream(stream_info)),
612 _ => Err(format!("expected StreamInfo streaming response for method '{}'", #method_name_str)),
613 }
614 }
615 }
616}