1use proc_macro::TokenStream;
2use proc_macro_crate::{FoundCrate, crate_name};
3use quote::quote;
4use std::collections::HashSet;
5use syn::{
6 Data, DeriveInput, Error, Fields, Ident, LitStr, Path, Token, parse_macro_input,
7 spanned::Spanned,
8};
9
10fn orm_path() -> syn::Result<proc_macro2::TokenStream> {
11 match crate_name("che-orm") {
12 Ok(FoundCrate::Itself) => Ok(quote!(crate)),
13 Ok(FoundCrate::Name(name)) => {
14 let ident = Ident::new(&name, proc_macro2::Span::call_site());
15 Ok(quote!(::#ident))
16 }
17 Err(error) => Err(Error::new(
18 proc_macro2::Span::call_site(),
19 format!("could not resolve che-orm dependency: {error}"),
20 )),
21 }
22}
23
24#[proc_macro_derive(Model, attributes(orm))]
25pub fn derive_model(input: TokenStream) -> TokenStream {
26 match derive_model_impl(parse_macro_input!(input as DeriveInput)) {
27 Ok(tokens) => tokens.into(),
28 Err(error) => error.into_compile_error().into(),
29 }
30}
31
32#[proc_macro_derive(DbEnum, attributes(db_enum))]
33pub fn derive_db_enum(input: TokenStream) -> TokenStream {
34 match derive_db_enum_impl(parse_macro_input!(input as DeriveInput)) {
35 Ok(tokens) => tokens.into(),
36 Err(error) => error.into_compile_error().into(),
37 }
38}
39
40fn derive_db_enum_impl(input: DeriveInput) -> syn::Result<proc_macro2::TokenStream> {
41 let orm = orm_path()?;
42 if !input.generics.params.is_empty() {
43 return Err(Error::new_spanned(
44 &input.generics,
45 "DbEnum does not support generic enums",
46 ));
47 }
48 let name = input.ident;
49 let variants = match input.data {
50 Data::Enum(data) => data.variants,
51 _ => {
52 return Err(Error::new_spanned(
53 name,
54 "DbEnum can only be derived for enums",
55 ));
56 }
57 };
58 let mut as_str_arms = Vec::new();
59 let mut from_str_arms = Vec::new();
60 let mut values = Vec::new();
61 for variant in variants {
62 if !variant.fields.is_empty() {
63 return Err(Error::new_spanned(
64 variant,
65 "DbEnum variants must be unit variants",
66 ));
67 }
68 let ident = variant.ident;
69 let mut value = None;
70 for attribute in &variant.attrs {
71 if !attribute.path().is_ident("db_enum") {
72 continue;
73 }
74 attribute.parse_nested_meta(|meta| {
75 if meta.path.is_ident("rename") {
76 if value.is_some() {
77 return Err(meta.error("db_enum rename is declared more than once"));
78 }
79 value = Some(meta.value()?.parse::<LitStr>()?);
80 Ok(())
81 } else {
82 Err(meta.error("expected `rename = \"value\"`"))
83 }
84 })?;
85 }
86 let value =
87 value.unwrap_or_else(|| LitStr::new(&snake_case(&ident.to_string()), ident.span()));
88 if values
89 .iter()
90 .any(|existing: &LitStr| existing.value() == value.value())
91 {
92 return Err(Error::new_spanned(
93 &ident,
94 format!("duplicate DbEnum value `{}`", value.value()),
95 ));
96 }
97 values.push(value.clone());
98 as_str_arms.push(quote! { Self::#ident => #value });
99 from_str_arms.push(quote! { #value => Some(Self::#ident) });
100 }
101 if values.is_empty() {
102 return Err(Error::new_spanned(
103 name,
104 "DbEnum requires at least one variant",
105 ));
106 }
107 Ok(quote! {
108 impl #orm::DbEnum for #name {
109 const VALUES: &'static [&'static str] = &[#(#values),*];
110 fn as_str(&self) -> &'static str {
111 match self { #(#as_str_arms),* }
112 }
113 fn from_str(value: &str) -> Option<Self> {
114 match value { #(#from_str_arms,)* _ => None }
115 }
116 }
117
118 impl #orm::serde::Serialize for #name {
119 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
120 where S: #orm::serde::Serializer {
121 serializer.serialize_str(<Self as #orm::DbEnum>::as_str(self))
122 }
123 }
124
125 impl<'de> #orm::serde::Deserialize<'de> for #name {
126 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
127 where D: #orm::serde::Deserializer<'de> {
128 let value = <String as #orm::serde::Deserialize>::deserialize(deserializer)?;
129 <Self as #orm::DbEnum>::from_str(&value).ok_or_else(|| #orm::serde::de::Error::custom(
130 format!("invalid {} value: {}", stringify!(#name), value)
131 ))
132 }
133 }
134
135 impl #orm::rusqlite::types::FromSql for #name {
136 fn column_result(value: #orm::rusqlite::types::ValueRef<'_>)
137 -> #orm::rusqlite::types::FromSqlResult<Self>
138 {
139 let value = value.as_str()?;
140 <Self as #orm::DbEnum>::from_str(value)
141 .ok_or(#orm::rusqlite::types::FromSqlError::InvalidType)
142 }
143 }
144 })
145}
146
147fn snake_case(value: &str) -> String {
148 value
149 .chars()
150 .enumerate()
151 .fold(String::new(), |mut output, (index, ch)| {
152 if ch.is_uppercase() && index != 0 {
153 output.push('_');
154 }
155 output.extend(ch.to_lowercase());
156 output
157 })
158}
159
160#[proc_macro_derive(ModelSerializer, attributes(serializer))]
161pub fn derive_model_serializer(input: TokenStream) -> TokenStream {
162 match derive_model_serializer_impl(parse_macro_input!(input as DeriveInput)) {
163 Ok(tokens) => tokens.into(),
164 Err(error) => error.into_compile_error().into(),
165 }
166}
167
168fn derive_model_serializer_impl(input: DeriveInput) -> syn::Result<proc_macro2::TokenStream> {
169 let orm = orm_path()?;
170 let model = parse_serializer_model(&input.attrs)?;
171 let validator = parse_serializer_validator(&input.attrs)?;
172 let validator_call = validator.map_or_else(
173 proc_macro2::TokenStream::new,
174 |path| quote! { #path(&data, mode)?; },
175 );
176 let serializer = input.ident.clone();
177 let fields = match input.data {
178 Data::Struct(data) => match data.fields {
179 Fields::Named(fields) => fields.named,
180 _ => {
181 return Err(Error::new_spanned(
182 serializer,
183 "ModelSerializer can only be derived for structs with named fields",
184 ));
185 }
186 },
187 _ => {
188 return Err(Error::new_spanned(
189 serializer,
190 "ModelSerializer can only be derived for structs",
191 ));
192 }
193 };
194 let mut assignments = Vec::new();
195 let mut nested = Vec::new();
196 let mut serialize_fields = Vec::new();
197 let mut input_fields = Vec::new();
198 let mut serializer_fields = Vec::new();
199 for field in fields {
200 let name = field.ident.expect("named fields always have identifiers");
201 let field_type = field.ty.clone();
202 let json_name = name.to_string();
203 let mut read_only = false;
204 let mut write_only = false;
205 serialize_fields.push(quote! {
206 #orm::serde::ser::SerializeStruct::serialize_field(
207 &mut state,
208 #json_name,
209 &self.#name,
210 )?;
211 });
212 let mut nested_relation = None;
213 let mut relation_path = None;
214 let mut scalar_relation = None;
215 for attribute in &field.attrs {
216 if !attribute.path().is_ident("serializer") {
217 continue;
218 }
219 attribute.parse_nested_meta(|meta| {
220 if meta.path.is_ident("read_only") {
221 read_only = true;
222 Ok(())
223 } else if meta.path.is_ident("write_only") {
224 write_only = true;
225 Ok(())
226 } else if meta.path.is_ident("many") || meta.path.is_ident("one") {
227 let many = meta.path.is_ident("many");
228 let model: Path = meta.value()?.parse()?;
229 if nested_relation.is_some() {
230 return Err(meta.error("a serializer field can have only one relation"));
231 }
232 nested_relation = Some((many, model));
233 Ok(())
234 } else if meta.path.is_ident("relation") {
235 relation_path = Some(meta.value()?.parse::<Path>()?);
236 Ok(())
237 } else if meta.path.is_ident("foreign_key") {
238 scalar_relation = Some(meta.value()?.parse::<Path>()?);
239 Ok(())
240 } else {
241 Err(meta.error(
242 "unsupported serializer field attribute; expected read_only, write_only, foreign_key = Model, many = Model, one = Model or relation = Model::RELATION",
243 ))
244 }
245 })?;
246 }
247 if write_only {
248 serialize_fields.pop();
249 }
250 if nested_relation.is_some() && scalar_relation.is_some() {
251 return Err(Error::new_spanned(
252 &name,
253 "a serializer field cannot use both nested and scalar relation metadata",
254 ));
255 }
256 if let Some((many, related_model)) = nested_relation {
257 let relation_path = relation_path.ok_or_else(|| {
258 Error::new_spanned(
259 &name,
260 "nested serializer fields require `relation = RelationMarker`",
261 )
262 })?;
263 let marker = relation_marker(&relation_path)?;
264 let optional = !many && is_option_type(&field.ty);
265 let serializer_type = nested_serializer_type(&field.ty, many, optional)?;
266 nested.push((
267 name,
268 many,
269 related_model.clone(),
270 marker.clone(),
271 optional,
272 serializer_type,
273 ));
274 serializer_fields.push(quote! {
275 #orm::SerializerField {
276 name: #json_name,
277 source: <#marker as #orm::RelationSource>::SOURCE,
278 read_only: #read_only,
279 write_only: #write_only,
280 rust_type: ::core::stringify!(#field_type),
281 related_model: Some(::core::stringify!(#related_model)),
282 many: #many,
283 }
284 });
285 } else {
286 let related_model = scalar_relation
287 .as_ref()
288 .map(|model| quote! { Some(::core::stringify!(#model)) })
289 .unwrap_or_else(|| quote! { None });
290 let relation_source = if scalar_relation.is_some() {
291 let relation_path = relation_path.as_ref().ok_or_else(|| {
292 Error::new_spanned(
293 &name,
294 "scalar relation fields require `relation = RelationMarker`",
295 )
296 })?;
297 let marker = relation_marker(relation_path)?;
298 quote! { <#marker as #orm::RelationSource>::SOURCE }
299 } else {
300 quote! { #json_name }
301 };
302 serializer_fields.push(quote! {
303 #orm::SerializerField {
304 name: #json_name,
305 source: #relation_source,
306 read_only: #read_only,
307 write_only: #write_only,
308 rust_type: ::core::stringify!(#field_type),
309 related_model: #related_model,
310 many: false,
311 }
312 });
313 if !read_only {
314 let constant = Ident::new(&name.to_string().to_uppercase(), name.span());
315 input_fields.push((name.clone(), field.ty.clone(), constant));
316 }
317 assignments.push(quote! { #name: model.#name });
318 }
319 }
320 let serializer_fields = quote! { &[#(#serializer_fields),*] };
321 let has_nested = !nested.is_empty();
322 let field_count = serialize_fields.len();
323 let conversion = if nested.len() == 1 {
324 let (name, many, _related_model, marker, optional, serializer_type) =
325 nested.into_iter().next().unwrap();
326 let child_input = quote! { <#serializer_type as #orm::ModelSerializer>::Input };
327 let wrapper = if many {
328 quote! { #orm::WithMany<#model, #child_input, #marker> }
329 } else if optional {
330 quote! { #orm::WithOptionalOne<#model, #child_input, #marker> }
331 } else {
332 quote! { #orm::WithOne<#model, #child_input, #marker> }
333 };
334 let loaded_wrapper = quote! {
335 #orm::Loaded<#model, (#orm::LoadedMany<#child_input, #marker>,)>
336 };
337 let many_input = if many {
338 loaded_wrapper.clone()
339 } else {
340 wrapper.clone()
341 };
342 let nested_assignment = if many {
343 quote! { #name: value.related.into_iter().map(::core::convert::Into::into).collect() }
344 } else if optional {
345 quote! { #name: value.related.map(::core::convert::Into::into) }
346 } else {
347 quote! { #name: ::core::convert::Into::into(value.related) }
348 };
349 let loaded_conversion = if many {
350 quote! {
351 impl ::core::convert::From<#loaded_wrapper> for #serializer {
352 fn from(value: #loaded_wrapper) -> Self {
353 let model = value.model;
354 let (relation,) = value.relations;
355 Self {
356 #(#assignments,)*
357 #name: relation.related
358 .into_iter()
359 .map(::core::convert::Into::into)
360 .collect()
361 }
362 }
363 }
364
365 impl #orm::ModelSerializer for #serializer {
366 type Model = #model;
367 type Input = #loaded_wrapper;
368
369 fn from_input(value: Self::Input) -> Self {
370 <Self as ::core::convert::From<#loaded_wrapper>>::from(value)
371 }
372
373 fn fields() -> &'static [#orm::SerializerField] {
374 #serializer_fields
375 }
376 }
377 }
378 } else {
379 quote! {
380 impl #orm::ModelSerializer for #serializer {
381 type Model = #model;
382 type Input = #wrapper;
383
384 fn from_input(value: Self::Input) -> Self {
385 <Self as ::core::convert::From<#wrapper>>::from(value)
386 }
387
388 fn fields() -> &'static [#orm::SerializerField] {
389 #serializer_fields
390 }
391 }
392 }
393 };
394 quote! {
395 impl ::core::convert::From<#wrapper> for #serializer {
396 fn from(value: #wrapper) -> Self {
397 let model = value.model;
398 Self { #(#assignments,)* #nested_assignment }
399 }
400 }
401
402 #loaded_conversion
403
404 impl #serializer {
405 pub fn many<I>(values: I) -> ::std::vec::Vec<Self>
406 where
407 I: ::core::iter::IntoIterator<Item = #many_input>,
408 {
409 values.into_iter().map(::core::convert::Into::into).collect()
410 }
411 }
412 }
413 } else if nested.len() > 1 {
414 let mut wrappers = Vec::new();
415 let mut relation_vars = Vec::new();
416 let mut nested_assignments = Vec::new();
417 for (index, (name, many, _related_model, marker, optional, serializer_type)) in
418 nested.into_iter().enumerate()
419 {
420 if !many || optional {
421 return Err(Error::new_spanned(
422 name,
423 "multiple nested fields currently support only `many` relations",
424 ));
425 }
426 let relation_var = Ident::new(
427 &format!("__relation{index}"),
428 proc_macro2::Span::call_site(),
429 );
430 relation_vars.push(relation_var.clone());
431 let child_input = quote! { <#serializer_type as #orm::ModelSerializer>::Input };
432 wrappers.push(quote! { #orm::LoadedMany<#child_input, #marker> });
433 nested_assignments.push(quote! {
434 #name: #relation_var.related
435 .into_iter()
436 .map(::core::convert::Into::into)
437 .collect()
438 });
439 }
440 let loaded_type = quote! {
441 #orm::Loaded<#model, (#(#wrappers),*,)>
442 };
443 let destructure = quote! { let (#(#relation_vars),*,) = value.relations; };
444 quote! {
445 impl ::core::convert::From<#loaded_type> for #serializer {
446 fn from(value: #loaded_type) -> Self {
447 let model = value.model;
448 #destructure
449 Self { #(#assignments,)* #(#nested_assignments),* }
450 }
451 }
452
453 impl #orm::ModelSerializer for #serializer {
454 type Model = #model;
455 type Input = #loaded_type;
456
457 fn from_input(value: Self::Input) -> Self {
458 <Self as ::core::convert::From<#loaded_type>>::from(value)
459 }
460
461 fn fields() -> &'static [#orm::SerializerField] {
462 #serializer_fields
463 }
464 }
465
466 impl #serializer {
467 pub fn many<I>(values: I) -> ::std::vec::Vec<Self>
468 where
469 I: ::core::iter::IntoIterator<Item = #loaded_type>,
470 {
471 values.into_iter().map(::core::convert::Into::into).collect()
472 }
473 }
474 }
475 } else {
476 quote! {
477 impl ::core::convert::From<#model> for #serializer {
478 fn from(model: #model) -> Self {
479 <Self as #orm::ModelSerializer>::from_input(model)
480 }
481 }
482
483 impl #serializer {
484 pub fn from_model(model: #model) -> Self {
485 <Self as #orm::ModelSerializer>::from_input(model)
486 }
487
488 pub fn many<I>(values: I) -> ::std::vec::Vec<Self>
489 where
490 I: ::core::iter::IntoIterator<Item = #model>,
491 {
492 values.into_iter().map(::core::convert::Into::into).collect()
493 }
494 }
495 }
496 };
497
498 let trait_impl = if has_nested {
499 quote! {}
500 } else {
501 quote! {
502 impl #orm::ModelSerializer for #serializer {
503 type Model = #model;
504 type Input = #model;
505
506 fn from_input(model: Self::Input) -> Self {
507 Self { #(#assignments),* }
508 }
509
510 fn fields() -> &'static [#orm::SerializerField] {
511 #serializer_fields
512 }
513 }
514 }
515 };
516
517 let create_name = Ident::new(&format!("{}CreateInput", serializer), serializer.span());
518 let update_name = Ident::new(&format!("{}UpdateInput", serializer), serializer.span());
519 let patch_name = Ident::new(&format!("{}PatchInput", serializer), serializer.span());
520 let input_names = input_fields
521 .iter()
522 .map(|(name, _, _)| name.clone())
523 .collect::<Vec<_>>();
524 let input_types = input_fields
525 .iter()
526 .map(|(_, ty, _)| ty.clone())
527 .collect::<Vec<_>>();
528 let create_sets = input_fields.iter().map(|(name, _, constant)| {
529 quote! {
530 let builder = builder.set(<#model>::#constant, input.#name);
531 }
532 });
533 let update_sets = input_fields.iter().map(|(name, _, constant)| {
534 quote! {
535 let builder = builder.set(<#model>::#constant, input.#name);
536 }
537 });
538 let patch_sets = input_fields.iter().map(|(name, _, constant)| {
539 quote! {
540 let builder = match input.#name {
541 #orm::PatchField::Missing => builder,
542 #orm::PatchField::Value(value) => builder.set(<#model>::#constant, value),
543 };
544 }
545 });
546 let patch_missing_checks = input_fields
547 .iter()
548 .map(|(name, _, _)| quote! { input.#name.is_missing() })
549 .collect::<Vec<_>>();
550 let patch_empty = if patch_missing_checks.is_empty() {
551 quote! { true }
552 } else {
553 quote! { #(#patch_missing_checks)&&* }
554 };
555
556 Ok(quote! {
557 #[derive(Debug, #orm::serde::Deserialize)]
558 #[serde(deny_unknown_fields)]
559 pub struct #create_name {
560 #(pub #input_names: #input_types,)*
561 }
562
563 #[derive(Debug, #orm::serde::Deserialize)]
564 #[serde(deny_unknown_fields)]
565 pub struct #update_name {
566 #(pub #input_names: #input_types,)*
567 }
568
569 #[derive(Debug, #orm::serde::Deserialize)]
570 #[serde(deny_unknown_fields)]
571 pub struct #patch_name {
572 #(#[serde(default)] pub #input_names: #orm::PatchField<#input_types>,)*
573 }
574
575 impl #orm::ModelWriteSerializer for #serializer {
576 type Model = #model;
577
578 fn is_valid(
579 data: #orm::serde_json::Value,
580 mode: #orm::WriteMode,
581 ) -> ::core::result::Result<#orm::ValidatedWrite<#model>, #orm::ValidationErrors> {
582 #validator_call
583 match mode {
584 #orm::WriteMode::Create => {
585 let input: #create_name = #orm::serde_json::from_value(data)?;
586 let builder = <#model as #orm::Model>::insert();
587 #(#create_sets)*
588 Ok(#orm::ValidatedWrite::Create(builder))
589 }
590 #orm::WriteMode::Update { id } => {
591 let input: #update_name = #orm::serde_json::from_value(data)?;
592 let builder = <#model as #orm::Model>::update()
593 .filter(<#model as #orm::Model>::primary_key().eq(id));
594 #(#update_sets)*
595 Ok(#orm::ValidatedWrite::Update(builder))
596 }
597 #orm::WriteMode::Patch { id } => {
598 let input: #patch_name = #orm::serde_json::from_value(data)?;
599 if #patch_empty {
600 return Err(#orm::ValidationErrors {
601 detail: "patch must contain at least one field".into(),
602 });
603 }
604 let builder = <#model as #orm::Model>::update()
605 .filter(<#model as #orm::Model>::primary_key().eq(id));
606 #(#patch_sets)*
607 Ok(#orm::ValidatedWrite::Update(builder))
608 }
609 }
610 }
611 }
612
613 impl #orm::serde::Serialize for #serializer {
614 fn serialize<__Serializer>(
615 &self,
616 serializer: __Serializer,
617 ) -> ::core::result::Result<__Serializer::Ok, __Serializer::Error>
618 where
619 __Serializer: #orm::serde::Serializer,
620 {
621 let mut state = #orm::serde::Serializer::serialize_struct(
622 serializer,
623 stringify!(#serializer),
624 #field_count,
625 )?;
626 #(#serialize_fields)*
627 #orm::serde::ser::SerializeStruct::end(state)
628 }
629 }
630
631 #trait_impl
632 #conversion
633 })
634}
635
636fn parse_serializer_model(attributes: &[syn::Attribute]) -> syn::Result<Path> {
637 let mut model = None;
638 for attribute in attributes {
639 if !attribute.path().is_ident("serializer") {
640 continue;
641 }
642 attribute.parse_nested_meta(|meta| {
643 if meta.path.is_ident("model") {
644 if model.is_some() {
645 return Err(meta.error("serializer model is declared more than once"));
646 }
647 model = Some(meta.value()?.parse()?);
648 Ok(())
649 } else if meta.path.is_ident("validate") {
650 let _: Path = meta.value()?.parse()?;
651 Ok(())
652 } else {
653 Err(meta.error("expected `model = Model`"))
654 }
655 })?;
656 }
657 model.ok_or_else(|| {
658 Error::new(
659 proc_macro2::Span::call_site(),
660 "serializer requires `#[serializer(model = Model)]`",
661 )
662 })
663}
664
665fn parse_serializer_validator(attributes: &[syn::Attribute]) -> syn::Result<Option<Path>> {
666 let mut validator = None;
667 for attribute in attributes {
668 if !attribute.path().is_ident("serializer") {
669 continue;
670 }
671 attribute.parse_nested_meta(|meta| {
672 if meta.path.is_ident("validate") {
673 if validator.is_some() {
674 return Err(meta.error("serializer validator is declared more than once"));
675 }
676 validator = Some(meta.value()?.parse()?);
677 Ok(())
678 } else if meta.path.is_ident("model") {
679 let _: Path = meta.value()?.parse()?;
680 Ok(())
681 } else {
682 Err(meta.error("expected `model = Model` or `validate = path`"))
683 }
684 })?;
685 }
686 Ok(validator)
687}
688
689fn relation_marker(path: &Path) -> syn::Result<Ident> {
690 let mut segments = path.segments.iter();
691 let model = segments
692 .next()
693 .ok_or_else(|| Error::new_spanned(path, "relation must use `RelationMarker`"))?;
694 if segments.clone().next().is_none() {
695 return Ok(model.ident.clone());
696 }
697 let relation = segments
698 .next()
699 .ok_or_else(|| Error::new_spanned(path, "relation must use `RelationMarker`"))?;
700 if segments.next().is_some() {
701 return Err(Error::new_spanned(
702 path,
703 "relation must use `RelationMarker`",
704 ));
705 }
706 Ok(Ident::new(
707 &format!("{}{}Relation", model.ident, relation.ident),
708 path.span(),
709 ))
710}
711
712fn is_option_type(ty: &syn::Type) -> bool {
713 let syn::Type::Path(path) = ty else {
714 return false;
715 };
716 path.path
717 .segments
718 .last()
719 .is_some_and(|segment| segment.ident == "Option")
720}
721
722fn nested_serializer_type(ty: &syn::Type, many: bool, optional: bool) -> syn::Result<Path> {
723 let inner = if many {
724 let syn::Type::Path(path) = ty else {
725 return Err(Error::new_spanned(
726 ty,
727 "many serializer field must be Vec<Serializer>",
728 ));
729 };
730 let segment = path.path.segments.last().ok_or_else(|| {
731 Error::new_spanned(ty, "many serializer field must be Vec<Serializer>")
732 })?;
733 if segment.ident != "Vec" {
734 return Err(Error::new_spanned(
735 ty,
736 "many serializer field must be Vec<Serializer>",
737 ));
738 }
739 let syn::PathArguments::AngleBracketed(arguments) = &segment.arguments else {
740 return Err(Error::new_spanned(
741 ty,
742 "many serializer field must be Vec<Serializer>",
743 ));
744 };
745 arguments.args.first().cloned()
746 } else if optional {
747 let syn::Type::Path(path) = ty else {
748 return Err(Error::new_spanned(
749 ty,
750 "optional relation must be Option<Serializer>",
751 ));
752 };
753 let segment = path.path.segments.last().ok_or_else(|| {
754 Error::new_spanned(ty, "optional relation must be Option<Serializer>")
755 })?;
756 let syn::PathArguments::AngleBracketed(arguments) = &segment.arguments else {
757 return Err(Error::new_spanned(
758 ty,
759 "optional relation must be Option<Serializer>",
760 ));
761 };
762 arguments.args.first().cloned()
763 } else {
764 match ty {
765 syn::Type::Path(_) => Some(syn::GenericArgument::Type(ty.clone())),
766 _ => None,
767 }
768 };
769 match inner {
770 Some(syn::GenericArgument::Type(syn::Type::Path(path))) => Ok(path.path),
771 _ => Err(Error::new_spanned(
772 ty,
773 "nested serializer field must contain a serializer type",
774 )),
775 }
776}
777
778fn pascal_case(value: &str) -> String {
779 let mut chars = value.chars();
780 let Some(first) = chars.next() else {
781 return String::new();
782 };
783 first.to_ascii_uppercase().to_string() + chars.as_str()
784}
785
786fn derive_model_impl(input: DeriveInput) -> syn::Result<proc_macro2::TokenStream> {
787 let orm = orm_path()?;
788 let model_attributes = parse_model_attributes(&input)?;
789 let table = model_attributes.table;
790 validate_identifier(&table.value(), table.span(), "table")?;
791 let fields = match input.data {
792 Data::Struct(data) => match data.fields {
793 Fields::Named(fields) => fields.named,
794 _ => {
795 return Err(Error::new_spanned(
796 input.ident,
797 "Model can only be derived for structs with named fields",
798 ));
799 }
800 },
801 _ => {
802 return Err(Error::new_spanned(
803 input.ident,
804 "Model can only be derived for structs",
805 ));
806 }
807 };
808
809 let model = input.ident;
810 let mut columns = Vec::with_capacity(fields.len());
811 let mut constants = Vec::with_capacity(fields.len());
812 let mut schema_columns = Vec::with_capacity(fields.len());
813 let mut row_fields = Vec::with_capacity(fields.len());
814 let mut insert_values = Vec::with_capacity(fields.len());
815 let mut managed_update_values = Vec::with_capacity(fields.len());
816 let mut relation_constants = Vec::new();
817 let mut relation_markers = Vec::new();
818 let mut primary_key_seen = false;
819 let mut primary_key_constant = None;
820 let mut primary_key_field = None;
821 let mut generated_constants = HashSet::new();
822
823 for (index, field) in fields.into_iter().enumerate() {
824 let field_name = field.ident.expect("named fields always have identifiers");
825 let column = field_name.to_string();
826 let constant = Ident::new(&column.to_uppercase(), field_name.span());
827 let field_type = field.ty;
828 let field_attributes = parse_field_attributes(&field.attrs)?;
829
830 if !generated_constants.insert(constant.to_string()) {
831 return Err(Error::new_spanned(
832 &field_name,
833 format!("generated constant {constant} conflicts with another model field"),
834 ));
835 }
836
837 if field_attributes.foreign_key.is_some()
838 && !is_i64(&field_type)
839 && !is_option_i64(&field_type)
840 {
841 return Err(Error::new_spanned(
842 &field_type,
843 "foreign_key currently requires an i64 field",
844 ));
845 }
846
847 if field_attributes.foreign_key.is_some()
848 && field_attributes
849 .on_delete
850 .as_ref()
851 .is_some_and(|action| action.value().eq_ignore_ascii_case("set null"))
852 && !is_option_i64(&field_type)
853 {
854 return Err(Error::new_spanned(
855 &field_type,
856 "on_delete = \"set null\" requires an Option<i64> foreign_key field",
857 ));
858 }
859
860 if field_attributes.primary_key {
861 if primary_key_seen {
862 return Err(Error::new_spanned(
863 &field_name,
864 "a model can have only one primary_key field",
865 ));
866 }
867 if !is_i64(&field_type) {
868 return Err(Error::new_spanned(
869 &field_type,
870 "primary_key requires an i64 field",
871 ));
872 }
873 primary_key_seen = true;
874 primary_key_constant = Some(constant.clone());
875 primary_key_field = Some(field_name.clone());
876 }
877
878 if (field_attributes.auto_now_add || field_attributes.auto_now)
879 && !is_offset_date_time(&field_type)
880 {
881 return Err(Error::new_spanned(
882 field_type,
883 "auto_now_add and auto_now require time::OffsetDateTime",
884 ));
885 }
886
887 columns.push(LitStr::new(&column, field_name.span()));
888 constants.push(quote! {
889 pub const #constant: #orm::ModelField<Self, #field_type> =
890 #orm::ModelField::new(#table, #column);
891 });
892
893 let primary_key = field_attributes.primary_key;
894 let unique = field_attributes.unique;
895 let auto_now_add = field_attributes.auto_now_add;
896 let auto_now = field_attributes.auto_now;
897 let default = field_attributes
898 .default
899 .map(|value| quote! { column.default = Some(#value); });
900 let check = field_attributes
901 .check
902 .map(|value| quote! { column.check = Some(#value); });
903 let references = field_attributes.references.map(|target| {
904 let on_delete = field_attributes
905 .on_delete
906 .clone()
907 .map(|value| quote! { Some(#value) })
908 .unwrap_or_else(|| quote! { None });
909 quote! {
910 column.references = Some(#orm::ForeignKey::new(
911 #target,
912 #on_delete,
913 ));
914 }
915 });
916 let foreign_key = field_attributes.foreign_key.as_ref().map(|target| {
917 let on_delete = field_attributes
918 .on_delete
919 .clone()
920 .map(|value| quote! { Some(#value) })
921 .unwrap_or_else(|| quote! { None });
922 quote! {
923 column.references = Some(#orm::ForeignKey::new(
924 format!(
925 "{}({})",
926 <#target as #orm::Model>::table_name(),
927 <#target as #orm::Model>::primary_key().column().name,
928 ),
929 #on_delete,
930 ));
931 }
932 });
933 if let Some(target) = &field_attributes.foreign_key {
934 let relation_name = column.strip_suffix("_id").unwrap_or(&column).to_uppercase();
935 let alias = column
936 .strip_suffix("_id")
937 .unwrap_or(&column)
938 .to_ascii_lowercase();
939 let relation_constant = Ident::new(&relation_name, field_name.span());
940 let marker_name = Ident::new(
941 &format!(
942 "{}{}Relation",
943 model,
944 pascal_case(column.strip_suffix("_id").unwrap_or(&column))
945 ),
946 field_name.span(),
947 );
948 if !generated_constants.insert(relation_name.clone()) {
949 return Err(Error::new_spanned(
950 &field_name,
951 format!(
952 "generated relation constant {relation_name} conflicts with a model field"
953 ),
954 ));
955 }
956 let reverse_name = format!("{}_set", model.to_string().to_lowercase());
957 relation_constants.push(quote! {
958 pub const #relation_constant:
959 #orm::BelongsTo<Self, #target, #marker_name, #field_type> =
960 #orm::BelongsTo::new(
961 #table,
962 #column,
963 |model: &Self| model.#field_name,
964 #alias,
965 #reverse_name,
966 );
967 });
968 relation_markers.push(quote! {
969 #[allow(non_camel_case_types)]
970 pub struct #marker_name;
971 impl #orm::RelationSource for #marker_name {
972 const SOURCE: &'static str = #column;
973 }
974 });
975 }
976
977 schema_columns.push(quote! {
978 let mut column = #orm::ColumnSchema::new(
979 #column,
980 <#field_type as #orm::ColumnTypeOf>::column_type(),
981 <#field_type as #orm::ColumnTypeOf>::nullable(),
982 );
983 column.primary_key = #primary_key;
984 column.unique = #unique;
985 column.auto_now_add = #auto_now_add;
986 column.auto_now = #auto_now;
987 column.choices = <#field_type as #orm::ColumnTypeOf>::choices();
988 #default
989 #check
990 #references
991 #foreign_key
992 columns.push(column);
993 });
994
995 row_fields.push(quote! {
996 #field_name: row.get(#index + offset)?,
997 });
998
999 if !field_attributes.primary_key && !auto_now_add && !auto_now {
1000 insert_values.push(quote! {
1001 #orm::InsertValue {
1002 column: #orm::ColumnRef::new(#table, #column),
1003 value: #orm::QueryValue::<#field_type>::into_query_value(
1004 self.#field_name.clone(),
1005 ),
1006 }
1007 });
1008 }
1009
1010 if auto_now {
1011 managed_update_values.push(quote! {
1012 #orm::Assignment {
1013 column: #orm::ColumnRef::new(#table, #column),
1014 value: #orm::QueryValue::<#field_type>::into_query_value(
1015 #orm::time::OffsetDateTime::now_utc(),
1016 ),
1017 }
1018 });
1019 }
1020 }
1021
1022 let primary_key_constant = primary_key_constant.ok_or_else(|| {
1023 Error::new_spanned(
1024 &model,
1025 "Model requires exactly one #[orm(primary_key)] field",
1026 )
1027 })?;
1028 let primary_key_field = primary_key_field.expect("primary key constant has a field");
1029
1030 let unique_constraints = model_attributes.unique_constraints.iter().map(|columns| {
1031 quote! { vec![#(#columns),*] }
1032 });
1033 let indexes = model_attributes.indexes.iter().map(|columns| {
1034 quote! { vec![#(#columns),*] }
1035 });
1036
1037 Ok(quote! {
1038 #(#relation_markers)*
1039
1040 impl #orm::Model for #model {
1041 fn table_name() -> &'static str {
1042 #table
1043 }
1044
1045 fn columns() -> &'static [&'static str] {
1046 &[#(#columns),*]
1047 }
1048
1049 fn primary_key() -> #orm::ModelField<Self, i64> {
1050 Self::#primary_key_constant
1051 }
1052
1053 fn primary_key_value(&self) -> i64 {
1054 self.#primary_key_field
1055 }
1056
1057 fn schema() -> #orm::TableSchema {
1058 let mut columns = Vec::new();
1059 #(#schema_columns)*
1060 #orm::TableSchema {
1061 name: #table,
1062 columns,
1063 unique_constraints: vec![#(#unique_constraints),*],
1064 indexes: vec![#(#indexes),*],
1065 }
1066 }
1067
1068 fn from_row(row: &#orm::rusqlite::Row<'_>) -> #orm::rusqlite::Result<Self> {
1069 Self::from_row_at(row, 0)
1070 }
1071
1072 fn from_row_at(
1073 row: &#orm::rusqlite::Row<'_>,
1074 offset: usize,
1075 ) -> #orm::rusqlite::Result<Self> {
1076 Ok(Self {
1077 #(#row_fields)*
1078 })
1079 }
1080
1081 fn insert_values(&self) -> ::std::vec::Vec<#orm::InsertValue> {
1082 vec![#(#insert_values),*]
1083 }
1084
1085 fn managed_update_values() -> ::std::vec::Vec<#orm::Assignment> {
1086 vec![#(#managed_update_values),*]
1087 }
1088 }
1089
1090 impl #model {
1091 #(#constants)*
1092 #(#relation_constants)*
1093 }
1094 })
1095}
1096
1097struct ModelAttributes {
1098 table: LitStr,
1099 unique_constraints: Vec<Vec<LitStr>>,
1100 indexes: Vec<Vec<LitStr>>,
1101}
1102
1103fn parse_model_attributes(input: &DeriveInput) -> syn::Result<ModelAttributes> {
1104 let mut table = None;
1105 let mut unique_constraints = Vec::new();
1106 let mut indexes = Vec::new();
1107
1108 for attribute in &input.attrs {
1109 if !attribute.path().is_ident("orm") {
1110 continue;
1111 }
1112
1113 attribute.parse_nested_meta(|meta| {
1114 if meta.path.is_ident("table") {
1115 table = Some(meta.value()?.parse()?);
1116 Ok(())
1117 } else if meta.path.is_ident("unique") || meta.path.is_ident("index") {
1118 let content;
1119 syn::parenthesized!(content in meta.input);
1120 let values =
1121 content.parse_terminated(|input| input.parse::<LitStr>(), Token![,])?;
1122 if values.is_empty() {
1123 return Err(meta.error("constraint requires at least one column"));
1124 }
1125 let values = values.into_iter().collect::<Vec<_>>();
1126 for value in &values {
1127 validate_identifier(&value.value(), value.span(), "constraint column")?;
1128 }
1129 if meta.path.is_ident("unique") {
1130 unique_constraints.push(values);
1131 } else {
1132 indexes.push(values);
1133 }
1134 Ok(())
1135 } else {
1136 Err(meta
1137 .error("unsupported orm attribute; expected table, unique(...) or index(...)"))
1138 }
1139 })?;
1140 }
1141
1142 let table = table.ok_or_else(|| {
1143 Error::new_spanned(
1144 &input.ident,
1145 "Model requires #[orm(table = \"table_name\")]",
1146 )
1147 })?;
1148 Ok(ModelAttributes {
1149 table,
1150 unique_constraints,
1151 indexes,
1152 })
1153}
1154
1155struct FieldAttributes {
1156 primary_key: bool,
1157 unique: bool,
1158 default: Option<LitStr>,
1159 check: Option<LitStr>,
1160 references: Option<LitStr>,
1161 foreign_key: Option<Path>,
1162 on_delete: Option<LitStr>,
1163 auto_now_add: bool,
1164 auto_now: bool,
1165}
1166
1167fn parse_field_attributes(attributes: &[syn::Attribute]) -> syn::Result<FieldAttributes> {
1168 let mut result = FieldAttributes {
1169 primary_key: false,
1170 unique: false,
1171 default: None,
1172 check: None,
1173 references: None,
1174 foreign_key: None,
1175 on_delete: None,
1176 auto_now_add: false,
1177 auto_now: false,
1178 };
1179
1180 for attribute in attributes {
1181 if !attribute.path().is_ident("orm") {
1182 continue;
1183 }
1184 attribute.parse_nested_meta(|meta| {
1185 if meta.path.is_ident("primary_key") {
1186 result.primary_key = true;
1187 } else if meta.path.is_ident("unique") {
1188 result.unique = true;
1189 } else if meta.path.is_ident("default") {
1190 result.default = Some(meta.value()?.parse()?);
1191 } else if meta.path.is_ident("check") {
1192 result.check = Some(meta.value()?.parse()?);
1193 } else if meta.path.is_ident("references") {
1194 let value: LitStr = meta.value()?.parse()?;
1195 validate_reference(&value.value(), value.span())?;
1196 result.references = Some(value);
1197 } else if meta.path.is_ident("foreign_key") {
1198 if result.references.is_some() {
1199 return Err(meta.error("foreign_key and references are mutually exclusive"));
1200 }
1201 result.foreign_key = Some(meta.value()?.parse()?);
1202 } else if meta.path.is_ident("on_delete") {
1203 let value: LitStr = meta.value()?.parse()?;
1204 validate_on_delete(&value.value(), value.span())?;
1205 result.on_delete = Some(value);
1206 } else if meta.path.is_ident("auto_now_add") {
1207 result.auto_now_add = true;
1208 } else if meta.path.is_ident("auto_now") {
1209 result.auto_now = true;
1210 } else {
1211 return Err(meta.error("unsupported field attribute"));
1212 }
1213 Ok(())
1214 })?;
1215 }
1216
1217 if result.auto_now && result.auto_now_add {
1218 return Err(Error::new_spanned(
1219 &attributes[0],
1220 "a field cannot use both auto_now and auto_now_add",
1221 ));
1222 }
1223
1224 if result.references.is_some() && result.foreign_key.is_some() {
1225 return Err(Error::new_spanned(
1226 &attributes[0],
1227 "foreign_key and references are mutually exclusive",
1228 ));
1229 }
1230
1231 Ok(result)
1232}
1233
1234fn is_offset_date_time(ty: &syn::Type) -> bool {
1235 let syn::Type::Path(type_path) = ty else {
1236 return false;
1237 };
1238 type_path
1239 .path
1240 .segments
1241 .last()
1242 .is_some_and(|segment| segment.ident == "OffsetDateTime")
1243}
1244
1245fn is_i64(ty: &syn::Type) -> bool {
1246 match ty {
1247 syn::Type::Path(path) => path.qself.is_none() && path.path.is_ident("i64"),
1248 _ => false,
1249 }
1250}
1251
1252fn is_option_i64(ty: &syn::Type) -> bool {
1253 let syn::Type::Path(path) = ty else {
1254 return false;
1255 };
1256 let Some(segment) = path.path.segments.last() else {
1257 return false;
1258 };
1259 if segment.ident != "Option" {
1260 return false;
1261 }
1262 let syn::PathArguments::AngleBracketed(arguments) = &segment.arguments else {
1263 return false;
1264 };
1265 let Some(syn::GenericArgument::Type(inner)) = arguments.args.first() else {
1266 return false;
1267 };
1268 is_i64(inner)
1269}
1270
1271fn validate_identifier(identifier: &str, span: proc_macro2::Span, kind: &str) -> syn::Result<()> {
1272 let mut chars = identifier.chars();
1273 let valid_start = chars
1274 .next()
1275 .is_some_and(|ch| ch == '_' || ch.is_ascii_alphabetic());
1276 if valid_start && chars.all(|ch| ch == '_' || ch.is_ascii_alphanumeric()) {
1277 Ok(())
1278 } else {
1279 Err(Error::new(
1280 span,
1281 format!("invalid {kind} identifier: {identifier}"),
1282 ))
1283 }
1284}
1285
1286fn validate_reference(reference: &str, span: proc_macro2::Span) -> syn::Result<()> {
1287 let Some((table, column)) = reference.split_once('(') else {
1288 return Err(Error::new(
1289 span,
1290 "references must use `table(column)` format",
1291 ));
1292 };
1293 let Some(column) = column.strip_suffix(')') else {
1294 return Err(Error::new(
1295 span,
1296 "references must use `table(column)` format",
1297 ));
1298 };
1299 validate_identifier(table, span, "referenced table")?;
1300 validate_identifier(column, span, "referenced column")
1301}
1302
1303fn validate_on_delete(action: &str, span: proc_macro2::Span) -> syn::Result<()> {
1304 if matches!(
1305 action.to_ascii_lowercase().as_str(),
1306 "cascade" | "restrict" | "no action" | "set null" | "set default"
1307 ) {
1308 Ok(())
1309 } else {
1310 Err(Error::new(
1311 span,
1312 format!("unsupported on_delete action: {action}"),
1313 ))
1314 }
1315}