feat(examples): bare minimum "light switch" example

This example application is a bare minimum example of the core functionality.
Persistence is not enabled, nor is logging, nor any kind of user interface. It
just starts, runs some commands, queries the final state and prints it.

It models a "light switch". You can "install" the switch, then turn it "off" or
"on" using commands. You can issue a query to get the current state of a switch.

Author: zachwaite

Cargo.toml

@@ -6,4 +6,5 @@ members = [
     "eventually-postgres",
     # Examples
     "examples/bank-accounting",
+    "examples/light-switch",
 ]

examples/light-switch/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "light_switch"
+version = "0.1.0"
+edition = "2021"
+readme = "README.md"
+publish = false
+
+[dependencies]
+serde_json = { version = "1.0.114", optional = true }
+serde = { version = "1.0.197", features = ["derive"] }
+tokio = { version = "1.36.0", features = ["macros", "rt-multi-thread"] }
+thiserror = { version = "2.0.12" }
+anyhow = "1.0.97"
+async-trait = "0.1.77"
+eventually = { features = ["serde-json"], path="../../eventually" }

examples/light-switch/README.md

@@ -0,0 +1,8 @@
+# Example: Light Switch application
+
+This example application is a bare minimum example of the core functionality.
+Persistence is not enabled, nor is logging, nor any kind of user interface. It
+just starts, runs some commands, queries the final state and prints it.
+
+It models a "light switch". You can "install" the switch, then turn it "off" or
+"on" using commands. You can issue a query to get the current state of a switch.

examples/light-switch/src/application.rs

@@ -0,0 +1,23 @@
+use eventually::aggregate;
+
+use crate::domain::Lightswitch;
+pub type LightswitchRepo<S> = aggregate::EventSourcedRepository<Lightswitch, S>;
+
+#[derive(Clone)]
+pub struct LightswitchService<R>
+where
+    R: aggregate::Repository<Lightswitch>,
+{
+    pub light_switch_repository: R,
+}
+
+impl<R> From<R> for LightswitchService<R>
+where
+    R: aggregate::Repository<Lightswitch>,
+{
+    fn from(light_switch_repository: R) -> Self {
+        Self {
+            light_switch_repository,
+        }
+    }
+}

examples/light-switch/src/commands/install_light_switch.rs

@@ -0,0 +1,33 @@
+use async_trait::async_trait;
+use eventually::{aggregate, command, message};
+
+use crate::application::LightswitchService;
+use crate::domain::{Lightswitch, LightswitchId, LightswitchRoot};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct InstallLightSwitch {
+    pub id: LightswitchId,
+}
+
+impl message::Message for InstallLightSwitch {
+    fn name(&self) -> &'static str {
+        "InstallLightSwitch"
+    }
+}
+
+#[async_trait]
+impl<R> command::Handler<InstallLightSwitch> for LightswitchService<R>
+where
+    R: aggregate::Repository<Lightswitch>,
+{
+    type Error = anyhow::Error;
+    async fn handle(
+        &self,
+        command: command::Envelope<InstallLightSwitch>,
+    ) -> Result<(), Self::Error> {
+        let command = command.message;
+        let mut light_switch = LightswitchRoot::install(command.id)?;
+        self.light_switch_repository.save(&mut light_switch).await?;
+        Ok(())
+    }
+}

examples/light-switch/src/commands/mod.rs

@@ -0,0 +1,3 @@
+pub mod install_light_switch;
+pub mod turn_light_switch_off;
+pub mod turn_light_switch_on;

examples/light-switch/src/commands/turn_light_switch_off.rs

@@ -0,0 +1,34 @@
+use async_trait::async_trait;
+use eventually::{aggregate, command, message};
+
+use crate::application::LightswitchService;
+use crate::domain::{Lightswitch, LightswitchId, LightswitchRoot};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TurnLightSwitchOff {
+    pub id: LightswitchId,
+}
+
+impl message::Message for TurnLightSwitchOff {
+    fn name(&self) -> &'static str {
+        "TurnLightSwitchOff"
+    }
+}
+
+#[async_trait]
+impl<R> command::Handler<TurnLightSwitchOff> for LightswitchService<R>
+where
+    R: aggregate::Repository<Lightswitch>,
+{
+    type Error = anyhow::Error;
+    async fn handle(
+        &self,
+        command: command::Envelope<TurnLightSwitchOff>,
+    ) -> Result<(), Self::Error> {
+        let command = command.message;
+        let mut root: LightswitchRoot = self.light_switch_repository.get(&command.id).await?.into();
+        let _ = root.turn_off(command.id)?;
+        self.light_switch_repository.save(&mut root).await?;
+        Ok(())
+    }
+}

examples/light-switch/src/commands/turn_light_switch_on.rs

@@ -0,0 +1,34 @@
+use async_trait::async_trait;
+use eventually::{aggregate, command, message};
+
+use crate::application::LightswitchService;
+use crate::domain::{Lightswitch, LightswitchId, LightswitchRoot};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TurnLightSwitchOn {
+    pub id: LightswitchId,
+}
+
+impl message::Message for TurnLightSwitchOn {
+    fn name(&self) -> &'static str {
+        "TurnLightSwitchOn"
+    }
+}
+
+#[async_trait]
+impl<R> command::Handler<TurnLightSwitchOn> for LightswitchService<R>
+where
+    R: aggregate::Repository<Lightswitch>,
+{
+    type Error = anyhow::Error;
+    async fn handle(
+        &self,
+        command: command::Envelope<TurnLightSwitchOn>,
+    ) -> Result<(), Self::Error> {
+        let command = command.message;
+        let mut root: LightswitchRoot = self.light_switch_repository.get(&command.id).await?.into();
+        let _ = root.turn_on(command.id)?;
+        self.light_switch_repository.save(&mut root).await?;
+        Ok(())
+    }
+}

examples/light-switch/src/domain.rs

@@ -0,0 +1,156 @@
+use eventually::{aggregate, message};
+
+pub type LightswitchId = String;
+
+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
+pub enum LightswitchError {
+    #[error("NotImplemented")]
+    NotImplemented,
+    #[error("Light switch is already on")]
+    AlreadyOn,
+    #[error("Light switch is already off")]
+    AlreadyOff,
+}
+
+// events
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Installed {
+    id: LightswitchId,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct SwitchedOn {
+    id: LightswitchId,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct SwitchedOff {
+    id: LightswitchId,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum LightswitchEvent {
+    Installed(Installed),
+    SwitchedOn(SwitchedOn),
+    SwitchedOff(SwitchedOff),
+}
+
+impl message::Message for LightswitchEvent {
+    fn name(&self) -> &'static str {
+        match self {
+            LightswitchEvent::SwitchedOn(_) => "SwitchedOn",
+            LightswitchEvent::SwitchedOff(_) => "SwitchedOff",
+            LightswitchEvent::Installed(_) => "Installed",
+        }
+    }
+}
+
+// aggregate
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum LightswitchState {
+    On,
+    Off,
+}
+
+#[derive(Debug, Clone)]
+pub struct Lightswitch {
+    id: LightswitchId,
+    state: LightswitchState,
+}
+
+impl aggregate::Aggregate for Lightswitch {
+    type Id = LightswitchId;
+    type Event = LightswitchEvent;
+    type Error = LightswitchError;
+
+    fn type_name() -> &'static str {
+        "Lightswitch"
+    }
+
+    fn aggregate_id(&self) -> &Self::Id {
+        &self.id
+    }
+
+    fn apply(state: Option<Self>, event: Self::Event) -> Result<Self, Self::Error> {
+        match state {
+            None => match event {
+                LightswitchEvent::Installed(installed) => Ok(Lightswitch {
+                    id: installed.id,
+                    state: LightswitchState::Off,
+                }),
+                LightswitchEvent::SwitchedOn(_) | LightswitchEvent::SwitchedOff(_) => {
+                    Err(LightswitchError::NotImplemented)
+                },
+            },
+            Some(mut light_switch) => match event {
+                LightswitchEvent::Installed(_) => Err(LightswitchError::NotImplemented),
+                LightswitchEvent::SwitchedOn(_) => match light_switch.state {
+                    LightswitchState::On => Err(LightswitchError::AlreadyOn),
+                    LightswitchState::Off => {
+                        light_switch.state = LightswitchState::On;
+                        Ok(light_switch)
+                    },
+                },
+                LightswitchEvent::SwitchedOff(_) => match light_switch.state {
+                    LightswitchState::On => {
+                        light_switch.state = LightswitchState::Off;
+                        Ok(light_switch)
+                    },
+                    LightswitchState::Off => Err(LightswitchError::AlreadyOff),
+                },
+            },
+        }
+    }
+}
+
+// root
+#[derive(Debug, Clone)]
+pub struct LightswitchRoot(aggregate::Root<Lightswitch>);
+
+impl From<eventually::aggregate::Root<Lightswitch>> for LightswitchRoot {
+    fn from(root: eventually::aggregate::Root<Lightswitch>) -> Self {
+        Self(root)
+    }
+}
+impl From<LightswitchRoot> for eventually::aggregate::Root<Lightswitch> {
+    fn from(value: LightswitchRoot) -> Self {
+        value.0
+    }
+}
+impl std::ops::Deref for LightswitchRoot {
+    type Target = eventually::aggregate::Root<Lightswitch>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl std::ops::DerefMut for LightswitchRoot {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl LightswitchRoot {
+    pub fn install(id: LightswitchId) -> Result<Self, LightswitchError> {
+        aggregate::Root::<Lightswitch>::record_new(
+            LightswitchEvent::Installed(Installed { id }).into(),
+        )
+        .map(Self)
+    }
+    pub fn turn_on(&mut self, id: LightswitchId) -> Result<(), LightswitchError> {
+        if self.state == LightswitchState::On {
+            return Err(LightswitchError::AlreadyOn);
+        }
+
+        self.record_that(LightswitchEvent::SwitchedOn(SwitchedOn { id }).into())
+    }
+    pub fn turn_off(&mut self, id: LightswitchId) -> Result<(), LightswitchError> {
+        if self.state == LightswitchState::Off {
+            return Err(LightswitchError::AlreadyOff);
+        }
+
+        self.record_that(LightswitchEvent::SwitchedOff(SwitchedOff { id }).into())
+    }
+    pub fn get_switch_state(&self) -> Result<LightswitchState, LightswitchError> {
+        Ok(self.state.clone())
+    }
+}

examples/light-switch/src/main.rs

@@ -0,0 +1,47 @@
+mod application;
+mod commands;
+mod domain;
+mod queries;
+use application::{LightswitchRepo, LightswitchService};
+use commands::install_light_switch::InstallLightSwitch;
+use commands::turn_light_switch_off::TurnLightSwitchOff;
+use commands::turn_light_switch_on::TurnLightSwitchOn;
+use domain::{LightswitchEvent, LightswitchId};
+use eventually::{command, event, query};
+use queries::get_switch_state::GetSwitchState;
+
+#[tokio::main]
+async fn main() -> Result<(), anyhow::Error> {
+    let store = event::store::InMemory::<LightswitchId, LightswitchEvent>::default();
+    let repo = LightswitchRepo::from(store.clone());
+    let svc = LightswitchService::from(repo);
+
+    let cmd = InstallLightSwitch {
+        id: "Switch1".to_string(),
+    }
+    .into();
+    command::Handler::handle(&svc, cmd).await?;
+    println!("Installed Switch1");
+
+    let cmd = TurnLightSwitchOn {
+        id: "Switch1".to_string(),
+    }
+    .into();
+    command::Handler::handle(&svc, cmd).await?;
+    println!("Turned Switch1 On");
+
+    let cmd = TurnLightSwitchOff {
+        id: "Switch1".to_string(),
+    }
+    .into();
+    command::Handler::handle(&svc, cmd).await?;
+    println!("Turned Switch1 Off");
+
+    let query = GetSwitchState {
+        id: "Switch1".to_string(),
+    }
+    .into();
+    let state = query::Handler::handle(&svc, query).await?;
+    println!("Switch1 is currently: {:?}", state);
+    Ok(())
+}