flowstate 0.8.2

Workflow runtime powered by finite state machines.
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
93
94
95
96

use std::any::type_name;

use flowstate::{AsyncWorkflow, AsyncWorkflowState, prelude::*};

struct BasicWorkflow<State> {
    _state: State,
}

impl BasicWorkflow<StateA> {
    fn init() -> Self {
        Self { _state: StateA }
    }
}

impl<State: flowstate::AsyncState> AsyncWorkflow for BasicWorkflow<State> {
    fn workflow_name(&self) -> String {
        type_name::<Self>().to_string()
    }

    fn state(&self) -> &dyn flowstate::AsyncState {
        &self._state
    }
}

#[async_state]
trait BasicWorkflowState: AsyncWorkflow {
    fn state_name(&self) -> String {
        self.state().name()
    }

    async fn next(self: Box<Self>) -> AsyncTransition<'static, WorkflowResult>;
}

#[async_state]
impl<State> AsyncWorkflowState<'static, WorkflowResult> for BasicWorkflow<State>
where
    State: flowstate::AsyncState + Send,
    BasicWorkflow<State>: BasicWorkflowState,
{
    fn name(&self) -> String {
        self.state_name()
    }

    async fn next(self: Box<Self>) -> AsyncTransition<'static, WorkflowResult> {
        BasicWorkflowState::next(self).await
    }
}

impl<State> BasicWorkflow<State> {
    fn transition<NewState>(self, next_state: NewState) -> AsyncTransition<'static, WorkflowResult>
    where
        BasicWorkflow<NewState>: AsyncWorkflowState<'static, WorkflowResult> + 'static,
    {
        AsyncTransition::Continue(Box::new(BasicWorkflow { _state: next_state }))
    }
}

struct StateA;

impl AsyncState for StateA {
    fn name(&self) -> String {
        type_name::<StateA>().to_string()
    }
}

#[async_state]
impl BasicWorkflowState for BasicWorkflow<StateA> {
    async fn next(self: Box<Self>) -> AsyncTransition<'static, WorkflowResult> {
        self.transition(StateB)
    }
}

struct StateB;

impl AsyncState for StateB {
    fn name(&self) -> String {
        type_name::<StateB>().to_string()
    }
}

#[async_state]
impl BasicWorkflowState for BasicWorkflow<StateB> {
    async fn next(self: Box<Self>) -> AsyncTransition<'static, WorkflowResult> {
        self.finish(WorkflowResult)
    }
}

#[derive(Debug, PartialEq)]
struct WorkflowResult;

#[tokio::test]
async fn test_basic_workflow_manual_impls_async() {
    let workflow = BasicWorkflow::init();
    let result = workflow.run().await;
    assert_eq!(result, WorkflowResult);
}