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