Attribute Macro ruva_macro::aggregate

#[aggregate]

Define TAggregate root

Example

#[aggregate]
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct TestAggregate {
    pub(crate) age: i64,
}

fn test_aggregate() {
let aggregate = TestAggregate::default().set_age(1);
assert_eq!(aggregate.version, 0);
assert!(!aggregate.is_existing);
assert_eq!(aggregate.events.len(), 0);
assert_eq!(aggregate.age, 1)
}

#[aggregate]
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct TestAggregate {
    pub(crate) age: i64,
    pub(crate) name: String,
}

Likewise, not specifying identifier will also error out

#[aggregate]
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct TestAggregate {
    pub(crate) age: i64,
    pub(crate) name: String,
}

{your aggregate name}Adapter will be generated automatically so you can use it to adapt it to database rust,no_run

#[aggregate] #[derive(Debug, Clone, Serialize, Default)] pub struct AggregateStruct { #[adapter_ignore] id: i32, #[serde(skip_serializing)] name: String, some_other_field: i32, } let aggregate = AggregateStruct::default(); let serialized = serde_json::to_string(&aggregate).unwrap(); assert_eq!(serialized, “{"id":0,"some_other_field":0,"version":0}”);

let adapter = AggregateStructAdapter::default(); let serialized = serde_json::to_string(&adapter).unwrap(); assert_eq!(serialized, “{"some_other_field":0}”);

Conversion is automatically done as follows:
```rust,no_run```
let aggregate = AggregateStruct {
        name: "migo".into(),
        some_other_field: 2,
        id: 1,
        ..Default::default()
    };
    let converted_adapter = AggregateStructAdapter::from(aggregate);
    assert_eq!(converted_adapter.name, "migo");
    assert_eq!(converted_adapter.some_other_field, 2);
    let converted_struct = AggregateStruct::from(converted_adapter);
    assert_eq!(converted_struct.name, "migo");
    assert_eq!(converted_struct.some_other_field, 2);