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