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, 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 = model_attributes.table;
821 validate_identifier(&table.value(), table.span(), "table")?;
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.sync_name.as_ref().unwrap_or(&table);
1167 let version = model_attributes.sync_version;
1168 quote! {
1169 impl #orm::SyncModel for #model {
1170 const SYNC_NAME: &'static str = #name;
1171 const SYNC_VERSION: u32 = #version;
1172 const AUTOMATIC_METADATA: bool = true;
1173 fn sync_fields() -> Vec<#orm::SyncField> { vec![#(#sync_fields),*] }
1174 }
1175 impl #model {
1176 pub const REVISION: #orm::ModelField<Self, i64> = #orm::ModelField::new(#table, "revision");
1177 pub const UPDATED_AT: #orm::ModelField<Self, #orm::time::OffsetDateTime> = #orm::ModelField::datetime(#table, "updated_at");
1178 pub const DELETED_AT: #orm::ModelField<Self, Option<#orm::time::OffsetDateTime>> = #orm::ModelField::datetime(#table, "deleted_at");
1179 pub const SYNC_SCOPE: #orm::ModelField<Self, String> = #orm::ModelField::new(#table, "sync_scope");
1180 }
1181 }
1182 } else {
1183 quote!()
1184 };
1185 Ok(quote! {
1186 #sync_impl
1187 #(#relation_markers)*
1188
1189 impl #orm::Model for #model {
1190 type PrimaryKey = #primary_key_type;
1191 fn table_name() -> &'static str {
1192 #table
1193 }
1194
1195 fn columns() -> &'static [&'static str] {
1196 &[#(#columns),*]
1197 }
1198
1199 fn primary_key() -> #orm::ModelField<Self, Self::PrimaryKey> {
1200 Self::#primary_key_constant
1201 }
1202
1203 fn primary_key_value(&self) -> Self::PrimaryKey {
1204 self.#primary_key_field
1205 }
1206
1207 fn schema() -> #orm::TableSchema {
1208 let mut columns = Vec::new();
1209 #(#schema_columns)*
1210 #orm::TableSchema {
1211 name: #table,
1212 columns,
1213 unique_constraints: vec![#(#unique_constraints),*],
1214 indexes: vec![#(#indexes),*],
1215 }
1216 }
1217
1218 fn from_row(row: &#orm::Row) -> ::core::result::Result<Self, #orm::DecodeError> {
1219 Self::from_row_at(row, 0)
1220 }
1221
1222 fn from_row_at(
1223 row: &#orm::Row,
1224 offset: usize,
1225 ) -> ::core::result::Result<Self, #orm::DecodeError> {
1226 Ok(Self {
1227 #(#row_fields)*
1228 })
1229 }
1230
1231 fn insert_values(&self) -> ::std::vec::Vec<#orm::InsertValue> {
1232 vec![#(#insert_values),*]
1233 }
1234
1235 fn field_values(&self) -> ::std::vec::Vec<#orm::InsertValue> {
1236 vec![#(#field_values),*]
1237 }
1238
1239 fn write_protected_columns() -> &'static [&'static str] {
1240 &[#(#write_protected_columns),*]
1241 }
1242 fn json_columns() -> &'static [&'static str] {
1243 &[#(#json_columns),*]
1244 }
1245
1246 fn managed_update_values() -> ::std::vec::Vec<#orm::Assignment> {
1247 vec![#(#managed_update_values),*]
1248 }
1249 }
1250
1251 impl #model {
1252 #(#constants)*
1253 #(#relation_constants)*
1254 }
1255 })
1256}
1257
1258struct ModelAttributes {
1259 table: LitStr,
1260 unique_constraints: Vec<Vec<LitStr>>,
1261 indexes: Vec<Vec<LitStr>>,
1262 sync: bool,
1263 sync_name: Option<LitStr>,
1264 sync_version: u32,
1265}
1266
1267fn parse_model_attributes(input: &DeriveInput) -> syn::Result<ModelAttributes> {
1268 let mut table = None;
1269 let mut unique_constraints = Vec::new();
1270 let mut indexes = Vec::new();
1271 let mut sync = false;
1272 let mut sync_name = None;
1273 let mut sync_version = 1;
1274
1275 for attribute in &input.attrs {
1276 if !attribute.path().is_ident("orm") {
1277 continue;
1278 }
1279
1280 attribute.parse_nested_meta(|meta| {
1281 if meta.path.is_ident("table") {
1282 table = Some(meta.value()?.parse()?);
1283 Ok(())
1284 } else if meta.path.is_ident("sync") {
1285 sync = true;
1286 Ok(())
1287 } else if meta.path.is_ident("sync_name") {
1288 sync_name = Some(meta.value()?.parse()?);
1289 Ok(())
1290 } else if meta.path.is_ident("sync_version") {
1291 let version: syn::LitInt = meta.value()?.parse()?;
1292 sync_version = version.base10_parse()?;
1293 if sync_version == 0 {
1294 return Err(meta.error("sync_version must be positive"));
1295 }
1296 Ok(())
1297 } else if meta.path.is_ident("unique") || meta.path.is_ident("index") {
1298 let content;
1299 syn::parenthesized!(content in meta.input);
1300 let values =
1301 content.parse_terminated(|input| input.parse::<LitStr>(), Token![,])?;
1302 if values.is_empty() {
1303 return Err(meta.error("constraint requires at least one column"));
1304 }
1305 let values = values.into_iter().collect::<Vec<_>>();
1306 for value in &values {
1307 validate_identifier(&value.value(), value.span(), "constraint column")?;
1308 }
1309 if meta.path.is_ident("unique") {
1310 unique_constraints.push(values);
1311 } else {
1312 indexes.push(values);
1313 }
1314 Ok(())
1315 } else {
1316 Err(meta
1317 .error("unsupported orm attribute; expected table, unique(...) or index(...)"))
1318 }
1319 })?;
1320 }
1321
1322 let table = table.ok_or_else(|| {
1323 Error::new_spanned(
1324 &input.ident,
1325 "Model requires #[orm(table = \"table_name\")]",
1326 )
1327 })?;
1328 if !sync && (sync_name.is_some() || sync_version != 1) {
1329 return Err(Error::new_spanned(
1330 &input.ident,
1331 "sync settings require #[orm(sync)]",
1332 ));
1333 }
1334 Ok(ModelAttributes {
1335 table,
1336 unique_constraints,
1337 indexes,
1338 sync,
1339 sync_name,
1340 sync_version,
1341 })
1342}
1343
1344struct FieldAttributes {
1345 db_column: Option<LitStr>,
1346 primary_key: bool,
1347 unique: bool,
1348 default: Option<LitStr>,
1349 check: Option<LitStr>,
1350 references: Option<LitStr>,
1351 foreign_key: Option<Path>,
1352 on_delete: Option<LitStr>,
1353 auto_now_add: bool,
1354 auto_now: bool,
1355 sync_name: Option<LitStr>,
1356 server_owned: bool,
1357}
1358
1359fn parse_field_attributes(attributes: &[syn::Attribute]) -> syn::Result<FieldAttributes> {
1360 let mut result = FieldAttributes {
1361 db_column: None,
1362 primary_key: false,
1363 unique: false,
1364 default: None,
1365 check: None,
1366 references: None,
1367 foreign_key: None,
1368 on_delete: None,
1369 auto_now_add: false,
1370 auto_now: false,
1371 sync_name: None,
1372 server_owned: false,
1373 };
1374
1375 for attribute in attributes {
1376 if !attribute.path().is_ident("orm") {
1377 continue;
1378 }
1379 attribute.parse_nested_meta(|meta| {
1380 if meta.path.is_ident("db_column") {
1381 result.db_column = Some(meta.value()?.parse()?);
1382 } else if meta.path.is_ident("sync_name") {
1383 result.sync_name = Some(meta.value()?.parse()?);
1384 } else if meta.path.is_ident("server_owned") {
1385 result.server_owned = true;
1386 } else if meta.path.is_ident("primary_key") {
1387 result.primary_key = true;
1388 } else if meta.path.is_ident("unique") {
1389 result.unique = true;
1390 } else if meta.path.is_ident("default") {
1391 result.default = Some(meta.value()?.parse()?);
1392 } else if meta.path.is_ident("check") {
1393 result.check = Some(meta.value()?.parse()?);
1394 } else if meta.path.is_ident("references") {
1395 let value: LitStr = meta.value()?.parse()?;
1396 validate_reference(&value.value(), value.span())?;
1397 result.references = Some(value);
1398 } else if meta.path.is_ident("foreign_key") {
1399 if result.references.is_some() {
1400 return Err(meta.error("foreign_key and references are mutually exclusive"));
1401 }
1402 result.foreign_key = Some(meta.value()?.parse()?);
1403 } else if meta.path.is_ident("on_delete") {
1404 let value: LitStr = meta.value()?.parse()?;
1405 validate_on_delete(&value.value(), value.span())?;
1406 result.on_delete = Some(value);
1407 } else if meta.path.is_ident("auto_now_add") {
1408 result.auto_now_add = true;
1409 } else if meta.path.is_ident("auto_now") {
1410 result.auto_now = true;
1411 } else {
1412 return Err(meta.error("unsupported field attribute"));
1413 }
1414 Ok(())
1415 })?;
1416 }
1417
1418 if result.auto_now && result.auto_now_add {
1419 return Err(Error::new_spanned(
1420 &attributes[0],
1421 "a field cannot use both auto_now and auto_now_add",
1422 ));
1423 }
1424
1425 if result.references.is_some() && result.foreign_key.is_some() {
1426 return Err(Error::new_spanned(
1427 &attributes[0],
1428 "foreign_key and references are mutually exclusive",
1429 ));
1430 }
1431
1432 Ok(result)
1433}
1434
1435fn is_offset_date_time(ty: &syn::Type) -> bool {
1436 let syn::Type::Path(type_path) = ty else {
1437 return false;
1438 };
1439 type_path
1440 .path
1441 .segments
1442 .last()
1443 .is_some_and(|segment| segment.ident == "OffsetDateTime")
1444}
1445
1446fn is_option_offset_date_time(ty: &syn::Type) -> bool {
1447 let syn::Type::Path(type_path) = ty else {
1448 return false;
1449 };
1450 let Some(segment) = type_path.path.segments.last() else {
1451 return false;
1452 };
1453 if segment.ident != "Option" {
1454 return false;
1455 }
1456 let syn::PathArguments::AngleBracketed(arguments) = &segment.arguments else {
1457 return false;
1458 };
1459 arguments.args.iter().any(|argument| {
1460 matches!(argument, syn::GenericArgument::Type(inner) if is_offset_date_time(inner))
1461 })
1462}
1463
1464fn is_image_field_type(ty: &syn::Type) -> bool {
1465 is_named_field_type(ty, "ImageField")
1466}
1467
1468fn is_named_field_type(ty: &syn::Type, name: &str) -> bool {
1469 let syn::Type::Path(path) = ty else {
1470 return false;
1471 };
1472 let Some(segment) = path.path.segments.last() else {
1473 return false;
1474 };
1475 if segment.ident == name {
1476 return true;
1477 }
1478 if segment.ident != "Option" {
1479 return false;
1480 }
1481 let syn::PathArguments::AngleBracketed(args) = &segment.arguments else {
1482 return false;
1483 };
1484 matches!(args.args.first(), Some(syn::GenericArgument::Type(ty)) if is_named_field_type(ty, name))
1485}
1486
1487fn datetime_deserialize_attribute(
1488 ty: &syn::Type,
1489 orm: &proc_macro2::TokenStream,
1490 patch: bool,
1491) -> proc_macro2::TokenStream {
1492 let function = match (
1493 patch,
1494 is_offset_date_time(ty),
1495 is_option_offset_date_time(ty),
1496 ) {
1497 (false, true, _) => "deserialize_rfc3339",
1498 (false, false, true) => "deserialize_optional_rfc3339",
1499 (true, true, _) => "deserialize_patch_rfc3339",
1500 (true, false, true) => "deserialize_patch_optional_rfc3339",
1501 _ => return quote! {},
1502 };
1503 let path = LitStr::new(
1504 &format!("{}::{function}", orm).replace(' ', ""),
1505 proc_macro2::Span::call_site(),
1506 );
1507 quote! { #[serde(deserialize_with = #path)] }
1508}
1509
1510fn is_i64(ty: &syn::Type) -> bool {
1511 match ty {
1512 syn::Type::Path(path) => path.qself.is_none() && path.path.is_ident("i64"),
1513 _ => false,
1514 }
1515}
1516
1517fn is_uuid(ty: &syn::Type) -> bool {
1518 matches!(ty, syn::Type::Path(path) if path.qself.is_none()
1519 && path.path.segments.last().is_some_and(|segment| segment.ident == "Uuid"))
1520}
1521
1522fn is_option_uuid(ty: &syn::Type) -> bool {
1523 let syn::Type::Path(path) = ty else {
1524 return false;
1525 };
1526 let Some(segment) = path.path.segments.last() else {
1527 return false;
1528 };
1529 if segment.ident != "Option" {
1530 return false;
1531 }
1532 let syn::PathArguments::AngleBracketed(arguments) = &segment.arguments else {
1533 return false;
1534 };
1535 matches!(arguments.args.first(), Some(syn::GenericArgument::Type(inner)) if is_uuid(inner))
1536}
1537
1538fn is_option_i64(ty: &syn::Type) -> bool {
1539 let syn::Type::Path(path) = ty else {
1540 return false;
1541 };
1542 let Some(segment) = path.path.segments.last() else {
1543 return false;
1544 };
1545 if segment.ident != "Option" {
1546 return false;
1547 }
1548 let syn::PathArguments::AngleBracketed(arguments) = &segment.arguments else {
1549 return false;
1550 };
1551 let Some(syn::GenericArgument::Type(inner)) = arguments.args.first() else {
1552 return false;
1553 };
1554 is_i64(inner)
1555}
1556
1557fn validate_identifier(identifier: &str, span: proc_macro2::Span, kind: &str) -> syn::Result<()> {
1558 let mut chars = identifier.chars();
1559 let valid_start = chars
1560 .next()
1561 .is_some_and(|ch| ch == '_' || ch.is_ascii_alphabetic());
1562 if valid_start && chars.all(|ch| ch == '_' || ch.is_ascii_alphanumeric()) {
1563 Ok(())
1564 } else {
1565 Err(Error::new(
1566 span,
1567 format!("invalid {kind} identifier: {identifier}"),
1568 ))
1569 }
1570}
1571
1572fn validate_reference(reference: &str, span: proc_macro2::Span) -> syn::Result<()> {
1573 let Some((table, column)) = reference.split_once('(') else {
1574 return Err(Error::new(
1575 span,
1576 "references must use `table(column)` format",
1577 ));
1578 };
1579 let Some(column) = column.strip_suffix(')') else {
1580 return Err(Error::new(
1581 span,
1582 "references must use `table(column)` format",
1583 ));
1584 };
1585 validate_identifier(table, span, "referenced table")?;
1586 validate_identifier(column, span, "referenced column")
1587}
1588
1589fn validate_on_delete(action: &str, span: proc_macro2::Span) -> syn::Result<()> {
1590 if matches!(
1591 action.to_ascii_lowercase().as_str(),
1592 "cascade" | "restrict" | "no action" | "set null" | "set default"
1593 ) {
1594 Ok(())
1595 } else {
1596 Err(Error::new(
1597 span,
1598 format!("unsupported on_delete action: {action}"),
1599 ))
1600 }
1601}