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