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 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}