Skip to main content

che_orm_macros/
lib.rs

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        // Doctests are separate crates even when Cargo identifies this package
13        // as che-orm. The core also aliases itself as che_orm for internal derives.
14        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        // Image references are written by a validated upload handler, never by
198        // accepting a storage key from the JSON model API.
199        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 managed_update_values = Vec::with_capacity(fields.len());
848    let mut relation_constants = Vec::new();
849    let mut relation_markers = Vec::new();
850    let mut primary_key_seen = false;
851    let mut primary_key_constant = None;
852    let mut primary_key_field = None;
853    let mut primary_key_type = None;
854    let mut generated_constants = HashSet::new();
855    let mut field_columns = HashMap::new();
856
857    for (index, field) in fields.into_iter().enumerate() {
858        let field_name = field.ident.expect("named fields always have identifiers");
859        let field_column = field_name.to_string();
860        let field_type = field.ty;
861        let field_attributes = parse_field_attributes(&field.attrs)?;
862        let column = field_attributes
863            .db_column
864            .as_ref()
865            .map(LitStr::value)
866            .unwrap_or_else(|| field_column.clone());
867        let constant = Ident::new(&field_column.to_uppercase(), field_name.span());
868        field_columns.insert(field_column.clone(), column.clone());
869
870        if !generated_constants.insert(constant.to_string()) {
871            return Err(Error::new_spanned(
872                &field_name,
873                format!("generated constant {constant} conflicts with another model field"),
874            ));
875        }
876
877        if field_attributes.foreign_key.is_some()
878            && !is_i64(&field_type)
879            && !is_option_i64(&field_type)
880            && !is_uuid(&field_type)
881            && !is_option_uuid(&field_type)
882        {
883            return Err(Error::new_spanned(
884                &field_type,
885                "foreign_key requires i64, Uuid, Option<i64> or Option<Uuid>",
886            ));
887        }
888
889        if field_attributes.foreign_key.is_some()
890            && field_attributes
891                .on_delete
892                .as_ref()
893                .is_some_and(|action| action.value().eq_ignore_ascii_case("set null"))
894            && !is_option_i64(&field_type)
895            && !is_option_uuid(&field_type)
896        {
897            return Err(Error::new_spanned(
898                &field_type,
899                "on_delete = \"set null\" requires an Option<i64> or Option<Uuid> foreign_key field",
900            ));
901        }
902
903        if field_attributes.primary_key {
904            if primary_key_seen {
905                return Err(Error::new_spanned(
906                    &field_name,
907                    "a model can have only one primary_key field",
908                ));
909            }
910            if !is_i64(&field_type) && !is_uuid(&field_type) {
911                return Err(Error::new_spanned(
912                    &field_type,
913                    "primary_key requires an i64 or Uuid field",
914                ));
915            }
916            primary_key_seen = true;
917            primary_key_constant = Some(constant.clone());
918            primary_key_field = Some(field_name.clone());
919            primary_key_type = Some(field_type.clone());
920        }
921
922        if (field_attributes.auto_now_add || field_attributes.auto_now)
923            && !is_offset_date_time(&field_type)
924        {
925            return Err(Error::new_spanned(
926                field_type,
927                "auto_now_add and auto_now require time::OffsetDateTime",
928            ));
929        }
930
931        columns.push(LitStr::new(&column, field_name.span()));
932        constants.push(quote! {
933            pub const #constant: #orm::ModelField<Self, #field_type> =
934                #orm::ModelField::new(#table, #column);
935        });
936
937        let primary_key = field_attributes.primary_key;
938        let unique = field_attributes.unique;
939        let auto_now_add = field_attributes.auto_now_add;
940        let auto_now = field_attributes.auto_now;
941        let default = field_attributes
942            .default
943            .map(|value| quote! { column.default = Some(#value); });
944        let check = field_attributes
945            .check
946            .map(|value| quote! { column.check = Some(#value); });
947        let references = field_attributes.references.map(|target| {
948            let on_delete = field_attributes
949                .on_delete
950                .clone()
951                .map(|value| quote! { Some(#value) })
952                .unwrap_or_else(|| quote! { None });
953            quote! {
954                column.references = Some(#orm::ForeignKey::new(
955                    #target,
956                    #on_delete,
957                ));
958            }
959        });
960        let foreign_key = field_attributes.foreign_key.as_ref().map(|target| {
961            let on_delete = field_attributes
962                .on_delete
963                .clone()
964                .map(|value| quote! { Some(#value) })
965                .unwrap_or_else(|| quote! { None });
966            quote! {
967                column.references = Some(#orm::ForeignKey::new(
968                    format!(
969                        "{}({})",
970                        <#target as #orm::Model>::table_name(),
971                        <#target as #orm::Model>::primary_key().column().name,
972                    ),
973                    #on_delete,
974                ));
975            }
976        });
977        if let Some(target) = &field_attributes.foreign_key {
978            let key_type = if is_option_i64(&field_type) {
979                quote! { i64 }
980            } else if is_option_uuid(&field_type) {
981                quote! { #orm::Uuid }
982            } else {
983                quote! { #field_type }
984            };
985            let relation_name = field_column
986                .strip_suffix("_id")
987                .unwrap_or(&field_column)
988                .to_uppercase();
989            let alias = field_column
990                .strip_suffix("_id")
991                .unwrap_or(&field_column)
992                .to_ascii_lowercase();
993            let relation_constant = Ident::new(&relation_name, field_name.span());
994            let marker_name = Ident::new(
995                &format!(
996                    "{}{}Relation",
997                    model,
998                    pascal_case(field_column.strip_suffix("_id").unwrap_or(&field_column))
999                ),
1000                field_name.span(),
1001            );
1002            if !generated_constants.insert(relation_name.clone()) {
1003                return Err(Error::new_spanned(
1004                    &field_name,
1005                    format!(
1006                        "generated relation constant {relation_name} conflicts with a model field"
1007                    ),
1008                ));
1009            }
1010            let reverse_name = format!("{}_set", model.to_string().to_lowercase());
1011            relation_constants.push(quote! {
1012                pub const #relation_constant:
1013                    #orm::BelongsTo<Self, #target, #marker_name, #field_type> =
1014                    #orm::BelongsTo::new(
1015                        #table,
1016                        #column,
1017                        |model: &Self| model.#field_name,
1018                        #alias,
1019                        #reverse_name,
1020                    );
1021            });
1022            relation_markers.push(quote! {
1023                #[allow(non_camel_case_types)]
1024                pub struct #marker_name;
1025                impl #orm::RelationSource for #marker_name {
1026                    const SOURCE: &'static str = #column;
1027                }
1028                const _: () = {
1029                    fn check_target_key<T: #orm::Model<PrimaryKey = #key_type>>() {}
1030                    let _ = check_target_key::<#target>;
1031                };
1032            });
1033        }
1034
1035        schema_columns.push(quote! {
1036            let mut column = #orm::ColumnSchema::new(
1037                #column,
1038                <#field_type as #orm::ColumnTypeOf>::column_type(),
1039                <#field_type as #orm::ColumnTypeOf>::nullable(),
1040            ).with_field_name(stringify!(#field_name));
1041            column.primary_key = #primary_key;
1042            column.unique = #unique;
1043            column.auto_now_add = #auto_now_add;
1044            column.auto_now = #auto_now;
1045            column.choices = <#field_type as #orm::ColumnTypeOf>::choices();
1046            #default
1047                #check
1048            #references
1049            #foreign_key
1050            columns.push(column);
1051        });
1052
1053        row_fields.push(quote! {
1054            #field_name: row.get(#index + offset)?,
1055        });
1056
1057        let field_value = quote! {
1058            #orm::InsertValue {
1059                column: #orm::ColumnRef::new(#table, #column),
1060                value: #orm::QueryValue::<#field_type>::into_query_value(
1061                    self.#field_name.clone(),
1062                ),
1063            }
1064        };
1065        field_values.push(field_value.clone());
1066        if (!field_attributes.primary_key || is_uuid(&field_type)) && !auto_now_add && !auto_now {
1067            insert_values.push(field_value);
1068        }
1069
1070        if auto_now {
1071            managed_update_values.push(quote! {
1072                #orm::Assignment {
1073                    column: #orm::ColumnRef::new(#table, #column),
1074                    value: #orm::QueryValue::<#field_type>::into_query_value(
1075                        #orm::time::OffsetDateTime::now_utc(),
1076                    ),
1077                }
1078            });
1079        }
1080    }
1081
1082    let primary_key_constant = primary_key_constant.ok_or_else(|| {
1083        Error::new_spanned(
1084            &model,
1085            "Model requires exactly one #[orm(primary_key)] field",
1086        )
1087    })?;
1088    let primary_key_field = primary_key_field.expect("primary key constant has a field");
1089    let primary_key_type = primary_key_type.expect("primary key has a type");
1090
1091    let unique_constraints = model_attributes.unique_constraints.iter().map(|columns| {
1092        let columns = columns.iter().map(|column| {
1093            let name = field_columns
1094                .get(&column.value())
1095                .cloned()
1096                .unwrap_or_else(|| column.value());
1097            LitStr::new(&name, column.span())
1098        });
1099        quote! { vec![#(#columns),*] }
1100    });
1101    let indexes = model_attributes.indexes.iter().map(|columns| {
1102        let columns = columns.iter().map(|column| {
1103            let name = field_columns
1104                .get(&column.value())
1105                .cloned()
1106                .unwrap_or_else(|| column.value());
1107            LitStr::new(&name, column.span())
1108        });
1109        quote! { vec![#(#columns),*] }
1110    });
1111
1112    Ok(quote! {
1113        #(#relation_markers)*
1114
1115        impl #orm::Model for #model {
1116            type PrimaryKey = #primary_key_type;
1117            fn table_name() -> &'static str {
1118                #table
1119            }
1120
1121            fn columns() -> &'static [&'static str] {
1122                &[#(#columns),*]
1123            }
1124
1125            fn primary_key() -> #orm::ModelField<Self, Self::PrimaryKey> {
1126                Self::#primary_key_constant
1127            }
1128
1129            fn primary_key_value(&self) -> Self::PrimaryKey {
1130                self.#primary_key_field
1131            }
1132
1133            fn schema() -> #orm::TableSchema {
1134                let mut columns = Vec::new();
1135                #(#schema_columns)*
1136                #orm::TableSchema {
1137                    name: #table,
1138                    columns,
1139                    unique_constraints: vec![#(#unique_constraints),*],
1140                    indexes: vec![#(#indexes),*],
1141                }
1142            }
1143
1144            fn from_row(row: &#orm::Row) -> ::core::result::Result<Self, #orm::DecodeError> {
1145                Self::from_row_at(row, 0)
1146            }
1147
1148            fn from_row_at(
1149                row: &#orm::Row,
1150                offset: usize,
1151            ) -> ::core::result::Result<Self, #orm::DecodeError> {
1152                Ok(Self {
1153                    #(#row_fields)*
1154                })
1155            }
1156
1157            fn insert_values(&self) -> ::std::vec::Vec<#orm::InsertValue> {
1158                vec![#(#insert_values),*]
1159            }
1160
1161            fn field_values(&self) -> ::std::vec::Vec<#orm::InsertValue> {
1162                vec![#(#field_values),*]
1163            }
1164
1165            fn managed_update_values() -> ::std::vec::Vec<#orm::Assignment> {
1166                vec![#(#managed_update_values),*]
1167            }
1168        }
1169
1170        impl #model {
1171            #(#constants)*
1172            #(#relation_constants)*
1173        }
1174    })
1175}
1176
1177struct ModelAttributes {
1178    table: LitStr,
1179    unique_constraints: Vec<Vec<LitStr>>,
1180    indexes: Vec<Vec<LitStr>>,
1181}
1182
1183fn parse_model_attributes(input: &DeriveInput) -> syn::Result<ModelAttributes> {
1184    let mut table = None;
1185    let mut unique_constraints = Vec::new();
1186    let mut indexes = Vec::new();
1187
1188    for attribute in &input.attrs {
1189        if !attribute.path().is_ident("orm") {
1190            continue;
1191        }
1192
1193        attribute.parse_nested_meta(|meta| {
1194            if meta.path.is_ident("table") {
1195                table = Some(meta.value()?.parse()?);
1196                Ok(())
1197            } else if meta.path.is_ident("unique") || meta.path.is_ident("index") {
1198                let content;
1199                syn::parenthesized!(content in meta.input);
1200                let values =
1201                    content.parse_terminated(|input| input.parse::<LitStr>(), Token![,])?;
1202                if values.is_empty() {
1203                    return Err(meta.error("constraint requires at least one column"));
1204                }
1205                let values = values.into_iter().collect::<Vec<_>>();
1206                for value in &values {
1207                    validate_identifier(&value.value(), value.span(), "constraint column")?;
1208                }
1209                if meta.path.is_ident("unique") {
1210                    unique_constraints.push(values);
1211                } else {
1212                    indexes.push(values);
1213                }
1214                Ok(())
1215            } else {
1216                Err(meta
1217                    .error("unsupported orm attribute; expected table, unique(...) or index(...)"))
1218            }
1219        })?;
1220    }
1221
1222    let table = table.ok_or_else(|| {
1223        Error::new_spanned(
1224            &input.ident,
1225            "Model requires #[orm(table = \"table_name\")]",
1226        )
1227    })?;
1228    Ok(ModelAttributes {
1229        table,
1230        unique_constraints,
1231        indexes,
1232    })
1233}
1234
1235struct FieldAttributes {
1236    db_column: Option<LitStr>,
1237    primary_key: bool,
1238    unique: bool,
1239    default: Option<LitStr>,
1240    check: Option<LitStr>,
1241    references: Option<LitStr>,
1242    foreign_key: Option<Path>,
1243    on_delete: Option<LitStr>,
1244    auto_now_add: bool,
1245    auto_now: bool,
1246}
1247
1248fn parse_field_attributes(attributes: &[syn::Attribute]) -> syn::Result<FieldAttributes> {
1249    let mut result = FieldAttributes {
1250        db_column: None,
1251        primary_key: false,
1252        unique: false,
1253        default: None,
1254        check: None,
1255        references: None,
1256        foreign_key: None,
1257        on_delete: None,
1258        auto_now_add: false,
1259        auto_now: false,
1260    };
1261
1262    for attribute in attributes {
1263        if !attribute.path().is_ident("orm") {
1264            continue;
1265        }
1266        attribute.parse_nested_meta(|meta| {
1267            if meta.path.is_ident("db_column") {
1268                result.db_column = Some(meta.value()?.parse()?);
1269            } else if meta.path.is_ident("primary_key") {
1270                result.primary_key = true;
1271            } else if meta.path.is_ident("unique") {
1272                result.unique = true;
1273            } else if meta.path.is_ident("default") {
1274                result.default = Some(meta.value()?.parse()?);
1275            } else if meta.path.is_ident("check") {
1276                result.check = Some(meta.value()?.parse()?);
1277            } else if meta.path.is_ident("references") {
1278                let value: LitStr = meta.value()?.parse()?;
1279                validate_reference(&value.value(), value.span())?;
1280                result.references = Some(value);
1281            } else if meta.path.is_ident("foreign_key") {
1282                if result.references.is_some() {
1283                    return Err(meta.error("foreign_key and references are mutually exclusive"));
1284                }
1285                result.foreign_key = Some(meta.value()?.parse()?);
1286            } else if meta.path.is_ident("on_delete") {
1287                let value: LitStr = meta.value()?.parse()?;
1288                validate_on_delete(&value.value(), value.span())?;
1289                result.on_delete = Some(value);
1290            } else if meta.path.is_ident("auto_now_add") {
1291                result.auto_now_add = true;
1292            } else if meta.path.is_ident("auto_now") {
1293                result.auto_now = true;
1294            } else {
1295                return Err(meta.error("unsupported field attribute"));
1296            }
1297            Ok(())
1298        })?;
1299    }
1300
1301    if result.auto_now && result.auto_now_add {
1302        return Err(Error::new_spanned(
1303            &attributes[0],
1304            "a field cannot use both auto_now and auto_now_add",
1305        ));
1306    }
1307
1308    if result.references.is_some() && result.foreign_key.is_some() {
1309        return Err(Error::new_spanned(
1310            &attributes[0],
1311            "foreign_key and references are mutually exclusive",
1312        ));
1313    }
1314
1315    Ok(result)
1316}
1317
1318fn is_offset_date_time(ty: &syn::Type) -> bool {
1319    let syn::Type::Path(type_path) = ty else {
1320        return false;
1321    };
1322    type_path
1323        .path
1324        .segments
1325        .last()
1326        .is_some_and(|segment| segment.ident == "OffsetDateTime")
1327}
1328
1329fn is_option_offset_date_time(ty: &syn::Type) -> bool {
1330    let syn::Type::Path(type_path) = ty else {
1331        return false;
1332    };
1333    let Some(segment) = type_path.path.segments.last() else {
1334        return false;
1335    };
1336    if segment.ident != "Option" {
1337        return false;
1338    }
1339    let syn::PathArguments::AngleBracketed(arguments) = &segment.arguments else {
1340        return false;
1341    };
1342    arguments.args.iter().any(|argument| {
1343        matches!(argument, syn::GenericArgument::Type(inner) if is_offset_date_time(inner))
1344    })
1345}
1346
1347fn is_image_field_type(ty: &syn::Type) -> bool {
1348    let syn::Type::Path(path) = ty else {
1349        return false;
1350    };
1351    let Some(segment) = path.path.segments.last() else {
1352        return false;
1353    };
1354    if segment.ident == "ImageField" {
1355        return true;
1356    }
1357    if segment.ident != "Option" {
1358        return false;
1359    }
1360    let syn::PathArguments::AngleBracketed(args) = &segment.arguments else {
1361        return false;
1362    };
1363    matches!(args.args.first(), Some(syn::GenericArgument::Type(ty)) if is_image_field_type(ty))
1364}
1365
1366fn datetime_deserialize_attribute(
1367    ty: &syn::Type,
1368    orm: &proc_macro2::TokenStream,
1369    patch: bool,
1370) -> proc_macro2::TokenStream {
1371    let function = match (
1372        patch,
1373        is_offset_date_time(ty),
1374        is_option_offset_date_time(ty),
1375    ) {
1376        (false, true, _) => "deserialize_rfc3339",
1377        (false, false, true) => "deserialize_optional_rfc3339",
1378        (true, true, _) => "deserialize_patch_rfc3339",
1379        (true, false, true) => "deserialize_patch_optional_rfc3339",
1380        _ => return quote! {},
1381    };
1382    let path = LitStr::new(
1383        &format!("{}::{function}", orm).replace(' ', ""),
1384        proc_macro2::Span::call_site(),
1385    );
1386    quote! { #[serde(deserialize_with = #path)] }
1387}
1388
1389fn is_i64(ty: &syn::Type) -> bool {
1390    match ty {
1391        syn::Type::Path(path) => path.qself.is_none() && path.path.is_ident("i64"),
1392        _ => false,
1393    }
1394}
1395
1396fn is_uuid(ty: &syn::Type) -> bool {
1397    matches!(ty, syn::Type::Path(path) if path.qself.is_none()
1398        && path.path.segments.last().is_some_and(|segment| segment.ident == "Uuid"))
1399}
1400
1401fn is_option_uuid(ty: &syn::Type) -> bool {
1402    let syn::Type::Path(path) = ty else {
1403        return false;
1404    };
1405    let Some(segment) = path.path.segments.last() else {
1406        return false;
1407    };
1408    if segment.ident != "Option" {
1409        return false;
1410    }
1411    let syn::PathArguments::AngleBracketed(arguments) = &segment.arguments else {
1412        return false;
1413    };
1414    matches!(arguments.args.first(), Some(syn::GenericArgument::Type(inner)) if is_uuid(inner))
1415}
1416
1417fn is_option_i64(ty: &syn::Type) -> bool {
1418    let syn::Type::Path(path) = ty else {
1419        return false;
1420    };
1421    let Some(segment) = path.path.segments.last() else {
1422        return false;
1423    };
1424    if segment.ident != "Option" {
1425        return false;
1426    }
1427    let syn::PathArguments::AngleBracketed(arguments) = &segment.arguments else {
1428        return false;
1429    };
1430    let Some(syn::GenericArgument::Type(inner)) = arguments.args.first() else {
1431        return false;
1432    };
1433    is_i64(inner)
1434}
1435
1436fn validate_identifier(identifier: &str, span: proc_macro2::Span, kind: &str) -> syn::Result<()> {
1437    let mut chars = identifier.chars();
1438    let valid_start = chars
1439        .next()
1440        .is_some_and(|ch| ch == '_' || ch.is_ascii_alphabetic());
1441    if valid_start && chars.all(|ch| ch == '_' || ch.is_ascii_alphanumeric()) {
1442        Ok(())
1443    } else {
1444        Err(Error::new(
1445            span,
1446            format!("invalid {kind} identifier: {identifier}"),
1447        ))
1448    }
1449}
1450
1451fn validate_reference(reference: &str, span: proc_macro2::Span) -> syn::Result<()> {
1452    let Some((table, column)) = reference.split_once('(') else {
1453        return Err(Error::new(
1454            span,
1455            "references must use `table(column)` format",
1456        ));
1457    };
1458    let Some(column) = column.strip_suffix(')') else {
1459        return Err(Error::new(
1460            span,
1461            "references must use `table(column)` format",
1462        ));
1463    };
1464    validate_identifier(table, span, "referenced table")?;
1465    validate_identifier(column, span, "referenced column")
1466}
1467
1468fn validate_on_delete(action: &str, span: proc_macro2::Span) -> syn::Result<()> {
1469    if matches!(
1470        action.to_ascii_lowercase().as_str(),
1471        "cascade" | "restrict" | "no action" | "set null" | "set default"
1472    ) {
1473        Ok(())
1474    } else {
1475        Err(Error::new(
1476            span,
1477            format!("unsupported on_delete action: {action}"),
1478        ))
1479    }
1480}