Create active model based on difference between old and new model for update operation

[ziimakc]

I would like to request an approval for creating active_model_from_diff method that will generate active model based on difference between old and new model for update operation.

If similar functionality already exist, please let me know.

This method will simplify update operation (remove boilerplate) if you preserve original model while mutating it's clone or getting book_new from other sources.

#[sea_orm(table_name = "book")]
pub struct Model {
    #[sea_orm(primary_key, auto_increment = false)]
    pub id: i32,
    pub title: String,
    pub description: String,
}

fn test() {
    // from_diff
    let book_old = Model {
        id: 1,
        title: "old_title",
        description: "old_description",
    };

    let mut book_new = book_old.clone();
    book_new.title = "new_title";

    let active_model = book_new.active_model_from_diff(book_old);

    let expected = ActiveModel {
        id: ActiveValue::Unchanged(1),
        title: ActiveValue::Set("new_title"),
        description: ActiveValue::Unchanged("old_description"),
    };

    assert_eq!(active_model, expected);
}

impl ActiveModel {
    fn active_model_from_diff(&self, current: Self) -> ActiveModel {
            // todo
    }
}

---

Example of what you currently need to do to get active model:

    fn aggregate_to_model(user: &User) -> user_model::ActiveModel {
       let nickname = user.nickname().to_string();
          let nickname = if Self::nickname_is_new(user) {
              Set(nickname)
          } else {
              Unchanged(nickname)
          };
          
          ...and so on for each property
          
          user_model::ActiveModel {
            nickname,
            ...
        }
     }
     
      fn nickname_is_new(user: &User) -> bool {
          user.original()
              .is_none_or(|val| val.nickname != user.current().nickname)
      }
        ...and so on for each property

[GoldenChrysus]

This is a strange pattern. ActiveModels effect Models, so why wouldn't you just do:

let book_new = ActiveModel {
    id: ActiveValue::Unchanged(1),
    title: ActiveValue::Set("new_title"),
    ..Default::default()
}.save(db)...

Maybe the premise that you need to set every field is the missing piece of information? You don't need to set every field... The above code block is an example of that but this is also similar:

let mut book_new = ActiveModel::default();

book_new.id = ActiveValue::Unchanged(1);
book_new.title = ActiveValue::Set("new_title");

let book_new = book_new.save(db)...

There's no reason you'd need to be explicitly setting Unchanged on every field.

If you're receiving incoming data from JSON and the above is just a simplified example of your problem, you can similarly automatically convert JSON or structs into ActiveModels with everything automatically set.

Various docs discuss this:

• https://www.sea-ql.org/SeaORM/docs/advanced-query/custom-active-model/
• https://www.sea-ql.org/sea-orm-cookbook/022-bulk-active-model-field-setting.html

Basically the concept of modifying a Model to turn it into an ActiveModel which in turn just generates another Model seems incorrect. You should not be modifying Models, only ActiveModels.

[ziimakc]

@GoldenChrysus User is ddd domain model, basically struct. I have original one Option<User> and changed one User, if original is Option, then I do insert and need all fields set, if original is some, I diff domain models to create active model with unchanged files set as Unchanged(value) and updated fields set as Set(value).

Thanks for a suggestion, I will check it out a bit later, but I still don't see how I can create an active model where only changed fields will be Set, while others Unchanged.

Why I suggested approach above - it much easier to convert domain model into db model as you don't care about Set/Unset and the do a diff to get active model for update operation.

[GoldenChrysus]

Thanks for a suggestion, I will check it out a bit later, but I still don't see how I can create an active model where only changed fields will be Set, while others Unchanged.

See docs linked above where this exact scenario is covered with multiple approaches for multiple use cases.

[ziimakc]

@GoldenChrysus I din't found any way of doing it, here is the simplified example:

    use sea_orm::{
        ActiveValue::{Set, Unchanged},
        entity::prelude::*,
    };
    use serde::{Deserialize, Serialize};

    #[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel, Serialize, Deserialize)]
    #[sea_orm(table_name = "user")]
    pub struct Model {
        #[sea_orm(primary_key, auto_increment = false)]
        pub user_id: i32,
        pub nickname: String,
        pub description: Option<String>,
    }

    #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
    pub enum Relation {}

    impl ActiveModelBehavior for ActiveModel {}

   // domain model should not know anything about database model
    #[derive(Serialize, Deserialize, Clone)]
    pub struct User {
        pub user_id: i32,
        pub nickname: String,
        pub description: Option<String>,
        pub friends: Vec<i32>,
    }

    async fn xxx() {
        let user_entity_original = User {
            user_id: 1,
            nickname: "test".to_owned(),
            description: None,
            friends: vec![],
        };
        let mut user_entity_updated = user_entity_original.clone();
        user_entity_updated.description = Some("new_desc".to_owned());

        // I need to get this
        let expected = ActiveModel {
            user_id: Unchanged(1),
            nickname: Unchanged("test".to_owned()),
            description: Set(Some("new_desc".to_owned())),
        };

        let user_original_json = serde_json::to_value(&user_entity_original).unwrap();
        let user_updated_json = serde_json::to_value(&user_entity_updated).unwrap();
        // all values are set, but I need only changed to be set, json is not helpful
        dbg!(ActiveModel::from_json(user_original_json).unwrap());
        dbg!(ActiveModel::from_json(user_updated_json).unwrap());
    }
    ```