feat: Extend DeriveIntoActiveModel (#2961)

* Add default and set functionality to DeriveIntoActiveModel macros

* Add simple comments to avoid adding more functions
Remove redundant mut skip
Run cargo fmt

* Add foreign ingnore test

* Add draft docs for DeriveIntoActiveModel

* Fix silent fail on invalid rust in default attribute
Move field attribute parsing into a function

* Error on dublicate `default` attributes

* Add comments and internal docs
Rename sets to set_fields

* Add fill as an alias for `set` container attribute

* Add a test both variants of writing `set` attribute

* Add bare `default` variant support

* Format docs

* Allow `default` attribute for enums other than Option<T> through `.into()`

* Add a test for external CustomOption implmentations

Author: sinder38

sea-orm-macros/src/derives/into_active_model.rs

@@ -9,13 +9,48 @@ enum Error {
     Syn(syn::Error),
 }
 
+/// Matches all potential ways to convert struct fields into ActiveModel ones
+pub(super) enum IntoActiveModelField {
+    /// `IntoActiveValue::into_active_value(self.field).into()`
+    Normal(syn::Ident),
+    /// Option<T> with fallback: `Some(v) => Set(v).into(), None => Set(expr).into()`
+    WithDefault { ident: syn::Ident, expr: syn::Expr },
+}
+
+impl IntoActiveModelField {
+    pub(super) fn ident(&self) -> &syn::Ident {
+        match self {
+            IntoActiveModelField::Normal(ident) => ident,
+            IntoActiveModelField::WithDefault { ident, .. } => ident,
+        }
+    }
+}
+
+/// Contains all the information extracted from the input struct and its attributes
+/// needed to generate the `IntoActiveModel` trait implementation.
 pub(super) struct DeriveIntoActiveModel {
+    /// The identifier of the input struct
     pub ident: syn::Ident,
+    /// Optional explicit ActiveModel type specified via `#[sea_orm(active_model = "Type")]`
     pub active_model: Option<syn::Type>,
-    pub fields: Vec<syn::Ident>,
+    /// handles provided struct fields
+    pub fields: Vec<IntoActiveModelField>,
+    /// handles fields set by #[sea_orm(set(field = expr))]
+    pub set_fields: Vec<(syn::Ident, syn::Expr)>,
+    /// require all fields specified, no `..default::Default()`
+    pub exhaustive: bool,
 }
 
 impl DeriveIntoActiveModel {
+    /// This function finds attributes relevant for this macros:
+    /// Container attributes (#[sea_orm(...)]) on the struct for:
+    ///   - active_model: explicit ActiveModel type
+    ///   - exhaustive: require all fields to be set
+    ///   - set/fill(...): provided values for ommited fields
+    ///
+    /// Field attributes (#[sea_orm(...)]) with:
+    ///   - ignore/skip: exclude from conversion
+    ///   - default: fallback value for Option<T> fields
     fn new(input: syn::DeriveInput) -> Result<Self, Error> {
         let fields = match input.data {
             syn::Data::Struct(syn::DataStruct {
@@ -26,30 +61,65 @@ impl DeriveIntoActiveModel {
         };
 
         let mut active_model = None;
+        let mut set_fields = Vec::new();
+        let mut exhaustive = false;
 
         for attr in input.attrs.iter() {
             if !attr.path().is_ident("sea_orm") {
                 continue;
             }
 
+            // Parse container attributes: #[sea_orm(...)]
+            // Supports:
+            // - active_model = "Type": explicitly specify the ActiveModel type
+            // - exhaustive: require all ActiveModel fields to be explicitly set
+            // - set(field = expr, ...): provide default values for fields not in the input struct
             if let Ok(list) = attr.parse_args_with(Punctuated::<Meta, Comma>::parse_terminated) {
                 for meta in list {
+                    // Parse active_model attribute: #[sea_orm(active_model = "MyActiveModel")]
                     if let Some(s) = meta.get_as_kv("active_model") {
                         active_model = Some(syn::parse_str::<syn::Type>(&s).map_err(Error::Syn)?);
                     }
+                    // Parse exhaustive flag: #[sea_orm(exhaustive)]
+                    // When set, prevents using Default::default() for unspecified fields
+                    if meta.exists("exhaustive") {
+                        exhaustive = true;
+                    }
+                    // Parse set/fill attribute: #[sea_orm(set(field1 = expr1, field2 = expr2, ...))]
+                    // Collects field assignments to be included in the generated ActiveModel
+                    if let Meta::List(meta_list) = &meta {
+                        if meta_list.path.is_ident("set") || meta_list.path.is_ident("fill") {
+                            let nested = meta_list
+                                .parse_args_with(Punctuated::<Meta, Comma>::parse_terminated)
+                                .map_err(Error::Syn)?;
+                            for nested_meta in nested {
+                                if let Some(val) = nested_meta.get_as_kv_with_ident() {
+                                    let (ident, expr_str) = val;
+                                    let expr = syn::parse_str::<syn::Expr>(&expr_str)
+                                        .map_err(Error::Syn)?;
+                                    set_fields.push((ident, expr));
+                                }
+                            }
+                        }
+                    }
                 }
             }
         }
 
-        let field_idents = fields
-            .iter()
-            .map(|field| field.ident.as_ref().unwrap().clone())
-            .collect();
+        // Field attributes
+        let mut field_idents: Vec<IntoActiveModelField> = Vec::new();
+        for field in fields.iter() {
+            if let Some(f) = parse_field(field)? {
+                field_idents.push(f);
+            }
+        }
 
         Ok(Self {
             ident: input.ident,
             active_model,
             fields: field_idents,
+            set_fields,
+            exhaustive,
         })
     }
 
@@ -59,17 +129,21 @@ impl DeriveIntoActiveModel {
         Ok(expanded_impl_into_active_model)
     }
 
+    /// Generates the implementation of `IntoActiveModel` trait for the input struct
     pub(super) fn impl_into_active_model(&self) -> TokenStream {
         let Self {
             ident,
             active_model,
             fields,
+            set_fields,
+            exhaustive,
         } = self;
 
         let mut active_model_ident = active_model
             .clone()
             .unwrap_or_else(|| syn::parse_str::<syn::Type>("ActiveModel").unwrap());
 
+        // Create a type alias for qualified types
         let type_alias_definition = if is_qualified_type(&active_model_ident) {
             let type_alias = format_ident!("ActiveModelFor{ident}");
             let type_def = quote!( type #type_alias = #active_model_ident; );
@@ -90,28 +164,111 @@ impl DeriveIntoActiveModel {
             quote!()
         };
 
-        let expanded_fields = fields.iter().map(|field_ident| {
+        let field_idents: Vec<_> = fields.iter().map(|f| f.ident()).collect();
+
+        // Generate field conversion code based on field type
+        let expanded_fields = fields.iter().map(|field| match field {
+            IntoActiveModelField::Normal(ident) => quote!(
+                sea_orm::IntoActiveValue::<_>::into_active_value(self.#ident).into()
+            ),
+            IntoActiveModelField::WithDefault { ident, expr } => quote!({
+                match self.#ident.into() {
+                    Some(v) => sea_orm::ActiveValue::Set(v).into(),
+                    None => sea_orm::ActiveValue::Set(#expr).into(),
+                }
+            }),
+        });
+
+        // Add custom field assignments from #[sea_orm(set(field = expr))]
+        let (set_idents, set_exprs): (Vec<_>, Vec<_>) = set_fields.iter().cloned().unzip();
+        let expanded_sets = set_exprs.iter().map(|expr| {
             quote!(
-                sea_orm::IntoActiveValue::<_>::into_active_value(self.#field_ident).into()
+                sea_orm::ActiveValue::Set(#expr)
             )
         });
 
+        // Add defaults(Unset) unless exhaustive mode is enabled
+        let rest = if *exhaustive {
+            quote!()
+        } else {
+            quote!(..::std::default::Default::default())
+        };
+
         quote!(
             #type_alias_definition
 
             #[automatically_derived]
             impl sea_orm::IntoActiveModel<#active_model_ident> for #ident {
                 fn into_active_model(self) -> #active_model_ident {
                     #active_model_ident {
-                        #( #fields: #expanded_fields, )*
-                        ..::std::default::Default::default()
+                        #( #field_idents: #expanded_fields, )*
+                        #( #set_idents: #expanded_sets, )*
+                        #rest
                     }
                 }
             }
         )
     }
 }
 
+/// Parse field-level attributes on each struct field
+/// Supports:
+/// - ignore or skip: exclude the field from conversion
+/// - default = "expr": provide a fallback value for Option<T> fields (Some(v) => Set(v), None => Set(expr))
+fn parse_field(field: &syn::Field) -> Result<Option<IntoActiveModelField>, Error> {
+    let ident = field.ident.as_ref().unwrap().clone();
+    // Default expression for this field
+    let mut default_expr: Option<syn::Expr> = None;
+
+    for attr in field.attrs.iter() {
+        if !attr.path().is_ident("sea_orm") {
+            continue;
+        }
+
+        // Parse the attribute arguments: #[sea_orm(...)]
+        if let Ok(list) = attr.parse_args_with(Punctuated::<Meta, Comma>::parse_terminated) {
+            for meta in list.iter() {
+                // Check for ignore/skip: #[sea_orm(ignore)] or #[sea_orm(skip)]
+                if meta.exists("ignore") || meta.exists("skip") {
+                    return Ok(None);
+                }
+                // Check for bare default: #[sea_orm(default)]
+                if meta.exists("default") {
+                    if default_expr.is_some() {
+                        return Err(Error::Syn(syn::Error::new_spanned(
+                            meta,
+                            "duplicate `default` attribute",
+                        )));
+                    }
+                    let expr: syn::Expr = syn::parse_quote!(::core::default::Default::default());
+                    default_expr = Some(expr);
+                    continue; // Skip next default check
+                }
+                // Check for default value: #[sea_orm(default = "expr")]
+                if let Some(expr_str) = meta.get_as_kv("default") {
+                    // Error on duplicate `default`
+                    if default_expr.is_some() {
+                        return Err(Error::Syn(syn::Error::new_spanned(
+                            meta,
+                            "duplicate `default` attribute",
+                        )));
+                    }
+                    // Parse the expression string into a syn::Expr
+                    let expr = syn::parse_str::<syn::Expr>(&expr_str).map_err(Error::Syn)?;
+                    default_expr = Some(expr);
+                }
+            }
+        }
+    }
+
+    // Finnaly match and return appropriate field type
+    if let Some(expr) = default_expr {
+        Ok(Some(IntoActiveModelField::WithDefault { ident, expr }))
+    } else {
+        Ok(Some(IntoActiveModelField::Normal(ident)))
+    }
+}
+
 /// Method to derive the ActiveModel from the [ActiveModelTrait](sea_orm::ActiveModelTrait)
 pub fn expand_into_active_model(input: syn::DeriveInput) -> syn::Result<TokenStream> {
     let ident_span = input.ident.span();

sea-orm-macros/src/derives/partial_model.rs

@@ -8,7 +8,7 @@ use syn::{
 use super::from_query_result::{
     DeriveFromQueryResult, FromQueryResultItem, ItemType as FqrItemType,
 };
-use super::into_active_model::DeriveIntoActiveModel;
+use super::into_active_model::{DeriveIntoActiveModel, IntoActiveModelField};
 use super::util::GetMeta;
 
 #[derive(Debug)]
@@ -235,9 +235,11 @@ impl DerivePartialModel {
                             ColumnAs::Nested { .. } => None,
                             ColumnAs::Skip(_) => None,
                         }
-                        .cloned()
+                        .map(|f| IntoActiveModelField::Normal(f.clone()))
                     })
                     .collect(),
+                set_fields: Vec::new(),
+                exhaustive: false,
             }
             .impl_into_active_model()
         } else {

sea-orm-macros/src/derives/util.rs

@@ -198,6 +198,7 @@ pub(crate) const RUST_SPECIAL_KEYWORDS: [&str; 3] = ["crate", "Self", "self"];
 pub(crate) trait GetMeta {
     fn exists(&self, k: &str) -> bool;
     fn get_as_kv(&self, k: &str) -> Option<String>;
+    fn get_as_kv_with_ident(&self) -> Option<(Ident, String)>;
 }
 
 impl GetMeta for Meta {
@@ -228,6 +229,24 @@ impl GetMeta for Meta {
             None
         }
     }
+
+    fn get_as_kv_with_ident(&self) -> Option<(Ident, String)> {
+        let Meta::NameValue(MetaNameValue {
+            path,
+            value: syn::Expr::Lit(exprlit),
+            ..
+        }) = self
+        else {
+            return None;
+        };
+
+        let syn::Lit::Str(litstr) = &exprlit.lit else {
+            return None;
+        };
+
+        path.get_ident()
+            .map(|ident| (ident.clone(), litstr.value()))
+    }
 }
 
 #[cfg(test)]