1use proc_macro::TokenStream;
2use proc_macro_crate::{FoundCrate, crate_name};
3use quote::quote;
4use std::collections::{HashMap, HashSet};
5use syn::{
6 Data, DeriveInput, Error, Fields, Ident, LitStr, Path, Token, ext::IdentExt, 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!(::che_orm)),
15 Ok(FoundCrate::Name(name)) => {
16 let ident = Ident::new(&name, proc_macro2::Span::call_site());
17 Ok(quote!(::#ident))
18 }
19 Err(error) => Err(Error::new(
20 proc_macro2::Span::call_site(),
21 format!("could not resolve che-orm dependency: {error}"),
22 )),
23 }
24}
25
26#[proc_macro_derive(Model, attributes(orm))]
27pub fn derive_model(input: TokenStream) -> TokenStream {
28 match derive_model_impl(parse_macro_input!(input as DeriveInput)) {
29 Ok(tokens) => tokens.into(),
30 Err(error) => error.into_compile_error().into(),
31 }
32}
33
34#[proc_macro_derive(DbEnum, attributes(db_enum))]
35pub fn derive_db_enum(input: TokenStream) -> TokenStream {
36 match derive_db_enum_impl(parse_macro_input!(input as DeriveInput)) {
37 Ok(tokens) => tokens.into(),
38 Err(error) => error.into_compile_error().into(),
39 }
40}
41
42fn derive_db_enum_impl(input: DeriveInput) -> syn::Result<proc_macro2::TokenStream> {
43 let orm = orm_path()?;
44 if !input.generics.params.is_empty() {
45 return Err(Error::new_spanned(
46 &input.generics,
47 "DbEnum does not support generic enums",
48 ));
49 }
50 let name = input.ident;
51 let variants = match input.data {
52 Data::Enum(data) => data.variants,
53 _ => {
54 return Err(Error::new_spanned(
55 name,
56 "DbEnum can only be derived for enums",
57 ));
58 }
59 };
60 let mut as_str_arms = Vec::new();
61 let mut from_str_arms = Vec::new();
62 let mut values = Vec::new();
63 for variant in variants {
64 if !variant.fields.is_empty() {
65 return Err(Error::new_spanned(
66 variant,
67 "DbEnum variants must be unit variants",
68 ));
69 }
70 let ident = variant.ident;
71 let mut value = None;
72 for attribute in &variant.attrs {
73 if !attribute.path().is_ident("db_enum") {
74 continue;
75 }
76 attribute.parse_nested_meta(|meta| {
77 if meta.path.is_ident("rename") {
78 if value.is_some() {
79 return Err(meta.error("db_enum rename is declared more than once"));
80 }
81 value = Some(meta.value()?.parse::<LitStr>()?);
82 Ok(())
83 } else {
84 Err(meta.error("expected `rename = \"value\"`"))
85 }
86 })?;
87 }
88 let value =
89 value.unwrap_or_else(|| LitStr::new(&snake_case(&ident.to_string()), ident.span()));
90 if values
91 .iter()
92 .any(|existing: &LitStr| existing.value() == value.value())
93 {
94 return Err(Error::new_spanned(
95 &ident,
96 format!("duplicate DbEnum value `{}`", value.value()),
97 ));
98 }
99 values.push(value.clone());
100 as_str_arms.push(quote! { Self::#ident => #value });
101 from_str_arms.push(quote! { #value => Some(Self::#ident) });
102 }
103 if values.is_empty() {
104 return Err(Error::new_spanned(
105 name,
106 "DbEnum requires at least one variant",
107 ));
108 }
109 Ok(quote! {
110 impl #orm::DbEnum for #name {
111 const VALUES: &'static [&'static str] = &[#(#values),*];
112 fn as_str(&self) -> &'static str {
113 match self { #(#as_str_arms),* }
114 }
115 fn from_str(value: &str) -> Option<Self> {
116 match value { #(#from_str_arms,)* _ => None }
117 }
118 }
119
120 impl #orm::serde::Serialize for #name {
121 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
122 where S: #orm::serde::Serializer {
123 serializer.serialize_str(<Self as #orm::DbEnum>::as_str(self))
124 }
125 }
126
127 impl<'de> #orm::serde::Deserialize<'de> for #name {
128 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
129 where D: #orm::serde::Deserializer<'de> {
130 let value = <String as #orm::serde::Deserialize>::deserialize(deserializer)?;
131 <Self as #orm::DbEnum>::from_str(&value).ok_or_else(|| #orm::serde::de::Error::custom(
132 format!("invalid {} value: {}", stringify!(#name), value)
133 ))
134 }
135 }
136
137 #orm::__sqlite_db_enum_adapter!(#name);
138 })
139}
140
141fn snake_case(value: &str) -> String {
142 value
143 .chars()
144 .enumerate()
145 .fold(String::new(), |mut output, (index, ch)| {
146 if ch.is_uppercase() && index != 0 {
147 output.push('_');
148 }
149 output.extend(ch.to_lowercase());
150 output
151 })
152}
153
154#[proc_macro_derive(ModelSerializer, attributes(serializer))]
155pub fn derive_model_serializer(input: TokenStream) -> TokenStream {
156 match derive_model_serializer_impl(parse_macro_input!(input as DeriveInput)) {
157 Ok(tokens) => tokens.into(),
158 Err(error) => error.into_compile_error().into(),
159 }
160}
161
162fn derive_model_serializer_impl(input: DeriveInput) -> syn::Result<proc_macro2::TokenStream> {
163 let orm = orm_path()?;
164 let model = parse_serializer_model(&input.attrs)?;
165 let validator = parse_serializer_validator(&input.attrs)?;
166 let validator_call = validator.map_or_else(
167 proc_macro2::TokenStream::new,
168 |path| quote! { #path(&data, mode)?; },
169 );
170 let serializer = input.ident.clone();
171 let fields = match input.data {
172 Data::Struct(data) => match data.fields {
173 Fields::Named(fields) => fields.named,
174 _ => {
175 return Err(Error::new_spanned(
176 serializer,
177 "ModelSerializer can only be derived for structs with named fields",
178 ));
179 }
180 },
181 _ => {
182 return Err(Error::new_spanned(
183 serializer,
184 "ModelSerializer can only be derived for structs",
185 ));
186 }
187 };
188 let mut assignments = Vec::new();
189 let mut nested = Vec::new();
190 let mut serialize_fields = Vec::new();
191 let mut input_fields = Vec::new();
192 let mut serializer_fields = Vec::new();
193 for field in fields {
194 let name = field.ident.expect("named fields always have identifiers");
195 let field_type = field.ty.clone();
196 let json_name = name.to_string();
197 let mut read_only = is_image_field_type(&field_type);
200 let mut write_only = false;
201 let mut use_default_on_create = false;
202 let serialize_value = if is_offset_date_time(&field_type) {
203 quote! { &#orm::Rfc3339Timestamp(&self.#name) }
204 } else if is_option_offset_date_time(&field_type) {
205 quote! { &#orm::OptionalRfc3339Timestamp(&self.#name) }
206 } else {
207 quote! { &self.#name }
208 };
209 serialize_fields.push(quote! {
210 #orm::serde::ser::SerializeStruct::serialize_field(
211 &mut state,
212 #json_name,
213 #serialize_value,
214 )?;
215 });
216 let mut nested_relation = None;
217 let mut relation_path = None;
218 let mut scalar_relation = None;
219 for attribute in &field.attrs {
220 if !attribute.path().is_ident("serializer") {
221 continue;
222 }
223 attribute.parse_nested_meta(|meta| {
224 if meta.path.is_ident("read_only") {
225 read_only = true;
226 Ok(())
227 } else if meta.path.is_ident("write_only") {
228 write_only = true;
229 Ok(())
230 } else if meta.path.is_ident("default") {
231 use_default_on_create = true;
232 Ok(())
233 } else if meta.path.is_ident("many") || meta.path.is_ident("one") {
234 let many = meta.path.is_ident("many");
235 let model: Path = meta.value()?.parse()?;
236 if nested_relation.is_some() {
237 return Err(meta.error("a serializer field can have only one relation"));
238 }
239 nested_relation = Some((many, model));
240 Ok(())
241 } else if meta.path.is_ident("relation") {
242 relation_path = Some(meta.value()?.parse::<Path>()?);
243 Ok(())
244 } else if meta.path.is_ident("foreign_key") {
245 scalar_relation = Some(meta.value()?.parse::<Path>()?);
246 Ok(())
247 } else {
248 Err(meta.error(
249 "unsupported serializer field attribute; expected read_only, write_only, default, foreign_key = Model, many = Model, one = Model or relation = Model::RELATION",
250 ))
251 }
252 })?;
253 }
254 if write_only {
255 serialize_fields.pop();
256 }
257 if nested_relation.is_some() && scalar_relation.is_some() {
258 return Err(Error::new_spanned(
259 &name,
260 "a serializer field cannot use both nested and scalar relation metadata",
261 ));
262 }
263 if let Some((many, related_model)) = nested_relation {
264 let relation_path = relation_path.ok_or_else(|| {
265 Error::new_spanned(
266 &name,
267 "nested serializer fields require `relation = RelationMarker`",
268 )
269 })?;
270 let marker = relation_marker(&relation_path)?;
271 let optional = !many && is_option_type(&field.ty);
272 let serializer_type = nested_serializer_type(&field.ty, many, optional)?;
273 nested.push((
274 name,
275 many,
276 related_model.clone(),
277 marker.clone(),
278 optional,
279 serializer_type,
280 ));
281 serializer_fields.push(quote! {
282 #orm::SerializerField {
283 name: #json_name,
284 source: <#marker as #orm::RelationSource>::SOURCE,
285 read_only: #read_only,
286 write_only: #write_only,
287 rust_type: ::core::stringify!(#field_type),
288 related_model: Some(::core::stringify!(#related_model)),
289 many: #many,
290 }
291 });
292 } else {
293 let related_model = scalar_relation
294 .as_ref()
295 .map(|model| quote! { Some(::core::stringify!(#model)) })
296 .unwrap_or_else(|| quote! { None });
297 let relation_source = if scalar_relation.is_some() {
298 let relation_path = relation_path.as_ref().ok_or_else(|| {
299 Error::new_spanned(
300 &name,
301 "scalar relation fields require `relation = RelationMarker`",
302 )
303 })?;
304 let marker = relation_marker(relation_path)?;
305 quote! { <#marker as #orm::RelationSource>::SOURCE }
306 } else {
307 quote! { #json_name }
308 };
309 serializer_fields.push(quote! {
310 #orm::SerializerField {
311 name: #json_name,
312 source: #relation_source,
313 read_only: #read_only,
314 write_only: #write_only,
315 rust_type: ::core::stringify!(#field_type),
316 related_model: #related_model,
317 many: false,
318 }
319 });
320 if !read_only {
321 let constant = Ident::new(&name.to_string().to_uppercase(), name.span());
322 input_fields.push((
323 name.clone(),
324 field.ty.clone(),
325 constant,
326 use_default_on_create,
327 ));
328 }
329 assignments.push(quote! { #name: model.#name });
330 }
331 }
332 let serializer_fields = quote! { &[#(#serializer_fields),*] };
333 let has_nested = !nested.is_empty();
334 let field_count = serialize_fields.len();
335 let conversion = if nested.len() == 1 {
336 let (name, many, related_model, marker, optional, serializer_type) =
337 nested.into_iter().next().unwrap();
338 let child_input = quote! { <#serializer_type as #orm::ModelSerializer>::Input };
339 let wrapper = if many {
340 quote! { #orm::WithMany<#model, #child_input, #marker, <#model as #orm::Model>::PrimaryKey> }
341 } else if optional {
342 quote! { #orm::WithOptionalOne<#model, #child_input, #marker> }
343 } else {
344 quote! { #orm::WithOne<#model, #child_input, #marker, <#related_model as #orm::Model>::PrimaryKey> }
345 };
346 let loaded_wrapper = quote! {
347 #orm::Loaded<#model, (#orm::LoadedMany<#child_input, #marker>,)>
348 };
349 let many_input = if many {
350 loaded_wrapper.clone()
351 } else {
352 wrapper.clone()
353 };
354 let nested_assignment = if many {
355 quote! { #name: value.related.into_iter().map(::core::convert::Into::into).collect() }
356 } else if optional {
357 quote! { #name: value.related.map(::core::convert::Into::into) }
358 } else {
359 quote! { #name: ::core::convert::Into::into(value.related) }
360 };
361 let loaded_conversion = if many {
362 quote! {
363 impl ::core::convert::From<#loaded_wrapper> for #serializer {
364 fn from(value: #loaded_wrapper) -> Self {
365 let model = value.model;
366 let (relation,) = value.relations;
367 Self {
368 #(#assignments,)*
369 #name: relation.related
370 .into_iter()
371 .map(::core::convert::Into::into)
372 .collect()
373 }
374 }
375 }
376
377 impl #orm::ModelSerializer for #serializer {
378 type Model = #model;
379 type Input = #loaded_wrapper;
380
381 fn from_input(value: Self::Input) -> Self {
382 <Self as ::core::convert::From<#loaded_wrapper>>::from(value)
383 }
384
385 fn fields() -> &'static [#orm::SerializerField] {
386 #serializer_fields
387 }
388 }
389 }
390 } else {
391 quote! {
392 impl #orm::ModelSerializer for #serializer {
393 type Model = #model;
394 type Input = #wrapper;
395
396 fn from_input(value: Self::Input) -> Self {
397 <Self as ::core::convert::From<#wrapper>>::from(value)
398 }
399
400 fn fields() -> &'static [#orm::SerializerField] {
401 #serializer_fields
402 }
403 }
404 }
405 };
406 quote! {
407 impl ::core::convert::From<#wrapper> for #serializer {
408 fn from(value: #wrapper) -> Self {
409 let model = value.model;
410 Self { #(#assignments,)* #nested_assignment }
411 }
412 }
413
414 #loaded_conversion
415
416 impl #serializer {
417 pub fn many<I>(values: I) -> ::std::vec::Vec<Self>
418 where
419 I: ::core::iter::IntoIterator<Item = #many_input>,
420 {
421 values.into_iter().map(::core::convert::Into::into).collect()
422 }
423 }
424 }
425 } else if nested.len() > 1 {
426 let mut wrappers = Vec::new();
427 let mut relation_vars = Vec::new();
428 let mut nested_assignments = Vec::new();
429 for (index, (name, many, _related_model, marker, optional, serializer_type)) in
430 nested.into_iter().enumerate()
431 {
432 if !many || optional {
433 return Err(Error::new_spanned(
434 name,
435 "multiple nested fields currently support only `many` relations",
436 ));
437 }
438 let relation_var = Ident::new(
439 &format!("__relation{index}"),
440 proc_macro2::Span::call_site(),
441 );
442 relation_vars.push(relation_var.clone());
443 let child_input = quote! { <#serializer_type as #orm::ModelSerializer>::Input };
444 wrappers.push(quote! { #orm::LoadedMany<#child_input, #marker> });
445 nested_assignments.push(quote! {
446 #name: #relation_var.related
447 .into_iter()
448 .map(::core::convert::Into::into)
449 .collect()
450 });
451 }
452 let loaded_type = quote! {
453 #orm::Loaded<#model, (#(#wrappers),*,)>
454 };
455 let destructure = quote! { let (#(#relation_vars),*,) = value.relations; };
456 quote! {
457 impl ::core::convert::From<#loaded_type> for #serializer {
458 fn from(value: #loaded_type) -> Self {
459 let model = value.model;
460 #destructure
461 Self { #(#assignments,)* #(#nested_assignments),* }
462 }
463 }
464
465 impl #orm::ModelSerializer for #serializer {
466 type Model = #model;
467 type Input = #loaded_type;
468
469 fn from_input(value: Self::Input) -> Self {
470 <Self as ::core::convert::From<#loaded_type>>::from(value)
471 }
472
473 fn fields() -> &'static [#orm::SerializerField] {
474 #serializer_fields
475 }
476 }
477
478 impl #serializer {
479 pub fn many<I>(values: I) -> ::std::vec::Vec<Self>
480 where
481 I: ::core::iter::IntoIterator<Item = #loaded_type>,
482 {
483 values.into_iter().map(::core::convert::Into::into).collect()
484 }
485 }
486 }
487 } else {
488 quote! {
489 impl ::core::convert::From<#model> for #serializer {
490 fn from(model: #model) -> Self {
491 <Self as #orm::ModelSerializer>::from_input(model)
492 }
493 }
494
495 impl #serializer {
496 pub fn from_model(model: #model) -> Self {
497 <Self as #orm::ModelSerializer>::from_input(model)
498 }
499
500 pub fn many<I>(values: I) -> ::std::vec::Vec<Self>
501 where
502 I: ::core::iter::IntoIterator<Item = #model>,
503 {
504 values.into_iter().map(::core::convert::Into::into).collect()
505 }
506 }
507 }
508 };
509
510 let trait_impl = if has_nested {
511 quote! {}
512 } else {
513 quote! {
514 impl #orm::ModelSerializer for #serializer {
515 type Model = #model;
516 type Input = #model;
517
518 fn from_input(model: Self::Input) -> Self {
519 Self { #(#assignments),* }
520 }
521
522 fn fields() -> &'static [#orm::SerializerField] {
523 #serializer_fields
524 }
525 }
526 }
527 };
528
529 let create_name = Ident::new(&format!("{}CreateInput", serializer), serializer.span());
530 let update_name = Ident::new(&format!("{}UpdateInput", serializer), serializer.span());
531 let patch_name = Ident::new(&format!("{}PatchInput", serializer), serializer.span());
532 let create_fields = input_fields
533 .iter()
534 .map(|(name, ty, _, use_default_on_create)| {
535 let deserialize = datetime_deserialize_attribute(ty, &orm, false);
536 if *use_default_on_create {
537 quote! { #[serde(default)] #deserialize pub #name: ::core::option::Option<#ty>, }
538 } else {
539 quote! { #deserialize pub #name: #ty, }
540 }
541 });
542 let update_fields = input_fields.iter().map(|(name, ty, _, _)| {
543 let deserialize = datetime_deserialize_attribute(ty, &orm, false);
544 quote! { #deserialize pub #name: #ty, }
545 });
546 let patch_fields = input_fields.iter().map(|(name, ty, _, _)| {
547 let deserialize = datetime_deserialize_attribute(ty, &orm, true);
548 quote! { #[serde(default)] #deserialize pub #name: #orm::PatchField<#ty>, }
549 });
550 let create_sets = input_fields.iter().map(|(name, _, constant, use_default_on_create)| {
551 if *use_default_on_create {
552 quote! {
553 let builder = match input.#name {
554 ::core::option::Option::Some(value) => builder.set(<#model>::#constant, value),
555 ::core::option::Option::None => builder,
556 };
557 }
558 } else {
559 quote! {
560 let builder = builder.set(<#model>::#constant, input.#name);
561 }
562 }
563 });
564 let update_sets = input_fields.iter().map(|(name, _, constant, _)| {
565 quote! {
566 let builder = builder.set(<#model>::#constant, input.#name);
567 }
568 });
569 let patch_sets = input_fields.iter().map(|(name, _, constant, _)| {
570 quote! {
571 let builder = match input.#name {
572 #orm::PatchField::Missing => builder,
573 #orm::PatchField::Value(value) => builder.set(<#model>::#constant, value),
574 };
575 }
576 });
577 let patch_missing_checks = input_fields
578 .iter()
579 .map(|(name, _, _, _)| quote! { input.#name.is_missing() })
580 .collect::<Vec<_>>();
581 let patch_empty = if patch_missing_checks.is_empty() {
582 quote! { true }
583 } else {
584 quote! { #(#patch_missing_checks)&&* }
585 };
586
587 Ok(quote! {
588 #[derive(Debug, #orm::serde::Deserialize)]
589 #[serde(deny_unknown_fields)]
590 pub struct #create_name {
591 #(#create_fields)*
592 }
593
594 #[derive(Debug, #orm::serde::Deserialize)]
595 #[serde(deny_unknown_fields)]
596 pub struct #update_name {
597 #(#update_fields)*
598 }
599
600 #[derive(Debug, #orm::serde::Deserialize)]
601 #[serde(deny_unknown_fields)]
602 pub struct #patch_name {
603 #(#patch_fields)*
604 }
605
606 impl #orm::ModelWriteSerializer for #serializer {
607 type Model = #model;
608
609 fn is_valid(
610 data: #orm::serde_json::Value,
611 mode: #orm::WriteMode<<#model as #orm::Model>::PrimaryKey>,
612 ) -> ::core::result::Result<#orm::ValidatedWrite<#model>, #orm::ValidationErrors> {
613 #validator_call
614 match mode {
615 #orm::WriteMode::Create => {
616 let input: #create_name = #orm::serde_json::from_value(data)?;
617 let builder = <#model as #orm::Model>::insert();
618 #(#create_sets)*
619 Ok(#orm::ValidatedWrite::Create(builder))
620 }
621 #orm::WriteMode::Update { id } => {
622 let input: #update_name = #orm::serde_json::from_value(data)?;
623 let builder = <#model as #orm::Model>::update()
624 .filter(<#model as #orm::Model>::primary_key().eq(id));
625 #(#update_sets)*
626 Ok(#orm::ValidatedWrite::Update(builder))
627 }
628 #orm::WriteMode::Patch { id } => {
629 let input: #patch_name = #orm::serde_json::from_value(data)?;
630 if #patch_empty {
631 return Err(#orm::ValidationErrors {
632 detail: "patch must contain at least one field".into(),
633 });
634 }
635 let builder = <#model as #orm::Model>::update()
636 .filter(<#model as #orm::Model>::primary_key().eq(id));
637 #(#patch_sets)*
638 Ok(#orm::ValidatedWrite::Update(builder))
639 }
640 }
641 }
642 }
643
644 impl #orm::serde::Serialize for #serializer {
645 fn serialize<__Serializer>(
646 &self,
647 serializer: __Serializer,
648 ) -> ::core::result::Result<__Serializer::Ok, __Serializer::Error>
649 where
650 __Serializer: #orm::serde::Serializer,
651 {
652 let mut state = #orm::serde::Serializer::serialize_struct(
653 serializer,
654 stringify!(#serializer),
655 #field_count,
656 )?;
657 #(#serialize_fields)*
658 #orm::serde::ser::SerializeStruct::end(state)
659 }
660 }
661
662 #trait_impl
663 #conversion
664 })
665}
666
667fn parse_serializer_model(attributes: &[syn::Attribute]) -> syn::Result<Path> {
668 let mut model = None;
669 for attribute in attributes {
670 if !attribute.path().is_ident("serializer") {
671 continue;
672 }
673 attribute.parse_nested_meta(|meta| {
674 if meta.path.is_ident("model") {
675 if model.is_some() {
676 return Err(meta.error("serializer model is declared more than once"));
677 }
678 model = Some(meta.value()?.parse()?);
679 Ok(())
680 } else if meta.path.is_ident("validate") {
681 let _: Path = meta.value()?.parse()?;
682 Ok(())
683 } else {
684 Err(meta.error("expected `model = Model`"))
685 }
686 })?;
687 }
688 model.ok_or_else(|| {
689 Error::new(
690 proc_macro2::Span::call_site(),
691 "serializer requires `#[serializer(model = Model)]`",
692 )
693 })
694}
695
696fn parse_serializer_validator(attributes: &[syn::Attribute]) -> syn::Result<Option<Path>> {
697 let mut validator = None;
698 for attribute in attributes {
699 if !attribute.path().is_ident("serializer") {
700 continue;
701 }
702 attribute.parse_nested_meta(|meta| {
703 if meta.path.is_ident("validate") {
704 if validator.is_some() {
705 return Err(meta.error("serializer validator is declared more than once"));
706 }
707 validator = Some(meta.value()?.parse()?);
708 Ok(())
709 } else if meta.path.is_ident("model") {
710 let _: Path = meta.value()?.parse()?;
711 Ok(())
712 } else {
713 Err(meta.error("expected `model = Model` or `validate = path`"))
714 }
715 })?;
716 }
717 Ok(validator)
718}
719
720fn relation_marker(path: &Path) -> syn::Result<Ident> {
721 let mut segments = path.segments.iter();
722 let model = segments
723 .next()
724 .ok_or_else(|| Error::new_spanned(path, "relation must use `RelationMarker`"))?;
725 if segments.clone().next().is_none() {
726 return Ok(model.ident.clone());
727 }
728 let relation = segments
729 .next()
730 .ok_or_else(|| Error::new_spanned(path, "relation must use `RelationMarker`"))?;
731 if segments.next().is_some() {
732 return Err(Error::new_spanned(
733 path,
734 "relation must use `RelationMarker`",
735 ));
736 }
737 Ok(Ident::new(
738 &format!("{}{}Relation", model.ident, relation.ident),
739 path.span(),
740 ))
741}
742
743fn is_option_type(ty: &syn::Type) -> bool {
744 let syn::Type::Path(path) = ty else {
745 return false;
746 };
747 path.path
748 .segments
749 .last()
750 .is_some_and(|segment| segment.ident == "Option")
751}
752
753fn nested_serializer_type(ty: &syn::Type, many: bool, optional: bool) -> syn::Result<Path> {
754 let inner = if many {
755 let syn::Type::Path(path) = ty else {
756 return Err(Error::new_spanned(
757 ty,
758 "many serializer field must be Vec<Serializer>",
759 ));
760 };
761 let segment = path.path.segments.last().ok_or_else(|| {
762 Error::new_spanned(ty, "many serializer field must be Vec<Serializer>")
763 })?;
764 if segment.ident != "Vec" {
765 return Err(Error::new_spanned(
766 ty,
767 "many serializer field must be Vec<Serializer>",
768 ));
769 }
770 let syn::PathArguments::AngleBracketed(arguments) = &segment.arguments else {
771 return Err(Error::new_spanned(
772 ty,
773 "many serializer field must be Vec<Serializer>",
774 ));
775 };
776 arguments.args.first().cloned()
777 } else if optional {
778 let syn::Type::Path(path) = ty else {
779 return Err(Error::new_spanned(
780 ty,
781 "optional relation must be Option<Serializer>",
782 ));
783 };
784 let segment = path.path.segments.last().ok_or_else(|| {
785 Error::new_spanned(ty, "optional relation must be Option<Serializer>")
786 })?;
787 let syn::PathArguments::AngleBracketed(arguments) = &segment.arguments else {
788 return Err(Error::new_spanned(
789 ty,
790 "optional relation must be Option<Serializer>",
791 ));
792 };
793 arguments.args.first().cloned()
794 } else {
795 match ty {
796 syn::Type::Path(_) => Some(syn::GenericArgument::Type(ty.clone())),
797 _ => None,
798 }
799 };
800 match inner {
801 Some(syn::GenericArgument::Type(syn::Type::Path(path))) => Ok(path.path),
802 _ => Err(Error::new_spanned(
803 ty,
804 "nested serializer field must contain a serializer type",
805 )),
806 }
807}
808
809fn pascal_case(value: &str) -> String {
810 let mut chars = value.chars();
811 let Some(first) = chars.next() else {
812 return String::new();
813 };
814 first.to_ascii_uppercase().to_string() + chars.as_str()
815}
816
817fn derive_model_impl(input: DeriveInput) -> syn::Result<proc_macro2::TokenStream> {
818 let orm = orm_path()?;
819 let model_attributes = parse_model_attributes(&input)?;
820 let table_value = model_attributes.table;
821 let table = quote!(__CHE_ORM_MODEL_TABLE_NAME);
822 let fields = match input.data {
823 Data::Struct(data) => match data.fields {
824 Fields::Named(fields) => fields.named,
825 _ => {
826 return Err(Error::new_spanned(
827 input.ident,
828 "Model can only be derived for structs with named fields",
829 ));
830 }
831 },
832 _ => {
833 return Err(Error::new_spanned(
834 input.ident,
835 "Model can only be derived for structs",
836 ));
837 }
838 };
839
840 let model = input.ident;
841 let mut columns = Vec::with_capacity(fields.len());
842 let mut constants = Vec::with_capacity(fields.len());
843 let mut schema_columns = Vec::with_capacity(fields.len());
844 let mut row_fields = Vec::with_capacity(fields.len());
845 let mut insert_values = Vec::with_capacity(fields.len());
846 let mut field_values = Vec::with_capacity(fields.len());
847 let mut write_protected_columns = Vec::new();
848 let mut json_columns = Vec::new();
849 let mut managed_update_values = Vec::with_capacity(fields.len());
850 let mut relation_constants = Vec::new();
851 let mut relation_markers = Vec::new();
852 let mut primary_key_seen = false;
853 let mut primary_key_constant = None;
854 let mut primary_key_field = None;
855 let mut primary_key_type = None;
856 let mut generated_constants = HashSet::new();
857 let mut field_columns = HashMap::new();
858 let mut sync_fields = Vec::new();
859
860 for (index, field) in fields.into_iter().enumerate() {
861 let field_name = field.ident.expect("named fields always have identifiers");
862 let field_column = field_name.to_string();
863 let field_type = field.ty;
864 let field_attributes = parse_field_attributes(&field.attrs)?;
865 let column = field_attributes
866 .db_column
867 .as_ref()
868 .map(LitStr::value)
869 .unwrap_or_else(|| field_column.clone());
870 let constant = Ident::new(&field_column.to_uppercase(), field_name.span());
871 if model_attributes.sync {
872 if ["revision", "updated_at", "deleted_at", "sync_scope"].contains(&column.as_str())
873 || ["revision", "updated_at", "deleted_at", "sync_scope"]
874 .contains(&field_column.as_str())
875 {
876 return Err(Error::new_spanned(
877 &field_name,
878 "sync service columns are infrastructure-owned",
879 ));
880 }
881 if field_attributes.primary_key && !is_uuid(&field_type) {
882 return Err(Error::new_spanned(
883 &field_type,
884 "sync models require a UUID primary key",
885 ));
886 }
887 let wire = field_attributes
888 .sync_name
889 .as_ref()
890 .map(LitStr::value)
891 .unwrap_or_else(|| field_column.clone());
892 let constructor = if field_attributes.primary_key
893 || field_attributes.server_owned
894 || field_attributes.auto_now
895 || field_attributes.auto_now_add
896 || is_image_field_type(&field_type)
897 {
898 quote!(server_owned)
899 } else {
900 quote!(writable)
901 };
902 sync_fields.push(quote!(#orm::SyncField::#constructor(#wire, #column)));
903 } else if field_attributes.sync_name.is_some() || field_attributes.server_owned {
904 return Err(Error::new_spanned(
905 &field_name,
906 "sync field attributes require #[orm(sync)]",
907 ));
908 }
909 if is_image_field_type(&field_type) {
910 write_protected_columns.push(column.clone());
911 }
912 if is_named_field_type(&field_type, "JsonField") {
913 json_columns.push(column.clone());
914 }
915 field_columns.insert(field_column.clone(), column.clone());
916
917 if !generated_constants.insert(constant.to_string()) {
918 return Err(Error::new_spanned(
919 &field_name,
920 format!("generated constant {constant} conflicts with another model field"),
921 ));
922 }
923
924 if field_attributes.foreign_key.is_some()
925 && !is_i64(&field_type)
926 && !is_option_i64(&field_type)
927 && !is_uuid(&field_type)
928 && !is_option_uuid(&field_type)
929 {
930 return Err(Error::new_spanned(
931 &field_type,
932 "foreign_key requires i64, Uuid, Option<i64> or Option<Uuid>",
933 ));
934 }
935
936 if field_attributes.foreign_key.is_some()
937 && field_attributes
938 .on_delete
939 .as_ref()
940 .is_some_and(|action| action.value().eq_ignore_ascii_case("set null"))
941 && !is_option_i64(&field_type)
942 && !is_option_uuid(&field_type)
943 {
944 return Err(Error::new_spanned(
945 &field_type,
946 "on_delete = \"set null\" requires an Option<i64> or Option<Uuid> foreign_key field",
947 ));
948 }
949
950 if field_attributes.primary_key {
951 if primary_key_seen {
952 return Err(Error::new_spanned(
953 &field_name,
954 "a model can have only one primary_key field",
955 ));
956 }
957 if !is_i64(&field_type) && !is_uuid(&field_type) {
958 return Err(Error::new_spanned(
959 &field_type,
960 "primary_key requires an i64 or Uuid field",
961 ));
962 }
963 primary_key_seen = true;
964 primary_key_constant = Some(constant.clone());
965 primary_key_field = Some(field_name.clone());
966 primary_key_type = Some(field_type.clone());
967 }
968
969 if (field_attributes.auto_now_add || field_attributes.auto_now)
970 && !is_offset_date_time(&field_type)
971 {
972 return Err(Error::new_spanned(
973 field_type,
974 "auto_now_add and auto_now require time::OffsetDateTime",
975 ));
976 }
977
978 columns.push(LitStr::new(&column, field_name.span()));
979 let field_constructor =
980 if is_offset_date_time(&field_type) || is_option_offset_date_time(&field_type) {
981 quote!(datetime)
982 } else {
983 quote!(new)
984 };
985 constants.push(quote! {
986 pub const #constant: #orm::ModelField<Self, #field_type> =
987 #orm::ModelField::#field_constructor(#table, #column);
988 });
989
990 let primary_key = field_attributes.primary_key;
991 let unique = field_attributes.unique;
992 let auto_now_add = field_attributes.auto_now_add;
993 let auto_now = field_attributes.auto_now;
994 let default = field_attributes
995 .default
996 .map(|value| quote! { column.default = Some(#value); });
997 let check = field_attributes
998 .check
999 .map(|value| quote! { column.check = Some(#value); });
1000 let references = field_attributes.references.map(|target| {
1001 let on_delete = field_attributes
1002 .on_delete
1003 .clone()
1004 .map(|value| quote! { Some(#value) })
1005 .unwrap_or_else(|| quote! { None });
1006 quote! {
1007 column.references = Some(#orm::ForeignKey::new(
1008 #target,
1009 #on_delete,
1010 ));
1011 }
1012 });
1013 let foreign_key = field_attributes.foreign_key.as_ref().map(|target| {
1014 let on_delete = field_attributes
1015 .on_delete
1016 .clone()
1017 .map(|value| quote! { Some(#value) })
1018 .unwrap_or_else(|| quote! { None });
1019 quote! {
1020 column.references = Some(#orm::ForeignKey::new(
1021 format!(
1022 "{}({})",
1023 <#target as #orm::Model>::table_name(),
1024 <#target as #orm::Model>::primary_key().column().name,
1025 ),
1026 #on_delete,
1027 ));
1028 }
1029 });
1030 if let Some(target) = &field_attributes.foreign_key {
1031 let key_type = if is_option_i64(&field_type) {
1032 quote! { i64 }
1033 } else if is_option_uuid(&field_type) {
1034 quote! { #orm::Uuid }
1035 } else {
1036 quote! { #field_type }
1037 };
1038 let relation_name = field_column
1039 .strip_suffix("_id")
1040 .unwrap_or(&field_column)
1041 .to_uppercase();
1042 let alias = field_column
1043 .strip_suffix("_id")
1044 .unwrap_or(&field_column)
1045 .to_ascii_lowercase();
1046 let relation_constant = Ident::new(&relation_name, field_name.span());
1047 let marker_name = Ident::new(
1048 &format!(
1049 "{}{}Relation",
1050 model,
1051 pascal_case(field_column.strip_suffix("_id").unwrap_or(&field_column))
1052 ),
1053 field_name.span(),
1054 );
1055 if !generated_constants.insert(relation_name.clone()) {
1056 return Err(Error::new_spanned(
1057 &field_name,
1058 format!(
1059 "generated relation constant {relation_name} conflicts with a model field"
1060 ),
1061 ));
1062 }
1063 let reverse_name = format!("{}_set", model.to_string().to_lowercase());
1064 relation_constants.push(quote! {
1065 pub const #relation_constant:
1066 #orm::BelongsTo<Self, #target, #marker_name, #field_type> =
1067 #orm::BelongsTo::new(
1068 #table,
1069 #column,
1070 |model: &Self| model.#field_name,
1071 #alias,
1072 #reverse_name,
1073 );
1074 });
1075 relation_markers.push(quote! {
1076 #[allow(non_camel_case_types)]
1077 pub struct #marker_name;
1078 impl #orm::RelationSource for #marker_name {
1079 const SOURCE: &'static str = #column;
1080 }
1081 const _: () = {
1082 fn check_target_key<T: #orm::Model<PrimaryKey = #key_type>>() {}
1083 let _ = check_target_key::<#target>;
1084 };
1085 });
1086 }
1087
1088 schema_columns.push(quote! {
1089 let mut column = #orm::ColumnSchema::new(
1090 #column,
1091 <#field_type as #orm::ColumnTypeOf>::column_type(),
1092 <#field_type as #orm::ColumnTypeOf>::nullable(),
1093 ).with_field_name(stringify!(#field_name));
1094 column.primary_key = #primary_key;
1095 column.unique = #unique;
1096 column.auto_now_add = #auto_now_add;
1097 column.auto_now = #auto_now;
1098 column.choices = <#field_type as #orm::ColumnTypeOf>::choices();
1099 #default
1100 #check
1101 #references
1102 #foreign_key
1103 columns.push(column);
1104 });
1105
1106 row_fields.push(quote! {
1107 #field_name: row.get(#index + offset)?,
1108 });
1109
1110 let field_value = quote! {
1111 #orm::InsertValue {
1112 column: #orm::ColumnRef::new(#table, #column),
1113 value: #orm::QueryValue::<#field_type>::into_query_value(
1114 self.#field_name.clone(),
1115 ),
1116 }
1117 };
1118 field_values.push(field_value.clone());
1119 if (!field_attributes.primary_key || is_uuid(&field_type)) && !auto_now_add && !auto_now {
1120 insert_values.push(field_value);
1121 }
1122
1123 if auto_now {
1124 managed_update_values.push(quote! {
1125 #orm::Assignment {
1126 column: #orm::ColumnRef::new(#table, #column),
1127 value: #orm::QueryValue::<#field_type>::into_query_value(
1128 #orm::time::OffsetDateTime::now_utc(),
1129 ),
1130 }
1131 });
1132 }
1133 }
1134
1135 let primary_key_constant = primary_key_constant.ok_or_else(|| {
1136 Error::new_spanned(
1137 &model,
1138 "Model requires exactly one #[orm(primary_key)] field",
1139 )
1140 })?;
1141 let primary_key_field = primary_key_field.expect("primary key constant has a field");
1142 let primary_key_type = primary_key_type.expect("primary key has a type");
1143
1144 let unique_constraints = model_attributes.unique_constraints.iter().map(|columns| {
1145 let columns = columns.iter().map(|column| {
1146 let name = field_columns
1147 .get(&column.value())
1148 .cloned()
1149 .unwrap_or_else(|| column.value());
1150 LitStr::new(&name, column.span())
1151 });
1152 quote! { vec![#(#columns),*] }
1153 });
1154 let indexes = model_attributes.indexes.iter().map(|columns| {
1155 let columns = columns.iter().map(|column| {
1156 let name = field_columns
1157 .get(&column.value())
1158 .cloned()
1159 .unwrap_or_else(|| column.value());
1160 LitStr::new(&name, column.span())
1161 });
1162 quote! { vec![#(#columns),*] }
1163 });
1164
1165 let sync_impl = if model_attributes.sync {
1166 let name = model_attributes
1167 .sync_name
1168 .as_ref()
1169 .map(|name| quote!(#name))
1170 .unwrap_or_else(|| table.clone());
1171 let version = model_attributes.sync_version;
1172 quote! {
1173 impl #orm::SyncModel for #model {
1174 const SYNC_NAME: &'static str = #name;
1175 const SYNC_VERSION: u32 = #version;
1176 const AUTOMATIC_METADATA: bool = true;
1177 fn sync_fields() -> Vec<#orm::SyncField> { vec![#(#sync_fields),*] }
1178 }
1179 impl #model {
1180 pub const REVISION: #orm::ModelField<Self, i64> = #orm::ModelField::new(#table, "revision");
1181 pub const UPDATED_AT: #orm::ModelField<Self, #orm::time::OffsetDateTime> = #orm::ModelField::datetime(#table, "updated_at");
1182 pub const DELETED_AT: #orm::ModelField<Self, Option<#orm::time::OffsetDateTime>> = #orm::ModelField::datetime(#table, "deleted_at");
1183 pub const SYNC_SCOPE: #orm::ModelField<Self, String> = #orm::ModelField::new(#table, "sync_scope");
1184 }
1185 }
1186 } else {
1187 quote!()
1188 };
1189 let implementations = quote! {
1190 #sync_impl
1191
1192 impl #orm::Model for #model {
1193 type PrimaryKey = #primary_key_type;
1194 fn table_name() -> &'static str {
1195 #table
1196 }
1197
1198 fn columns() -> &'static [&'static str] {
1199 &[#(#columns),*]
1200 }
1201
1202 fn primary_key() -> #orm::ModelField<Self, Self::PrimaryKey> {
1203 Self::#primary_key_constant
1204 }
1205
1206 fn primary_key_value(&self) -> Self::PrimaryKey {
1207 self.#primary_key_field
1208 }
1209
1210 fn schema() -> #orm::TableSchema {
1211 let mut columns = Vec::new();
1212 #(#schema_columns)*
1213 #orm::TableSchema {
1214 name: #table,
1215 columns,
1216 unique_constraints: vec![#(#unique_constraints),*],
1217 indexes: vec![#(#indexes),*],
1218 }
1219 }
1220
1221 fn from_row(row: &#orm::Row) -> ::core::result::Result<Self, #orm::DecodeError> {
1222 Self::from_row_at(row, 0)
1223 }
1224
1225 fn from_row_at(
1226 row: &#orm::Row,
1227 offset: usize,
1228 ) -> ::core::result::Result<Self, #orm::DecodeError> {
1229 Ok(Self {
1230 #(#row_fields)*
1231 })
1232 }
1233
1234 fn insert_values(&self) -> ::std::vec::Vec<#orm::InsertValue> {
1235 vec![#(#insert_values),*]
1236 }
1237
1238 fn field_values(&self) -> ::std::vec::Vec<#orm::InsertValue> {
1239 vec![#(#field_values),*]
1240 }
1241
1242 fn write_protected_columns() -> &'static [&'static str] {
1243 &[#(#write_protected_columns),*]
1244 }
1245 fn json_columns() -> &'static [&'static str] {
1246 &[#(#json_columns),*]
1247 }
1248
1249 fn managed_update_values() -> ::std::vec::Vec<#orm::Assignment> {
1250 vec![#(#managed_update_values),*]
1251 }
1252 }
1253
1254 impl #model {
1255 #(#constants)*
1256 #(#relation_constants)*
1257 }
1258 };
1259 Ok(quote! {
1260 #(#relation_markers)*
1261 const _: () = {
1262 const __CHE_ORM_MODEL_TABLE_NAME: &str = #table_value;
1263 #implementations
1264 };
1265 })
1266}
1267
1268struct ModelAttributes {
1269 table: proc_macro2::TokenStream,
1270 unique_constraints: Vec<Vec<LitStr>>,
1271 indexes: Vec<Vec<LitStr>>,
1272 sync: bool,
1273 sync_name: Option<LitStr>,
1274 sync_version: u32,
1275}
1276
1277fn parse_model_attributes(input: &DeriveInput) -> syn::Result<ModelAttributes> {
1278 let mut table: Option<LitStr> = None;
1279 let mut app: Option<syn::Expr> = None;
1280 let mut unique_constraints = Vec::new();
1281 let mut indexes = Vec::new();
1282 let mut sync = false;
1283 let mut sync_name = None;
1284 let mut sync_version = 1;
1285
1286 for attribute in &input.attrs {
1287 if !attribute.path().is_ident("orm") {
1288 continue;
1289 }
1290
1291 attribute.parse_nested_meta(|meta| {
1292 if meta.path.is_ident("table") {
1293 table = Some(meta.value()?.parse()?);
1294 Ok(())
1295 } else if meta.path.is_ident("app") {
1296 let value: syn::Expr = meta.value()?.parse()?;
1297 match &value {
1298 syn::Expr::Lit(syn::ExprLit {
1299 lit: syn::Lit::Str(value),
1300 ..
1301 }) => {
1302 validate_identifier(&value.value(), value.span(), "app")?;
1303 }
1304 syn::Expr::Path(path) if path.qself.is_none() => {}
1305 _ => {
1306 return Err(Error::new_spanned(
1307 &value,
1308 "app must be a string literal or a path to a const &str",
1309 ));
1310 }
1311 }
1312 app = Some(value);
1313 Ok(())
1314 } else if meta.path.is_ident("sync") {
1315 sync = true;
1316 Ok(())
1317 } else if meta.path.is_ident("sync_name") {
1318 sync_name = Some(meta.value()?.parse()?);
1319 Ok(())
1320 } else if meta.path.is_ident("sync_version") {
1321 let version: syn::LitInt = meta.value()?.parse()?;
1322 sync_version = version.base10_parse()?;
1323 if sync_version == 0 {
1324 return Err(meta.error("sync_version must be positive"));
1325 }
1326 Ok(())
1327 } else if meta.path.is_ident("unique") || meta.path.is_ident("index") {
1328 let content;
1329 syn::parenthesized!(content in meta.input);
1330 let values =
1331 content.parse_terminated(|input| input.parse::<LitStr>(), Token![,])?;
1332 if values.is_empty() {
1333 return Err(meta.error("constraint requires at least one column"));
1334 }
1335 let values = values.into_iter().collect::<Vec<_>>();
1336 for value in &values {
1337 validate_identifier(&value.value(), value.span(), "constraint column")?;
1338 }
1339 if meta.path.is_ident("unique") {
1340 unique_constraints.push(values);
1341 } else {
1342 indexes.push(values);
1343 }
1344 Ok(())
1345 } else {
1346 Err(meta.error(
1347 "unsupported orm attribute; expected table, app, unique(...) or index(...)",
1348 ))
1349 }
1350 })?;
1351 }
1352
1353 let table = if let Some(table) = table {
1354 validate_identifier(&table.value(), table.span(), "table")?;
1355 quote!(#table)
1356 } else if let Some(app) = app {
1357 let model_name = LitStr::new(
1358 &snake_case(&input.ident.unraw().to_string()),
1359 input.ident.span(),
1360 );
1361 validate_identifier(&model_name.value(), model_name.span(), "model table suffix")?;
1362 quote!({
1365 const __CHE_ORM_APP: &str = #app;
1366 const __CHE_ORM_MODEL: &str = #model_name;
1367 const fn __che_orm_table_bytes() -> [u8; __CHE_ORM_APP.len() + 1 + __CHE_ORM_MODEL.len()] {
1368 let app = __CHE_ORM_APP.as_bytes();
1369 assert!(!app.is_empty(), "invalid app identifier: expected a nonempty SQL identifier");
1370 let mut bytes = [0; __CHE_ORM_APP.len() + 1 + __CHE_ORM_MODEL.len()];
1371 let mut i = 0;
1372 while i < app.len() {
1373 assert!(
1374 app[i] == b'_' || app[i].is_ascii_alphabetic()
1375 || (i > 0 && app[i].is_ascii_digit()),
1376 "invalid app identifier: expected ASCII letters, digits or underscores, starting with a letter or underscore",
1377 );
1378 bytes[i] = app[i];
1379 i += 1;
1380 }
1381 bytes[i] = b'_';
1382 let model = __CHE_ORM_MODEL.as_bytes();
1383 let mut j = 0;
1384 while j < model.len() {
1385 bytes[i + 1 + j] = model[j];
1386 j += 1;
1387 }
1388 bytes
1389 }
1390 const __CHE_ORM_BYTES: &[u8] = &__che_orm_table_bytes();
1391 const __CHE_ORM_TABLE: &str = match ::core::str::from_utf8(__CHE_ORM_BYTES) {
1392 Ok(table) => table,
1393 Err(_) => panic!("invalid table identifier: expected ASCII"),
1394 };
1395 __CHE_ORM_TABLE
1396 })
1397 } else {
1398 return Err(Error::new_spanned(
1399 &input.ident,
1400 "Model requires #[orm(table = \"table_name\")] or #[orm(app = \"app_name\")]",
1401 ));
1402 };
1403 if !sync && (sync_name.is_some() || sync_version != 1) {
1404 return Err(Error::new_spanned(
1405 &input.ident,
1406 "sync settings require #[orm(sync)]",
1407 ));
1408 }
1409 Ok(ModelAttributes {
1410 table,
1411 unique_constraints,
1412 indexes,
1413 sync,
1414 sync_name,
1415 sync_version,
1416 })
1417}
1418
1419struct FieldAttributes {
1420 db_column: Option<LitStr>,
1421 primary_key: bool,
1422 unique: bool,
1423 default: Option<LitStr>,
1424 check: Option<LitStr>,
1425 references: Option<LitStr>,
1426 foreign_key: Option<Path>,
1427 on_delete: Option<LitStr>,
1428 auto_now_add: bool,
1429 auto_now: bool,
1430 sync_name: Option<LitStr>,
1431 server_owned: bool,
1432}
1433
1434fn parse_field_attributes(attributes: &[syn::Attribute]) -> syn::Result<FieldAttributes> {
1435 let mut result = FieldAttributes {
1436 db_column: None,
1437 primary_key: false,
1438 unique: false,
1439 default: None,
1440 check: None,
1441 references: None,
1442 foreign_key: None,
1443 on_delete: None,
1444 auto_now_add: false,
1445 auto_now: false,
1446 sync_name: None,
1447 server_owned: false,
1448 };
1449
1450 for attribute in attributes {
1451 if !attribute.path().is_ident("orm") {
1452 continue;
1453 }
1454 attribute.parse_nested_meta(|meta| {
1455 if meta.path.is_ident("db_column") {
1456 result.db_column = Some(meta.value()?.parse()?);
1457 } else if meta.path.is_ident("sync_name") {
1458 result.sync_name = Some(meta.value()?.parse()?);
1459 } else if meta.path.is_ident("server_owned") {
1460 result.server_owned = true;
1461 } else if meta.path.is_ident("primary_key") {
1462 result.primary_key = true;
1463 } else if meta.path.is_ident("unique") {
1464 result.unique = true;
1465 } else if meta.path.is_ident("default") {
1466 result.default = Some(meta.value()?.parse()?);
1467 } else if meta.path.is_ident("check") {
1468 result.check = Some(meta.value()?.parse()?);
1469 } else if meta.path.is_ident("references") {
1470 let value: LitStr = meta.value()?.parse()?;
1471 validate_reference(&value.value(), value.span())?;
1472 result.references = Some(value);
1473 } else if meta.path.is_ident("foreign_key") {
1474 if result.references.is_some() {
1475 return Err(meta.error("foreign_key and references are mutually exclusive"));
1476 }
1477 result.foreign_key = Some(meta.value()?.parse()?);
1478 } else if meta.path.is_ident("on_delete") {
1479 let value: LitStr = meta.value()?.parse()?;
1480 validate_on_delete(&value.value(), value.span())?;
1481 result.on_delete = Some(value);
1482 } else if meta.path.is_ident("auto_now_add") {
1483 result.auto_now_add = true;
1484 } else if meta.path.is_ident("auto_now") {
1485 result.auto_now = true;
1486 } else {
1487 return Err(meta.error("unsupported field attribute"));
1488 }
1489 Ok(())
1490 })?;
1491 }
1492
1493 if result.auto_now && result.auto_now_add {
1494 return Err(Error::new_spanned(
1495 &attributes[0],
1496 "a field cannot use both auto_now and auto_now_add",
1497 ));
1498 }
1499
1500 if result.references.is_some() && result.foreign_key.is_some() {
1501 return Err(Error::new_spanned(
1502 &attributes[0],
1503 "foreign_key and references are mutually exclusive",
1504 ));
1505 }
1506
1507 Ok(result)
1508}
1509
1510fn is_offset_date_time(ty: &syn::Type) -> bool {
1511 let syn::Type::Path(type_path) = ty else {
1512 return false;
1513 };
1514 type_path
1515 .path
1516 .segments
1517 .last()
1518 .is_some_and(|segment| segment.ident == "OffsetDateTime")
1519}
1520
1521fn is_option_offset_date_time(ty: &syn::Type) -> bool {
1522 let syn::Type::Path(type_path) = ty else {
1523 return false;
1524 };
1525 let Some(segment) = type_path.path.segments.last() else {
1526 return false;
1527 };
1528 if segment.ident != "Option" {
1529 return false;
1530 }
1531 let syn::PathArguments::AngleBracketed(arguments) = &segment.arguments else {
1532 return false;
1533 };
1534 arguments.args.iter().any(|argument| {
1535 matches!(argument, syn::GenericArgument::Type(inner) if is_offset_date_time(inner))
1536 })
1537}
1538
1539fn is_image_field_type(ty: &syn::Type) -> bool {
1540 is_named_field_type(ty, "ImageField")
1541}
1542
1543fn is_named_field_type(ty: &syn::Type, name: &str) -> bool {
1544 let syn::Type::Path(path) = ty else {
1545 return false;
1546 };
1547 let Some(segment) = path.path.segments.last() else {
1548 return false;
1549 };
1550 if segment.ident == name {
1551 return true;
1552 }
1553 if segment.ident != "Option" {
1554 return false;
1555 }
1556 let syn::PathArguments::AngleBracketed(args) = &segment.arguments else {
1557 return false;
1558 };
1559 matches!(args.args.first(), Some(syn::GenericArgument::Type(ty)) if is_named_field_type(ty, name))
1560}
1561
1562fn datetime_deserialize_attribute(
1563 ty: &syn::Type,
1564 orm: &proc_macro2::TokenStream,
1565 patch: bool,
1566) -> proc_macro2::TokenStream {
1567 let function = match (
1568 patch,
1569 is_offset_date_time(ty),
1570 is_option_offset_date_time(ty),
1571 ) {
1572 (false, true, _) => "deserialize_rfc3339",
1573 (false, false, true) => "deserialize_optional_rfc3339",
1574 (true, true, _) => "deserialize_patch_rfc3339",
1575 (true, false, true) => "deserialize_patch_optional_rfc3339",
1576 _ => return quote! {},
1577 };
1578 let path = LitStr::new(
1579 &format!("{}::{function}", orm).replace(' ', ""),
1580 proc_macro2::Span::call_site(),
1581 );
1582 quote! { #[serde(deserialize_with = #path)] }
1583}
1584
1585fn is_i64(ty: &syn::Type) -> bool {
1586 match ty {
1587 syn::Type::Path(path) => path.qself.is_none() && path.path.is_ident("i64"),
1588 _ => false,
1589 }
1590}
1591
1592fn is_uuid(ty: &syn::Type) -> bool {
1593 matches!(ty, syn::Type::Path(path) if path.qself.is_none()
1594 && path.path.segments.last().is_some_and(|segment| segment.ident == "Uuid"))
1595}
1596
1597fn is_option_uuid(ty: &syn::Type) -> bool {
1598 let syn::Type::Path(path) = ty else {
1599 return false;
1600 };
1601 let Some(segment) = path.path.segments.last() else {
1602 return false;
1603 };
1604 if segment.ident != "Option" {
1605 return false;
1606 }
1607 let syn::PathArguments::AngleBracketed(arguments) = &segment.arguments else {
1608 return false;
1609 };
1610 matches!(arguments.args.first(), Some(syn::GenericArgument::Type(inner)) if is_uuid(inner))
1611}
1612
1613fn is_option_i64(ty: &syn::Type) -> bool {
1614 let syn::Type::Path(path) = ty else {
1615 return false;
1616 };
1617 let Some(segment) = path.path.segments.last() else {
1618 return false;
1619 };
1620 if segment.ident != "Option" {
1621 return false;
1622 }
1623 let syn::PathArguments::AngleBracketed(arguments) = &segment.arguments else {
1624 return false;
1625 };
1626 let Some(syn::GenericArgument::Type(inner)) = arguments.args.first() else {
1627 return false;
1628 };
1629 is_i64(inner)
1630}
1631
1632fn validate_identifier(identifier: &str, span: proc_macro2::Span, kind: &str) -> syn::Result<()> {
1633 let mut chars = identifier.chars();
1634 let valid_start = chars
1635 .next()
1636 .is_some_and(|ch| ch == '_' || ch.is_ascii_alphabetic());
1637 if valid_start && chars.all(|ch| ch == '_' || ch.is_ascii_alphanumeric()) {
1638 Ok(())
1639 } else {
1640 Err(Error::new(
1641 span,
1642 format!("invalid {kind} identifier: {identifier}"),
1643 ))
1644 }
1645}
1646
1647fn validate_reference(reference: &str, span: proc_macro2::Span) -> syn::Result<()> {
1648 let Some((table, column)) = reference.split_once('(') else {
1649 return Err(Error::new(
1650 span,
1651 "references must use `table(column)` format",
1652 ));
1653 };
1654 let Some(column) = column.strip_suffix(')') else {
1655 return Err(Error::new(
1656 span,
1657 "references must use `table(column)` format",
1658 ));
1659 };
1660 validate_identifier(table, span, "referenced table")?;
1661 validate_identifier(column, span, "referenced column")
1662}
1663
1664fn validate_on_delete(action: &str, span: proc_macro2::Span) -> syn::Result<()> {
1665 if matches!(
1666 action.to_ascii_lowercase().as_str(),
1667 "cascade" | "restrict" | "no action" | "set null" | "set default"
1668 ) {
1669 Ok(())
1670 } else {
1671 Err(Error::new(
1672 span,
1673 format!("unsupported on_delete action: {action}"),
1674 ))
1675 }
1676}