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, ext::IdentExt, parse_macro_input,
7    spanned::Spanned,
8};
9
10fn orm_path() -> syn::Result<proc_macro2::TokenStream> {
11    match crate_name("che-orm") {
12        // 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_value = model_attributes.table;
821    let table = quote!(__CHE_ORM_MODEL_TABLE_NAME);
822    let fields = match input.data {
823        Data::Struct(data) => match data.fields {
824            Fields::Named(fields) => fields.named,
825            _ => {
826                return Err(Error::new_spanned(
827                    input.ident,
828                    "Model can only be derived for structs with named fields",
829                ));
830            }
831        },
832        _ => {
833            return Err(Error::new_spanned(
834                input.ident,
835                "Model can only be derived for structs",
836            ));
837        }
838    };
839
840    let model = input.ident;
841    let mut columns = Vec::with_capacity(fields.len());
842    let mut constants = Vec::with_capacity(fields.len());
843    let mut schema_columns = Vec::with_capacity(fields.len());
844    let mut row_fields = Vec::with_capacity(fields.len());
845    let mut insert_values = Vec::with_capacity(fields.len());
846    let mut field_values = Vec::with_capacity(fields.len());
847    let mut write_protected_columns = Vec::new();
848    let mut json_columns = Vec::new();
849    let mut managed_update_values = Vec::with_capacity(fields.len());
850    let mut relation_constants = Vec::new();
851    let mut relation_markers = Vec::new();
852    let mut primary_key_seen = false;
853    let mut primary_key_constant = None;
854    let mut primary_key_field = None;
855    let mut primary_key_type = None;
856    let mut generated_constants = HashSet::new();
857    let mut field_columns = HashMap::new();
858    let mut sync_fields = Vec::new();
859
860    for (index, field) in fields.into_iter().enumerate() {
861        let field_name = field.ident.expect("named fields always have identifiers");
862        let field_column = field_name.to_string();
863        let field_type = field.ty;
864        let field_attributes = parse_field_attributes(&field.attrs)?;
865        let column = field_attributes
866            .db_column
867            .as_ref()
868            .map(LitStr::value)
869            .unwrap_or_else(|| field_column.clone());
870        let constant = Ident::new(&field_column.to_uppercase(), field_name.span());
871        if model_attributes.sync {
872            if ["revision", "updated_at", "deleted_at", "sync_scope"].contains(&column.as_str())
873                || ["revision", "updated_at", "deleted_at", "sync_scope"]
874                    .contains(&field_column.as_str())
875            {
876                return Err(Error::new_spanned(
877                    &field_name,
878                    "sync service columns are infrastructure-owned",
879                ));
880            }
881            if field_attributes.primary_key && !is_uuid(&field_type) {
882                return Err(Error::new_spanned(
883                    &field_type,
884                    "sync models require a UUID primary key",
885                ));
886            }
887            let wire = field_attributes
888                .sync_name
889                .as_ref()
890                .map(LitStr::value)
891                .unwrap_or_else(|| field_column.clone());
892            let constructor = if field_attributes.primary_key
893                || field_attributes.server_owned
894                || field_attributes.auto_now
895                || field_attributes.auto_now_add
896                || is_image_field_type(&field_type)
897            {
898                quote!(server_owned)
899            } else {
900                quote!(writable)
901            };
902            sync_fields.push(quote!(#orm::SyncField::#constructor(#wire, #column)));
903        } else if field_attributes.sync_name.is_some() || field_attributes.server_owned {
904            return Err(Error::new_spanned(
905                &field_name,
906                "sync field attributes require #[orm(sync)]",
907            ));
908        }
909        if is_image_field_type(&field_type) {
910            write_protected_columns.push(column.clone());
911        }
912        if is_named_field_type(&field_type, "JsonField") {
913            json_columns.push(column.clone());
914        }
915        field_columns.insert(field_column.clone(), column.clone());
916
917        if !generated_constants.insert(constant.to_string()) {
918            return Err(Error::new_spanned(
919                &field_name,
920                format!("generated constant {constant} conflicts with another model field"),
921            ));
922        }
923
924        if field_attributes.foreign_key.is_some()
925            && !is_i64(&field_type)
926            && !is_option_i64(&field_type)
927            && !is_uuid(&field_type)
928            && !is_option_uuid(&field_type)
929        {
930            return Err(Error::new_spanned(
931                &field_type,
932                "foreign_key requires i64, Uuid, Option<i64> or Option<Uuid>",
933            ));
934        }
935
936        if field_attributes.foreign_key.is_some()
937            && field_attributes
938                .on_delete
939                .as_ref()
940                .is_some_and(|action| action.value().eq_ignore_ascii_case("set null"))
941            && !is_option_i64(&field_type)
942            && !is_option_uuid(&field_type)
943        {
944            return Err(Error::new_spanned(
945                &field_type,
946                "on_delete = \"set null\" requires an Option<i64> or Option<Uuid> foreign_key field",
947            ));
948        }
949
950        if field_attributes.primary_key {
951            if primary_key_seen {
952                return Err(Error::new_spanned(
953                    &field_name,
954                    "a model can have only one primary_key field",
955                ));
956            }
957            if !is_i64(&field_type) && !is_uuid(&field_type) {
958                return Err(Error::new_spanned(
959                    &field_type,
960                    "primary_key requires an i64 or Uuid field",
961                ));
962            }
963            primary_key_seen = true;
964            primary_key_constant = Some(constant.clone());
965            primary_key_field = Some(field_name.clone());
966            primary_key_type = Some(field_type.clone());
967        }
968
969        if (field_attributes.auto_now_add || field_attributes.auto_now)
970            && !is_offset_date_time(&field_type)
971        {
972            return Err(Error::new_spanned(
973                field_type,
974                "auto_now_add and auto_now require time::OffsetDateTime",
975            ));
976        }
977
978        columns.push(LitStr::new(&column, field_name.span()));
979        let field_constructor =
980            if is_offset_date_time(&field_type) || is_option_offset_date_time(&field_type) {
981                quote!(datetime)
982            } else {
983                quote!(new)
984            };
985        constants.push(quote! {
986            pub const #constant: #orm::ModelField<Self, #field_type> =
987                #orm::ModelField::#field_constructor(#table, #column);
988        });
989
990        let primary_key = field_attributes.primary_key;
991        let unique = field_attributes.unique;
992        let auto_now_add = field_attributes.auto_now_add;
993        let auto_now = field_attributes.auto_now;
994        let default = field_attributes
995            .default
996            .map(|value| quote! { column.default = Some(#value); });
997        let check = field_attributes
998            .check
999            .map(|value| quote! { column.check = Some(#value); });
1000        let references = field_attributes.references.map(|target| {
1001            let on_delete = field_attributes
1002                .on_delete
1003                .clone()
1004                .map(|value| quote! { Some(#value) })
1005                .unwrap_or_else(|| quote! { None });
1006            quote! {
1007                column.references = Some(#orm::ForeignKey::new(
1008                    #target,
1009                    #on_delete,
1010                ));
1011            }
1012        });
1013        let foreign_key = field_attributes.foreign_key.as_ref().map(|target| {
1014            let on_delete = field_attributes
1015                .on_delete
1016                .clone()
1017                .map(|value| quote! { Some(#value) })
1018                .unwrap_or_else(|| quote! { None });
1019            quote! {
1020                column.references = Some(#orm::ForeignKey::new(
1021                    format!(
1022                        "{}({})",
1023                        <#target as #orm::Model>::table_name(),
1024                        <#target as #orm::Model>::primary_key().column().name,
1025                    ),
1026                    #on_delete,
1027                ));
1028            }
1029        });
1030        if let Some(target) = &field_attributes.foreign_key {
1031            let key_type = if is_option_i64(&field_type) {
1032                quote! { i64 }
1033            } else if is_option_uuid(&field_type) {
1034                quote! { #orm::Uuid }
1035            } else {
1036                quote! { #field_type }
1037            };
1038            let relation_name = field_column
1039                .strip_suffix("_id")
1040                .unwrap_or(&field_column)
1041                .to_uppercase();
1042            let alias = field_column
1043                .strip_suffix("_id")
1044                .unwrap_or(&field_column)
1045                .to_ascii_lowercase();
1046            let relation_constant = Ident::new(&relation_name, field_name.span());
1047            let marker_name = Ident::new(
1048                &format!(
1049                    "{}{}Relation",
1050                    model,
1051                    pascal_case(field_column.strip_suffix("_id").unwrap_or(&field_column))
1052                ),
1053                field_name.span(),
1054            );
1055            if !generated_constants.insert(relation_name.clone()) {
1056                return Err(Error::new_spanned(
1057                    &field_name,
1058                    format!(
1059                        "generated relation constant {relation_name} conflicts with a model field"
1060                    ),
1061                ));
1062            }
1063            let reverse_name = format!("{}_set", model.to_string().to_lowercase());
1064            relation_constants.push(quote! {
1065                pub const #relation_constant:
1066                    #orm::BelongsTo<Self, #target, #marker_name, #field_type> =
1067                    #orm::BelongsTo::new(
1068                        #table,
1069                        #column,
1070                        |model: &Self| model.#field_name,
1071                        #alias,
1072                        #reverse_name,
1073                    );
1074            });
1075            relation_markers.push(quote! {
1076                #[allow(non_camel_case_types)]
1077                pub struct #marker_name;
1078                impl #orm::RelationSource for #marker_name {
1079                    const SOURCE: &'static str = #column;
1080                }
1081                const _: () = {
1082                    fn check_target_key<T: #orm::Model<PrimaryKey = #key_type>>() {}
1083                    let _ = check_target_key::<#target>;
1084                };
1085            });
1086        }
1087
1088        schema_columns.push(quote! {
1089            let mut column = #orm::ColumnSchema::new(
1090                #column,
1091                <#field_type as #orm::ColumnTypeOf>::column_type(),
1092                <#field_type as #orm::ColumnTypeOf>::nullable(),
1093            ).with_field_name(stringify!(#field_name));
1094            column.primary_key = #primary_key;
1095            column.unique = #unique;
1096            column.auto_now_add = #auto_now_add;
1097            column.auto_now = #auto_now;
1098            column.choices = <#field_type as #orm::ColumnTypeOf>::choices();
1099            #default
1100                #check
1101            #references
1102            #foreign_key
1103            columns.push(column);
1104        });
1105
1106        row_fields.push(quote! {
1107            #field_name: row.get(#index + offset)?,
1108        });
1109
1110        let field_value = quote! {
1111            #orm::InsertValue {
1112                column: #orm::ColumnRef::new(#table, #column),
1113                value: #orm::QueryValue::<#field_type>::into_query_value(
1114                    self.#field_name.clone(),
1115                ),
1116            }
1117        };
1118        field_values.push(field_value.clone());
1119        if (!field_attributes.primary_key || is_uuid(&field_type)) && !auto_now_add && !auto_now {
1120            insert_values.push(field_value);
1121        }
1122
1123        if auto_now {
1124            managed_update_values.push(quote! {
1125                #orm::Assignment {
1126                    column: #orm::ColumnRef::new(#table, #column),
1127                    value: #orm::QueryValue::<#field_type>::into_query_value(
1128                        #orm::time::OffsetDateTime::now_utc(),
1129                    ),
1130                }
1131            });
1132        }
1133    }
1134
1135    let primary_key_constant = primary_key_constant.ok_or_else(|| {
1136        Error::new_spanned(
1137            &model,
1138            "Model requires exactly one #[orm(primary_key)] field",
1139        )
1140    })?;
1141    let primary_key_field = primary_key_field.expect("primary key constant has a field");
1142    let primary_key_type = primary_key_type.expect("primary key has a type");
1143
1144    let unique_constraints = model_attributes.unique_constraints.iter().map(|columns| {
1145        let columns = columns.iter().map(|column| {
1146            let name = field_columns
1147                .get(&column.value())
1148                .cloned()
1149                .unwrap_or_else(|| column.value());
1150            LitStr::new(&name, column.span())
1151        });
1152        quote! { vec![#(#columns),*] }
1153    });
1154    let indexes = model_attributes.indexes.iter().map(|columns| {
1155        let columns = columns.iter().map(|column| {
1156            let name = field_columns
1157                .get(&column.value())
1158                .cloned()
1159                .unwrap_or_else(|| column.value());
1160            LitStr::new(&name, column.span())
1161        });
1162        quote! { vec![#(#columns),*] }
1163    });
1164
1165    let sync_impl = if model_attributes.sync {
1166        let name = model_attributes
1167            .sync_name
1168            .as_ref()
1169            .map(|name| quote!(#name))
1170            .unwrap_or_else(|| table.clone());
1171        let version = model_attributes.sync_version;
1172        quote! {
1173            impl #orm::SyncModel for #model {
1174                const SYNC_NAME: &'static str = #name;
1175                const SYNC_VERSION: u32 = #version;
1176                const AUTOMATIC_METADATA: bool = true;
1177                fn sync_fields() -> Vec<#orm::SyncField> { vec![#(#sync_fields),*] }
1178            }
1179            impl #model {
1180                pub const REVISION: #orm::ModelField<Self, i64> = #orm::ModelField::new(#table, "revision");
1181                pub const UPDATED_AT: #orm::ModelField<Self, #orm::time::OffsetDateTime> = #orm::ModelField::datetime(#table, "updated_at");
1182                pub const DELETED_AT: #orm::ModelField<Self, Option<#orm::time::OffsetDateTime>> = #orm::ModelField::datetime(#table, "deleted_at");
1183                pub const SYNC_SCOPE: #orm::ModelField<Self, String> = #orm::ModelField::new(#table, "sync_scope");
1184            }
1185        }
1186    } else {
1187        quote!()
1188    };
1189    let implementations = quote! {
1190        #sync_impl
1191
1192        impl #orm::Model for #model {
1193            type PrimaryKey = #primary_key_type;
1194            fn table_name() -> &'static str {
1195                #table
1196            }
1197
1198            fn columns() -> &'static [&'static str] {
1199                &[#(#columns),*]
1200            }
1201
1202            fn primary_key() -> #orm::ModelField<Self, Self::PrimaryKey> {
1203                Self::#primary_key_constant
1204            }
1205
1206            fn primary_key_value(&self) -> Self::PrimaryKey {
1207                self.#primary_key_field
1208            }
1209
1210            fn schema() -> #orm::TableSchema {
1211                let mut columns = Vec::new();
1212                #(#schema_columns)*
1213                #orm::TableSchema {
1214                    name: #table,
1215                    columns,
1216                    unique_constraints: vec![#(#unique_constraints),*],
1217                    indexes: vec![#(#indexes),*],
1218                }
1219            }
1220
1221            fn from_row(row: &#orm::Row) -> ::core::result::Result<Self, #orm::DecodeError> {
1222                Self::from_row_at(row, 0)
1223            }
1224
1225            fn from_row_at(
1226                row: &#orm::Row,
1227                offset: usize,
1228            ) -> ::core::result::Result<Self, #orm::DecodeError> {
1229                Ok(Self {
1230                    #(#row_fields)*
1231                })
1232            }
1233
1234            fn insert_values(&self) -> ::std::vec::Vec<#orm::InsertValue> {
1235                vec![#(#insert_values),*]
1236            }
1237
1238            fn field_values(&self) -> ::std::vec::Vec<#orm::InsertValue> {
1239                vec![#(#field_values),*]
1240            }
1241
1242            fn write_protected_columns() -> &'static [&'static str] {
1243                &[#(#write_protected_columns),*]
1244            }
1245            fn json_columns() -> &'static [&'static str] {
1246                &[#(#json_columns),*]
1247            }
1248
1249            fn managed_update_values() -> ::std::vec::Vec<#orm::Assignment> {
1250                vec![#(#managed_update_values),*]
1251            }
1252        }
1253
1254        impl #model {
1255            #(#constants)*
1256            #(#relation_constants)*
1257        }
1258    };
1259    Ok(quote! {
1260        #(#relation_markers)*
1261        const _: () = {
1262            const __CHE_ORM_MODEL_TABLE_NAME: &str = #table_value;
1263            #implementations
1264        };
1265    })
1266}
1267
1268struct ModelAttributes {
1269    table: proc_macro2::TokenStream,
1270    unique_constraints: Vec<Vec<LitStr>>,
1271    indexes: Vec<Vec<LitStr>>,
1272    sync: bool,
1273    sync_name: Option<LitStr>,
1274    sync_version: u32,
1275}
1276
1277fn parse_model_attributes(input: &DeriveInput) -> syn::Result<ModelAttributes> {
1278    let mut table: Option<LitStr> = None;
1279    let mut app: Option<syn::Expr> = None;
1280    let mut unique_constraints = Vec::new();
1281    let mut indexes = Vec::new();
1282    let mut sync = false;
1283    let mut sync_name = None;
1284    let mut sync_version = 1;
1285
1286    for attribute in &input.attrs {
1287        if !attribute.path().is_ident("orm") {
1288            continue;
1289        }
1290
1291        attribute.parse_nested_meta(|meta| {
1292            if meta.path.is_ident("table") {
1293                table = Some(meta.value()?.parse()?);
1294                Ok(())
1295            } else if meta.path.is_ident("app") {
1296                let value: syn::Expr = meta.value()?.parse()?;
1297                match &value {
1298                    syn::Expr::Lit(syn::ExprLit {
1299                        lit: syn::Lit::Str(value),
1300                        ..
1301                    }) => {
1302                        validate_identifier(&value.value(), value.span(), "app")?;
1303                    }
1304                    syn::Expr::Path(path) if path.qself.is_none() => {}
1305                    _ => {
1306                        return Err(Error::new_spanned(
1307                            &value,
1308                            "app must be a string literal or a path to a const &str",
1309                        ));
1310                    }
1311                }
1312                app = Some(value);
1313                Ok(())
1314            } else if meta.path.is_ident("sync") {
1315                sync = true;
1316                Ok(())
1317            } else if meta.path.is_ident("sync_name") {
1318                sync_name = Some(meta.value()?.parse()?);
1319                Ok(())
1320            } else if meta.path.is_ident("sync_version") {
1321                let version: syn::LitInt = meta.value()?.parse()?;
1322                sync_version = version.base10_parse()?;
1323                if sync_version == 0 {
1324                    return Err(meta.error("sync_version must be positive"));
1325                }
1326                Ok(())
1327            } else if meta.path.is_ident("unique") || meta.path.is_ident("index") {
1328                let content;
1329                syn::parenthesized!(content in meta.input);
1330                let values =
1331                    content.parse_terminated(|input| input.parse::<LitStr>(), Token![,])?;
1332                if values.is_empty() {
1333                    return Err(meta.error("constraint requires at least one column"));
1334                }
1335                let values = values.into_iter().collect::<Vec<_>>();
1336                for value in &values {
1337                    validate_identifier(&value.value(), value.span(), "constraint column")?;
1338                }
1339                if meta.path.is_ident("unique") {
1340                    unique_constraints.push(values);
1341                } else {
1342                    indexes.push(values);
1343                }
1344                Ok(())
1345            } else {
1346                Err(meta.error(
1347                    "unsupported orm attribute; expected table, app, unique(...) or index(...)",
1348                ))
1349            }
1350        })?;
1351    }
1352
1353    let table = if let Some(table) = table {
1354        validate_identifier(&table.value(), table.span(), "table")?;
1355        quote!(#table)
1356    } else if let Some(app) = app {
1357        let model_name = LitStr::new(
1358            &snake_case(&input.ident.unraw().to_string()),
1359            input.ident.span(),
1360        );
1361        validate_identifier(&model_name.value(), model_name.span(), "model table suffix")?;
1362        // Each expression has its own scope, so generated names cannot collide with
1363        // application items. The compiler evaluates and validates constant paths.
1364        quote!({
1365            const __CHE_ORM_APP: &str = #app;
1366            const __CHE_ORM_MODEL: &str = #model_name;
1367            const fn __che_orm_table_bytes() -> [u8; __CHE_ORM_APP.len() + 1 + __CHE_ORM_MODEL.len()] {
1368                let app = __CHE_ORM_APP.as_bytes();
1369                assert!(!app.is_empty(), "invalid app identifier: expected a nonempty SQL identifier");
1370                let mut bytes = [0; __CHE_ORM_APP.len() + 1 + __CHE_ORM_MODEL.len()];
1371                let mut i = 0;
1372                while i < app.len() {
1373                    assert!(
1374                        app[i] == b'_' || app[i].is_ascii_alphabetic()
1375                            || (i > 0 && app[i].is_ascii_digit()),
1376                        "invalid app identifier: expected ASCII letters, digits or underscores, starting with a letter or underscore",
1377                    );
1378                    bytes[i] = app[i];
1379                    i += 1;
1380                }
1381                bytes[i] = b'_';
1382                let model = __CHE_ORM_MODEL.as_bytes();
1383                let mut j = 0;
1384                while j < model.len() {
1385                    bytes[i + 1 + j] = model[j];
1386                    j += 1;
1387                }
1388                bytes
1389            }
1390            const __CHE_ORM_BYTES: &[u8] = &__che_orm_table_bytes();
1391            const __CHE_ORM_TABLE: &str = match ::core::str::from_utf8(__CHE_ORM_BYTES) {
1392                Ok(table) => table,
1393                Err(_) => panic!("invalid table identifier: expected ASCII"),
1394            };
1395            __CHE_ORM_TABLE
1396        })
1397    } else {
1398        return Err(Error::new_spanned(
1399            &input.ident,
1400            "Model requires #[orm(table = \"table_name\")] or #[orm(app = \"app_name\")]",
1401        ));
1402    };
1403    if !sync && (sync_name.is_some() || sync_version != 1) {
1404        return Err(Error::new_spanned(
1405            &input.ident,
1406            "sync settings require #[orm(sync)]",
1407        ));
1408    }
1409    Ok(ModelAttributes {
1410        table,
1411        unique_constraints,
1412        indexes,
1413        sync,
1414        sync_name,
1415        sync_version,
1416    })
1417}
1418
1419struct FieldAttributes {
1420    db_column: Option<LitStr>,
1421    primary_key: bool,
1422    unique: bool,
1423    default: Option<LitStr>,
1424    check: Option<LitStr>,
1425    references: Option<LitStr>,
1426    foreign_key: Option<Path>,
1427    on_delete: Option<LitStr>,
1428    auto_now_add: bool,
1429    auto_now: bool,
1430    sync_name: Option<LitStr>,
1431    server_owned: bool,
1432}
1433
1434fn parse_field_attributes(attributes: &[syn::Attribute]) -> syn::Result<FieldAttributes> {
1435    let mut result = FieldAttributes {
1436        db_column: None,
1437        primary_key: false,
1438        unique: false,
1439        default: None,
1440        check: None,
1441        references: None,
1442        foreign_key: None,
1443        on_delete: None,
1444        auto_now_add: false,
1445        auto_now: false,
1446        sync_name: None,
1447        server_owned: false,
1448    };
1449
1450    for attribute in attributes {
1451        if !attribute.path().is_ident("orm") {
1452            continue;
1453        }
1454        attribute.parse_nested_meta(|meta| {
1455            if meta.path.is_ident("db_column") {
1456                result.db_column = Some(meta.value()?.parse()?);
1457            } else if meta.path.is_ident("sync_name") {
1458                result.sync_name = Some(meta.value()?.parse()?);
1459            } else if meta.path.is_ident("server_owned") {
1460                result.server_owned = true;
1461            } else if meta.path.is_ident("primary_key") {
1462                result.primary_key = true;
1463            } else if meta.path.is_ident("unique") {
1464                result.unique = true;
1465            } else if meta.path.is_ident("default") {
1466                result.default = Some(meta.value()?.parse()?);
1467            } else if meta.path.is_ident("check") {
1468                result.check = Some(meta.value()?.parse()?);
1469            } else if meta.path.is_ident("references") {
1470                let value: LitStr = meta.value()?.parse()?;
1471                validate_reference(&value.value(), value.span())?;
1472                result.references = Some(value);
1473            } else if meta.path.is_ident("foreign_key") {
1474                if result.references.is_some() {
1475                    return Err(meta.error("foreign_key and references are mutually exclusive"));
1476                }
1477                result.foreign_key = Some(meta.value()?.parse()?);
1478            } else if meta.path.is_ident("on_delete") {
1479                let value: LitStr = meta.value()?.parse()?;
1480                validate_on_delete(&value.value(), value.span())?;
1481                result.on_delete = Some(value);
1482            } else if meta.path.is_ident("auto_now_add") {
1483                result.auto_now_add = true;
1484            } else if meta.path.is_ident("auto_now") {
1485                result.auto_now = true;
1486            } else {
1487                return Err(meta.error("unsupported field attribute"));
1488            }
1489            Ok(())
1490        })?;
1491    }
1492
1493    if result.auto_now && result.auto_now_add {
1494        return Err(Error::new_spanned(
1495            &attributes[0],
1496            "a field cannot use both auto_now and auto_now_add",
1497        ));
1498    }
1499
1500    if result.references.is_some() && result.foreign_key.is_some() {
1501        return Err(Error::new_spanned(
1502            &attributes[0],
1503            "foreign_key and references are mutually exclusive",
1504        ));
1505    }
1506
1507    Ok(result)
1508}
1509
1510fn is_offset_date_time(ty: &syn::Type) -> bool {
1511    let syn::Type::Path(type_path) = ty else {
1512        return false;
1513    };
1514    type_path
1515        .path
1516        .segments
1517        .last()
1518        .is_some_and(|segment| segment.ident == "OffsetDateTime")
1519}
1520
1521fn is_option_offset_date_time(ty: &syn::Type) -> bool {
1522    let syn::Type::Path(type_path) = ty else {
1523        return false;
1524    };
1525    let Some(segment) = type_path.path.segments.last() else {
1526        return false;
1527    };
1528    if segment.ident != "Option" {
1529        return false;
1530    }
1531    let syn::PathArguments::AngleBracketed(arguments) = &segment.arguments else {
1532        return false;
1533    };
1534    arguments.args.iter().any(|argument| {
1535        matches!(argument, syn::GenericArgument::Type(inner) if is_offset_date_time(inner))
1536    })
1537}
1538
1539fn is_image_field_type(ty: &syn::Type) -> bool {
1540    is_named_field_type(ty, "ImageField")
1541}
1542
1543fn is_named_field_type(ty: &syn::Type, name: &str) -> bool {
1544    let syn::Type::Path(path) = ty else {
1545        return false;
1546    };
1547    let Some(segment) = path.path.segments.last() else {
1548        return false;
1549    };
1550    if segment.ident == name {
1551        return true;
1552    }
1553    if segment.ident != "Option" {
1554        return false;
1555    }
1556    let syn::PathArguments::AngleBracketed(args) = &segment.arguments else {
1557        return false;
1558    };
1559    matches!(args.args.first(), Some(syn::GenericArgument::Type(ty)) if is_named_field_type(ty, name))
1560}
1561
1562fn datetime_deserialize_attribute(
1563    ty: &syn::Type,
1564    orm: &proc_macro2::TokenStream,
1565    patch: bool,
1566) -> proc_macro2::TokenStream {
1567    let function = match (
1568        patch,
1569        is_offset_date_time(ty),
1570        is_option_offset_date_time(ty),
1571    ) {
1572        (false, true, _) => "deserialize_rfc3339",
1573        (false, false, true) => "deserialize_optional_rfc3339",
1574        (true, true, _) => "deserialize_patch_rfc3339",
1575        (true, false, true) => "deserialize_patch_optional_rfc3339",
1576        _ => return quote! {},
1577    };
1578    let path = LitStr::new(
1579        &format!("{}::{function}", orm).replace(' ', ""),
1580        proc_macro2::Span::call_site(),
1581    );
1582    quote! { #[serde(deserialize_with = #path)] }
1583}
1584
1585fn is_i64(ty: &syn::Type) -> bool {
1586    match ty {
1587        syn::Type::Path(path) => path.qself.is_none() && path.path.is_ident("i64"),
1588        _ => false,
1589    }
1590}
1591
1592fn is_uuid(ty: &syn::Type) -> bool {
1593    matches!(ty, syn::Type::Path(path) if path.qself.is_none()
1594        && path.path.segments.last().is_some_and(|segment| segment.ident == "Uuid"))
1595}
1596
1597fn is_option_uuid(ty: &syn::Type) -> bool {
1598    let syn::Type::Path(path) = ty else {
1599        return false;
1600    };
1601    let Some(segment) = path.path.segments.last() else {
1602        return false;
1603    };
1604    if segment.ident != "Option" {
1605        return false;
1606    }
1607    let syn::PathArguments::AngleBracketed(arguments) = &segment.arguments else {
1608        return false;
1609    };
1610    matches!(arguments.args.first(), Some(syn::GenericArgument::Type(inner)) if is_uuid(inner))
1611}
1612
1613fn is_option_i64(ty: &syn::Type) -> bool {
1614    let syn::Type::Path(path) = ty else {
1615        return false;
1616    };
1617    let Some(segment) = path.path.segments.last() else {
1618        return false;
1619    };
1620    if segment.ident != "Option" {
1621        return false;
1622    }
1623    let syn::PathArguments::AngleBracketed(arguments) = &segment.arguments else {
1624        return false;
1625    };
1626    let Some(syn::GenericArgument::Type(inner)) = arguments.args.first() else {
1627        return false;
1628    };
1629    is_i64(inner)
1630}
1631
1632fn validate_identifier(identifier: &str, span: proc_macro2::Span, kind: &str) -> syn::Result<()> {
1633    let mut chars = identifier.chars();
1634    let valid_start = chars
1635        .next()
1636        .is_some_and(|ch| ch == '_' || ch.is_ascii_alphabetic());
1637    if valid_start && chars.all(|ch| ch == '_' || ch.is_ascii_alphanumeric()) {
1638        Ok(())
1639    } else {
1640        Err(Error::new(
1641            span,
1642            format!("invalid {kind} identifier: {identifier}"),
1643        ))
1644    }
1645}
1646
1647fn validate_reference(reference: &str, span: proc_macro2::Span) -> syn::Result<()> {
1648    let Some((table, column)) = reference.split_once('(') else {
1649        return Err(Error::new(
1650            span,
1651            "references must use `table(column)` format",
1652        ));
1653    };
1654    let Some(column) = column.strip_suffix(')') else {
1655        return Err(Error::new(
1656            span,
1657            "references must use `table(column)` format",
1658        ));
1659    };
1660    validate_identifier(table, span, "referenced table")?;
1661    validate_identifier(column, span, "referenced column")
1662}
1663
1664fn validate_on_delete(action: &str, span: proc_macro2::Span) -> syn::Result<()> {
1665    if matches!(
1666        action.to_ascii_lowercase().as_str(),
1667        "cascade" | "restrict" | "no action" | "set null" | "set default"
1668    ) {
1669        Ok(())
1670    } else {
1671        Err(Error::new(
1672            span,
1673            format!("unsupported on_delete action: {action}"),
1674        ))
1675    }
1676}