causality

"原因与其结果之间或经常相关的事件或现象之间的关系"

梅里厄姆-韦伯斯特词典

事件驱动架构特质。

事件溯源模型的规范性实现。

在文档中的使用示例。

文档

cargo doc --open

参考文献

• 事件溯源
• CQRS
• 领域驱动设计

许可证

MIT

lib.rs:

实现事件驱动架构的特质。

从因果理论借用热情来概念化确定性状态。

所代表的思想往往是他人工作的反映（Causality、事件溯源、CQRS等）。

注意：实现尚未成熟。预计会有破坏性变更。

示例

use simple_error::SimpleError;
use causality::{Actor, Cause, Effect};

enum Command {
    TestDoor {actor_id: u32, actor_version: u8},
}

impl Cause for Command {
    type ActorId = u32;
    type ActorVersion = u8;
    fn actor_id(&self) -> Self::ActorId {
        match self {
            Command::TestDoor {actor_id, ..} => {
                *actor_id
            }
        }
    }
    fn actor_version(&self) -> Self::ActorVersion {
        match self {
            Command::TestDoor {actor_version, ..} => {
                *actor_version
            }
        }
    }
}

enum Event {
    Opened {version: u8, key: u32},
    Closed {version: u8, key: u32}
}

impl Effect for Event {
    type Version = u8;
    type Key = u32;
    fn version(&self) -> Self::Version {
        match self {
            Event::Opened {version, ..} |
            Event::Closed {version, ..} => {
                *version
            }
        }
    }
    fn key(&self) -> Self::Key {
        match self {
            Event::Opened {key, ..} |
            Event::Closed {key, ..} => {
                *key
            }
        }
    }
}

struct Door {
    id: u32,
    version: u8
}

impl Actor<Command, Event, SimpleError> for Door {
    type Id = u32;
    type Version = u8;
    fn handle(&self, command: Command) -> Result<Vec<Event>, SimpleError> {
        match command {
            Command::TestDoor {actor_id, actor_version} => {
                return Ok(vec![
                    Event::Opened {version: 1, key: 1},
                    Event::Closed {version: 1, key: 2}
                ]);
            }
        }
        Err(SimpleError::new("command should be found due to enum type"))
    }
    fn apply(&mut self, effects: Vec<Event>) -> Result<(), SimpleError> {
        for effect in effects {
            match effect {
                Event::Opened {key, ..} |
                Event::Closed {key, ..} => {
                    self.version = key as u8;
                }
            }
        }
        Ok(())
    }
}

let mut door = Door {
    id: 1,
    version: 1
};
let command = Command::TestDoor {
    actor_id: 1,
    actor_version: 1
};
let events = door.handle(command).unwrap();
assert_eq!(events.len(), 2);
let result = door.apply(events);
assert!(result.is_ok());