umari 0.3.0

SDK for building event-sourced WASM components for the Umari runtime
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

#![allow(clippy::too_many_arguments)]

use std::marker::PhantomData;

use schemars::JsonSchema;
use serde::de::DeserializeOwned;

pub use self::umari::command::types::*;

wit_bindgen::generate!({
    world: "command",
    path: "wit/command",
    additional_derives: [PartialEq, Clone, serde::Serialize, serde::Deserialize],
    generate_unused_types: true,
    pub_export_macro: true,
    with: {
        "umari:common/types@0.1.0": crate::runtime::common,
    },
});

pub struct CommandExport<T>(PhantomData<T>);

pub trait ExportedCommand {
    type Input: DeserializeOwned + JsonSchema;

    fn execute(
        input: Self::Input,
        context: crate::command::CommandContext,
    ) -> anyhow::Result<ExecuteOutput>;
}

impl<T> Guest for CommandExport<T>
where
    T: ExportedCommand,
{
    fn schema() -> Option<Json> {
        let schema = schemars::schema_for!(T::Input);
        Some(serde_json::to_string(&schema).unwrap_or_else(|_| panic!("invalid json schema")))
    }

    fn execute(input: Json, context: CommandContext) -> Result<ExecuteOutput, Error> {
        let input: T::Input =
            serde_json::from_str(&input).map_err(|err| Error::InvalidInput(err.to_string()))?;

        let context = crate::command::CommandContext {
            correlation_id: uuid::Uuid::parse_str(&context.correlation_id).unwrap(),
            causation_id: uuid::Uuid::parse_str(&context.causation_id).unwrap(),
            triggering_event_id: context
                .triggering_event_id
                .as_deref()
                .map(|id| uuid::Uuid::parse_str(id).unwrap()),
            idempotency_key: context
                .idempotency_key
                .as_deref()
                .map(|id| uuid::Uuid::parse_str(id).unwrap()),
        };

        T::execute(input, context).map_err(|err| Error::Rejected(err.to_string()))
    }
}

impl From<crate::command::ExecuteOutput> for ExecuteOutput {
    fn from(output: crate::command::ExecuteOutput) -> Self {
        ExecuteOutput {
            position: output.position,
            events: output
                .events
                .into_iter()
                .map(|event| EmittedEvent {
                    id: event.id.to_string(),
                    event_type: event.event_type,
                    domain_ids: event
                        .domain_ids
                        .into_iter()
                        .map(|(name, id)| DomainId { name, id })
                        .collect(),
                })
                .collect(),
        }
    }
}

impl From<crate::command::CommandContext> for CommandContext {
    fn from(ctx: crate::command::CommandContext) -> Self {
        CommandContext {
            correlation_id: ctx.correlation_id.to_string(),
            causation_id: ctx.causation_id.to_string(),
            triggering_event_id: ctx.triggering_event_id.as_ref().map(ToString::to_string),
            idempotency_key: ctx.idempotency_key.as_ref().map(ToString::to_string),
        }
    }
}