Skip to main content

che_orm_macros/
lib.rs

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