1use proc_macro2::{Span, TokenStream};
2use quote::quote;
3use syn::{Ident, LitStr, parse_quote};
4use tracing::info;
5
6use crate::model::{Api, Field, IntegerType, Operation, ParseAs, RangeScalar, TypeRef};
7use crate::{GenerateOptions, RootModule};
8
9const PREAMBLE: &str = "\
10//! @generated by satay. Do not edit by hand.
11
12";
13
14#[derive(Debug)]
15pub struct GeneratedFile {
16 pub relative_path: String,
17 pub contents: String,
18}
19
20pub(crate) fn render_api(api: &Api, options: GenerateOptions) -> Vec<GeneratedFile> {
21 info!(
22 components = api.components.len(),
23 operations = api.operations.len(),
24 "rendering API"
25 );
26 let mut files = vec![];
27
28 let root_module = match options.root_module {
29 RootModule::ModRs => "mod.rs",
30 RootModule::LibRs => "lib.rs",
31 };
32 let top_mod = render_top_mod(api);
33 files.push(GeneratedFile {
34 relative_path: root_module.to_owned(),
35 contents: format_file(top_mod),
36 });
37
38 if !api.components.is_empty() || !api.constrained_types.is_empty() {
39 let types_file = types::render_types_file(api);
40 files.push(GeneratedFile {
41 relative_path: "types.rs".to_owned(),
42 contents: format_file(types_file),
43 });
44 }
45
46 let api_file = api::render_api_file(api);
47 files.push(GeneratedFile {
48 relative_path: "api.rs".to_owned(),
49 contents: format_file(api_file),
50 });
51
52 for operation in &api.operations {
53 let dir = &operation.fn_name;
54 let endpoint_mod = endpoint::render_endpoint_mod(operation);
55 files.push(GeneratedFile {
56 relative_path: format!("{dir}/mod.rs"),
57 contents: format_file(endpoint_mod),
58 });
59
60 let parts_file = endpoint::render_endpoint_parts_file(api, operation);
61 files.push(GeneratedFile {
62 relative_path: format!("{dir}/parts.rs"),
63 contents: format_file(parts_file),
64 });
65
66 let json_file = endpoint::render_endpoint_json_file(api, operation);
67 files.push(GeneratedFile {
68 relative_path: format!("{dir}/json.rs"),
69 contents: format_file(json_file),
70 });
71 }
72
73 info!(files = files.len(), "rendered API");
74 files
75}
76
77fn format_file(file: syn::File) -> String {
78 let code = prettyplease::unparse(&file);
79 let mut formatted = String::with_capacity(PREAMBLE.len() + code.len());
80 formatted.push_str(PREAMBLE);
81 formatted.push_str(&code);
82 formatted
83}
84
85fn render_top_mod(api: &Api) -> syn::File {
86 let mut items: Vec<syn::Item> = vec![];
87 let server_url = lit_str(&api.server_url);
88 items.push(parse_quote!(pub const SERVER_URL: &str = #server_url;));
89
90 let has_types = !api.components.is_empty() || !api.constrained_types.is_empty();
91 if has_types {
92 items.push(parse_quote!(
93 pub mod types;
94 ));
95 items.push(parse_quote!(
96 pub use types::*;
97 ));
98 }
99
100 items.push(parse_quote!(
101 #[cfg(feature = "json")]
102 mod api;
103 ));
104 items.push(parse_quote!(
105 #[cfg(feature = "json")]
106 pub use api::*;
107 ));
108
109 for operation in &api.operations {
110 let module = ident(&operation.fn_name);
111 items.push(parse_quote!(pub mod #module;));
112 items.push(parse_quote!(pub use #module::*;));
113 }
114
115 syn::File {
116 shebang: None,
117 attrs: vec![],
118 items,
119 }
120}
121
122pub fn ident(value: &str) -> Ident {
123 Ident::new(value, Span::call_site())
124}
125
126pub fn lit_str(value: &str) -> LitStr {
127 LitStr::new(value, Span::call_site())
128}
129
130pub fn doc_attrs(description: Option<&str>) -> Vec<syn::Attribute> {
131 let Some(description) = description.filter(|description| !description.trim().is_empty()) else {
132 return vec![];
133 };
134
135 description
136 .lines()
137 .map(|line| {
138 let doc_line = if line.is_empty() {
139 String::new()
140 } else {
141 format!(" {line}")
142 };
143 let doc_line = lit_str(&doc_line);
144 parse_quote!(#[doc = #doc_line])
145 })
146 .collect()
147}
148
149pub fn rust_type(ty: &TypeRef) -> syn::Type {
150 match ty {
151 TypeRef::String => parse_quote!(String),
152 TypeRef::ParsedString(parse_as) | TypeRef::ParsedInteger(parse_as) => {
153 parse_as_rust_type(*parse_as)
154 }
155 TypeRef::Integer(integer_type) => integer_rust_type(*integer_type),
156 TypeRef::F32 => parse_quote!(f32),
157 TypeRef::F64 => parse_quote!(f64),
158 TypeRef::Bool => parse_quote!(bool),
159 TypeRef::Array(item) => {
160 let item = rust_type(item);
161 parse_quote!(Vec<#item>)
162 }
163 TypeRef::Range(range_type) => {
164 let name = ident(&range_type.rust_name);
165 parse_quote!(#name)
166 }
167 TypeRef::Named(name)
168 | TypeRef::Constrained {
169 rust_name: name, ..
170 } => {
171 let name = ident(name);
172 parse_quote!(#name)
173 }
174 TypeRef::Option(inner) => {
175 let inner = rust_type(inner);
176 parse_quote!(Option<#inner>)
177 }
178 }
179}
180
181pub fn range_scalar_rust_type(scalar: RangeScalar) -> syn::Type {
182 match scalar {
183 RangeScalar::Integer(integer_type) => integer_rust_type(integer_type),
184 RangeScalar::F32 => parse_quote!(f32),
185 RangeScalar::F64 => parse_quote!(f64),
186 }
187}
188
189pub fn integer_rust_type(integer_type: IntegerType) -> syn::Type {
190 match integer_type {
191 IntegerType::U8 => parse_quote!(u8),
192 IntegerType::U16 => parse_quote!(u16),
193 IntegerType::U32 => parse_quote!(u32),
194 IntegerType::U64 => parse_quote!(u64),
195 IntegerType::I8 => parse_quote!(i8),
196 IntegerType::I16 => parse_quote!(i16),
197 IntegerType::I32 => parse_quote!(i32),
198 IntegerType::I64 => parse_quote!(i64),
199 }
200}
201
202pub fn parse_as_rust_type(parse_as: ParseAs) -> syn::Type {
203 match parse_as {
204 ParseAs::U8 => parse_quote!(u8),
205 ParseAs::U16 => parse_quote!(u16),
206 ParseAs::U32 => parse_quote!(u32),
207 ParseAs::U64 => parse_quote!(u64),
208 ParseAs::I8 => parse_quote!(i8),
209 ParseAs::I16 => parse_quote!(i16),
210 ParseAs::I32 => parse_quote!(i32),
211 ParseAs::I64 => parse_quote!(i64),
212 ParseAs::F32 => parse_quote!(f32),
213 ParseAs::F64 => parse_quote!(f64),
214 ParseAs::Bool => parse_quote!(bool),
215 ParseAs::Date => parse_quote!(satay_runtime::Date),
216 ParseAs::NaiveDateTime => parse_quote!(satay_runtime::PrimitiveDateTime),
217 ParseAs::OffsetDateTime => parse_quote!(satay_runtime::OffsetDateTime),
218 ParseAs::UnixTime => parse_quote!(satay_runtime::OffsetDateTime),
219 ParseAs::Time => parse_quote!(satay_runtime::Time),
220 ParseAs::IntegerRange | ParseAs::NumberRange => {
221 unreachable!("range parse-as uses generated range types")
222 }
223 }
224}
225
226pub fn parse_as_string_serde_module(parse_as: ParseAs) -> &'static str {
227 match parse_as {
228 ParseAs::U8 => "satay_runtime::serde_string::as_u8",
229 ParseAs::U16 => "satay_runtime::serde_string::as_u16",
230 ParseAs::U32 => "satay_runtime::serde_string::as_u32",
231 ParseAs::U64 => "satay_runtime::serde_string::as_u64",
232 ParseAs::I8 => "satay_runtime::serde_string::as_i8",
233 ParseAs::I16 => "satay_runtime::serde_string::as_i16",
234 ParseAs::I32 => "satay_runtime::serde_string::as_i32",
235 ParseAs::I64 => "satay_runtime::serde_string::as_i64",
236 ParseAs::F32 => "satay_runtime::serde_string::as_f32",
237 ParseAs::F64 => "satay_runtime::serde_string::as_f64",
238 ParseAs::Bool => "satay_runtime::serde_string::as_bool",
239 ParseAs::Date => "satay_runtime::serde_string::as_date",
240 ParseAs::NaiveDateTime => "satay_runtime::serde_string::as_naive_datetime",
241 ParseAs::OffsetDateTime => "satay_runtime::serde_string::as_offset_datetime",
242 ParseAs::UnixTime => "satay_runtime::serde_string::as_unix_time",
243 ParseAs::Time => "satay_runtime::serde_string::as_time",
244 ParseAs::IntegerRange | ParseAs::NumberRange => {
245 unreachable!("range parse-as uses generated range types")
246 }
247 }
248}
249
250pub fn parse_as_integer_serde_module(parse_as: ParseAs) -> &'static str {
251 match parse_as {
252 ParseAs::Bool => "satay_runtime::serde_integer::as_bool",
253 ParseAs::UnixTime => "satay_runtime::serde_integer::as_unix_time",
254 ParseAs::U8
255 | ParseAs::U16
256 | ParseAs::U32
257 | ParseAs::U64
258 | ParseAs::I8
259 | ParseAs::I16
260 | ParseAs::I32
261 | ParseAs::I64
262 | ParseAs::F32
263 | ParseAs::F64
264 | ParseAs::Date
265 | ParseAs::NaiveDateTime
266 | ParseAs::OffsetDateTime
267 | ParseAs::Time
268 | ParseAs::IntegerRange
269 | ParseAs::NumberRange => unreachable!("only bool and unixtime can parse from integer"),
270 }
271}
272
273pub fn rust_field_type(ty: &TypeRef, required: bool, treat_error_as_none: bool) -> syn::Type {
274 if (required && !treat_error_as_none) || ty.is_option() {
275 rust_type(ty)
276 } else {
277 let ty = rust_type(ty);
278 parse_quote!(Option<#ty>)
279 }
280}
281
282pub fn input_fields(operation: &Operation) -> Vec<Field> {
283 let mut input_fields = Vec::with_capacity(
284 operation.parameters.len() + usize::from(operation.request_body.is_some()),
285 );
286 input_fields.extend(operation.parameters.iter().map(|parameter| Field {
287 wire_name: parameter.wire_name.clone(),
288 rust_name: parameter.rust_name.clone(),
289 description: parameter.description.clone(),
290 ty: parameter.ty.clone(),
291 required: parameter.required,
292 treat_error_as_none: false,
293 }));
294 if let Some(body) = &operation.request_body {
295 input_fields.push(Field {
296 wire_name: body.field_name.clone(),
297 rust_name: body.field_name.clone(),
298 description: body.description.clone(),
299 ty: body.ty.clone(),
300 required: body.required,
301 treat_error_as_none: false,
302 });
303 }
304
305 input_fields
306}
307
308pub fn input_setter_name(field: &Field) -> Ident {
309 if field.rust_name == "new" {
310 ident("with_new")
311 } else {
312 ident(&field.rust_name)
313 }
314}
315
316pub fn input_builder_arg_type(ty: &TypeRef) -> TokenStream {
317 if ty == &TypeRef::String {
318 quote!(impl Into<String>)
319 } else {
320 let ty = rust_type(ty);
321 quote!(#ty)
322 }
323}
324
325pub fn input_builder_value(value: TokenStream, ty: &TypeRef) -> TokenStream {
326 if ty == &TypeRef::String {
327 quote!(#value.into())
328 } else {
329 value
330 }
331}
332
333pub fn request_from_parts_expr(operation: &Operation) -> syn::Expr {
334 match &operation.request_body {
335 Some(body) if body.required => parse_quote!(satay_runtime::into_json_request(parts)),
336 Some(_) => parse_quote!(satay_runtime::into_optional_json_request(parts)),
337 None => parse_quote!(satay_runtime::into_empty_request(parts)),
338 }
339}
340
341pub fn input_field(field: &str) -> syn::Expr {
342 let field = ident(field);
343 parse_quote!(input.#field)
344}
345
346mod api;
347mod endpoint;
348mod types;
349
350#[cfg(test)]
351mod tests {
352 use super::*;
353 use crate::model::PathSegment;
354 use crate::model::{Component, ComponentKind, HttpMethod, RequestBody, ResponseCase};
355 use quote::{ToTokens, quote};
356 use syn::{Fields, GenericArgument, Item, PathArguments, Type};
357
358 #[test]
359 fn render_file_exposes_struct_ast_without_source_comparison() {
360 let api = Api::new(
361 String::new(),
362 vec![],
363 vec![Component {
364 rust_name: "Pet".to_owned(),
365 description: None,
366 kind: ComponentKind::Struct(vec![
367 Field {
368 wire_name: "id".to_owned(),
369 rust_name: "id".to_owned(),
370 description: None,
371 ty: TypeRef::String,
372 required: true,
373 treat_error_as_none: false,
374 },
375 Field {
376 wire_name: "tag_count".to_owned(),
377 rust_name: "tag_count".to_owned(),
378 description: None,
379 ty: TypeRef::Integer(IntegerType::I32),
380 required: false,
381 treat_error_as_none: false,
382 },
383 ]),
384 }],
385 vec![],
386 vec![],
387 );
388
389 let file = types::render_types_file(&api);
390 assert_eq!(file.items.len(), 1);
391 let Item::Struct(item) = &file.items[0] else {
392 panic!("expected struct item");
393 };
394 assert_eq!(item.ident, "Pet");
395 let Fields::Named(fields) = &item.fields else {
396 panic!("expected named fields");
397 };
398 assert_eq!(fields.named.len(), 2);
399
400 let mut fields = fields.named.iter();
401 let id = fields.next().expect("id field");
402 assert_eq!(id.ident.as_ref().expect("field ident"), "id");
403 assert!(type_path_is(&id.ty, "String"));
404
405 let tag_count = fields.next().expect("tag_count field");
406 assert_eq!(tag_count.ident.as_ref().expect("field ident"), "tag_count");
407 let Some(inner) = option_inner(&tag_count.ty) else {
408 panic!("optional field should render as Option<T>");
409 };
410 assert!(type_path_is(inner, "i32"));
411 }
412
413 #[test]
414 fn render_file_exposes_operation_items_without_source_comparison() {
415 let api = Api::new(
416 String::new(),
417 vec![],
418 vec![],
419 vec![],
420 vec![Operation {
421 fn_name: "create_pet".to_owned(),
422 description: None,
423 input_name: "CreatePetInput".to_owned(),
424 response_name: "CreatePetResponse".to_owned(),
425 method: HttpMethod::Post,
426 path: "/pets".to_owned(),
427 path_segments: vec![PathSegment::Literal("/pets".to_owned())],
428 parameters: vec![],
429 request_body: Some(RequestBody {
430 field_name: "body".to_owned(),
431 description: None,
432 content_type: "application/json".to_owned(),
433 ty: TypeRef::Named("Pet".to_owned()),
434 required: true,
435 }),
436 responses: vec![ResponseCase {
437 status: 201,
438 variant_name: "Created".to_owned(),
439 description: None,
440 body: Some(TypeRef::Named("Pet".to_owned())),
441 }],
442 }],
443 );
444
445 let files = render_api(&api, GenerateOptions::default());
446 assert!(files.iter().any(|f| f.relative_path == "mod.rs"));
447 assert!(files.iter().any(|f| f.relative_path == "create_pet/mod.rs"));
448 assert!(
449 files
450 .iter()
451 .any(|f| f.relative_path == "create_pet/parts.rs")
452 );
453 assert!(
454 files
455 .iter()
456 .any(|f| f.relative_path == "create_pet/json.rs")
457 );
458 }
459
460 #[test]
461 fn rust_field_type_wraps_optional_and_treat_error_as_none_fields() {
462 assert_eq!(
463 rust_field_type(&TypeRef::String, true, false)
464 .to_token_stream()
465 .to_string(),
466 "String"
467 );
468 assert_eq!(
469 rust_field_type(&TypeRef::String, false, false)
470 .to_token_stream()
471 .to_string(),
472 "Option < String >"
473 );
474 assert_eq!(
475 rust_field_type(&TypeRef::String, true, true)
476 .to_token_stream()
477 .to_string(),
478 "Option < String >"
479 );
480 assert_eq!(
481 rust_field_type(&TypeRef::Option(Box::new(TypeRef::String)), true, false)
482 .to_token_stream()
483 .to_string(),
484 "Option < String >"
485 );
486 }
487
488 #[test]
489 fn input_builder_arguments_convert_strings_only() {
490 assert_eq!(
491 input_builder_arg_type(&TypeRef::String).to_string(),
492 "impl Into < String >"
493 );
494 assert_eq!(
495 input_builder_arg_type(&TypeRef::Integer(IntegerType::I32)).to_string(),
496 "i32"
497 );
498 assert_eq!(
499 input_builder_value(quote!(value), &TypeRef::String).to_string(),
500 "value . into ()"
501 );
502 assert_eq!(
503 input_builder_value(quote!(value), &TypeRef::Integer(IntegerType::I32)).to_string(),
504 "value"
505 );
506 }
507
508 #[test]
509 fn request_conversion_mode_matches_body_requirement() {
510 assert_eq!(
511 request_from_parts_expr(&operation_with_body(None))
512 .to_token_stream()
513 .to_string(),
514 "satay_runtime :: into_empty_request (parts)"
515 );
516 assert_eq!(
517 request_from_parts_expr(&operation_with_body(Some(true)))
518 .to_token_stream()
519 .to_string(),
520 "satay_runtime :: into_json_request (parts)"
521 );
522 assert_eq!(
523 request_from_parts_expr(&operation_with_body(Some(false)))
524 .to_token_stream()
525 .to_string(),
526 "satay_runtime :: into_optional_json_request (parts)"
527 );
528 }
529
530 fn operation_with_body(required: Option<bool>) -> Operation {
531 Operation {
532 fn_name: "create_pet".to_owned(),
533 description: None,
534 input_name: "CreatePetInput".to_owned(),
535 response_name: "CreatePetResponse".to_owned(),
536 method: HttpMethod::Post,
537 path: "/pets".to_owned(),
538 path_segments: vec![PathSegment::Literal("/pets".to_owned())],
539 parameters: vec![],
540 request_body: required.map(|required| RequestBody {
541 field_name: "body".to_owned(),
542 description: None,
543 content_type: "application/json".to_owned(),
544 ty: TypeRef::Named("Pet".to_owned()),
545 required,
546 }),
547 responses: vec![],
548 }
549 }
550
551 fn type_path_is(ty: &syn::Type, expected: &str) -> bool {
552 let Type::Path(path) = ty else {
553 return false;
554 };
555 path.path.is_ident(expected)
556 }
557
558 fn option_inner(ty: &syn::Type) -> Option<&syn::Type> {
559 let Type::Path(path) = ty else {
560 return None;
561 };
562 let segment = path.path.segments.first()?;
563 if segment.ident != "Option" {
564 return None;
565 }
566 let PathArguments::AngleBracketed(arguments) = &segment.arguments else {
567 return None;
568 };
569 let GenericArgument::Type(inner) = arguments.args.first()? else {
570 return None;
571 };
572 Some(inner)
573 }
574}