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