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
91
92
93
94
95
96
97
98
99
100

use async_trait::async_trait;
use serde::{Deserialize, Serialize};
use serde_json;
use std::sync::Arc;

use crate::core::{TaskState, WorkflowEngine, WorkflowResult, WorkflowState};

/// API request for creating a workflow
#[derive(Debug, Deserialize)]
pub struct CreateWorkflowRequest {
    pub workflow_type: String,
    pub data: serde_json::Value,
}

/// API request for completing a task
#[derive(Debug, Deserialize)]
pub struct CompleteTaskRequest {
    pub data: serde_json::Value,
}

/// API response
#[derive(Debug, Serialize)]
pub struct ApiResponse<T> {
    pub success: bool,
    pub data: Option<T>,
    pub error: Option<String>,
}

impl<T> ApiResponse<T> {
    pub fn success(data: T) -> Self {
        Self {
            success: true,
            data: Some(data),
            error: None,
        }
    }

    pub fn error(message: String) -> Self {
        Self {
            success: false,
            data: None,
            error: Some(message),
        }
    }
}

/// Workflow API trait
#[async_trait]
pub trait WorkflowApi: Send + Sync {
    async fn create_workflow(&self, req: CreateWorkflowRequest) -> WorkflowResult<WorkflowState>;
    async fn get_workflow(&self, workflow_id: &str) -> WorkflowResult<WorkflowState>;
    async fn get_tasks(&self, workflow_id: &str) -> WorkflowResult<Vec<TaskState>>;
    async fn complete_task(
        &self,
        task_id: &str,
        req: CompleteTaskRequest,
    ) -> WorkflowResult<TaskState>;
}

/// Default API implementation
pub struct DefaultWorkflowApi {
    engine: Arc<dyn WorkflowEngine>,
}

impl DefaultWorkflowApi {
    pub fn new(engine: Arc<dyn WorkflowEngine>) -> Self {
        Self { engine }
    }
}

#[async_trait]
impl WorkflowApi for DefaultWorkflowApi {
    async fn create_workflow(&self, req: CreateWorkflowRequest) -> WorkflowResult<WorkflowState> {
        self.engine
            .create_workflow(&req.workflow_type, req.data)
            .await
    }

    async fn get_workflow(&self, workflow_id: &str) -> WorkflowResult<WorkflowState> {
        self.engine.get_workflow(workflow_id).await
    }

    async fn get_tasks(&self, workflow_id: &str) -> WorkflowResult<Vec<TaskState>> {
        self.engine.get_tasks(workflow_id).await
    }

    async fn complete_task(
        &self,
        task_id: &str,
        req: CompleteTaskRequest,
    ) -> WorkflowResult<TaskState> {
        self.engine.complete_task(task_id, req.data).await
    }
}

#[cfg(feature = "axum")]
pub mod axum;

#[cfg(feature = "actix")]
pub mod actix;