Thalo is an event sourcing runtime that leverages the power of WebAssembly (wasm) through wasmtime, combined with sled as an embedded event store. It is designed to handle commands using compiled aggregate wasm components and to persist the resulting events, efficiently managing the rebuilding of aggregate states from previous events.

Counter Aggregate Example

This example shows a basic counter aggregate, allowing the count to be incremented by an amount.

# use std::convert::Infallible;
#
use serde::{Deserialize, Serialize};
use thalo::{events, export_aggregate, Aggregate, Apply, Command, Event, Handle};

export_aggregate!(Counter);

pub struct Counter {
count: u64,
}

impl Aggregate for Counter {
type Command = CounterCommand;
type Event = CounterEvent;

fn init(_id: String) -> Self {
Counter { count: 0 }
}
}

#[derive(Command, Deserialize)]
pub enum CounterCommand {
Increment { amount: u64 },
}

impl Handle<CounterCommand> for Counter {
type Error = Infallible;

fn handle(&self, cmd: CounterCommand) -> Result<Vec<CounterEvent>, Self::Error> {
match cmd {
CounterCommand::Increment { amount } => events![Incremented { amount }],
}
}
}

#[derive(Event, Serialize, Deserialize)]
pub enum CounterEvent {
Incremented(Incremented),
}

#[derive(Serialize, Deserialize)]
pub struct Incremented {
pub amount: u64,
}

impl Apply<Incremented> for Counter {
fn apply(&mut self, event: Incremented) {
self.count += event.amount;
}
}