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