rust-viewflow 0.1.0

Rust workflow library inspired by Viewflow, compatible with Axum and Actix-web
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

use std::collections::HashMap;
use std::sync::RwLock;

use crate::core::{TaskState, WorkflowResult, WorkflowState};
use crate::db::WorkflowDatabase;

pub struct MemoryDatabase {
    workflows: RwLock<HashMap<String, WorkflowState>>,
    tasks: RwLock<HashMap<String, TaskState>>,
}

impl Default for MemoryDatabase {
    fn default() -> Self {
        Self::new()
    }
}

impl MemoryDatabase {
    pub fn new() -> Self {
        Self {
            workflows: RwLock::new(HashMap::new()),
            tasks: RwLock::new(HashMap::new()),
        }
    }
}

#[async_trait::async_trait]
impl WorkflowDatabase for MemoryDatabase {
    async fn create_workflow(&self, workflow: &WorkflowState) -> WorkflowResult<()> {
        self.workflows
            .write()
            .expect("memory workflow lock poisoned")
            .insert(workflow.id.clone(), workflow.clone());
        Ok(())
    }

    async fn get_workflow(&self, workflow_id: &str) -> WorkflowResult<WorkflowState> {
        self.workflows
            .read()
            .expect("memory workflow lock poisoned")
            .get(workflow_id)
            .cloned()
            .ok_or_else(|| format!("Workflow '{}' not found", workflow_id).into())
    }

    async fn update_workflow(&self, workflow: &WorkflowState) -> WorkflowResult<()> {
        self.workflows
            .write()
            .expect("memory workflow lock poisoned")
            .insert(workflow.id.clone(), workflow.clone());
        Ok(())
    }

    async fn create_task(&self, task: &TaskState) -> WorkflowResult<()> {
        self.tasks
            .write()
            .expect("memory task lock poisoned")
            .insert(task.id.clone(), task.clone());
        Ok(())
    }

    async fn get_task(&self, task_id: &str) -> WorkflowResult<TaskState> {
        self.tasks
            .read()
            .expect("memory task lock poisoned")
            .get(task_id)
            .cloned()
            .ok_or_else(|| format!("Task '{}' not found", task_id).into())
    }

    async fn update_task(&self, task: &TaskState) -> WorkflowResult<()> {
        self.tasks
            .write()
            .expect("memory task lock poisoned")
            .insert(task.id.clone(), task.clone());
        Ok(())
    }

    async fn get_tasks_by_workflow(&self, workflow_id: &str) -> WorkflowResult<Vec<TaskState>> {
        let tasks = self
            .tasks
            .read()
            .expect("memory task lock poisoned")
            .values()
            .filter(|task| task.workflow_id == workflow_id)
            .cloned()
            .collect();
        Ok(tasks)
    }
}