actflow 0.1.6

A lightweight, event-driven workflow engine written in Rust.
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

//! # Actflow
//!
//! Actflow is a lightweight, event-driven workflow engine written in Rust.
//! It is designed to be embedded in applications to orchestrate complex business logic.
//!
//! ## Core Features
//!
//! - **Event-Driven Architecture**: Built on a robust event bus for high decoupling and scalability
//! - **Async Execution**: Powered by `tokio` for high-concurrency workflow execution
//! - **Pluggable Storage**: Supports in-memory storage (testing) and PostgreSQL (production)
//! - **Flexible Workflow Definition**: Define workflows using JSON with various node types
//!
//! ## Quick Start
//!
//! ```rust,ignore
//! use actflow::{EngineBuilder, WorkflowModel};
//!
//! let engine = EngineBuilder::new().build().unwrap();
//! engine.launch();
//!
//! // Deploy and run workflow
//! let workflow = WorkflowModel::from_json(json_str)?;
//! engine.deploy(&workflow)?;
//! let process = engine.build_process(&workflow.id)?;
//! engine.run_process(process)?;
//! ```

mod builder;
mod common;
mod dispatcher;
mod engine;
mod error;
mod events;
mod model;
mod runtime;
mod utils;
mod workflow;

use std::sync::{Arc, RwLock};

pub use builder::EngineBuilder;
pub use engine::Engine;
pub use error::ActflowError;
pub use events::*;
pub use model::*;
pub use runtime::{ChannelEvent, ChannelOptions};

/// Result type alias for Actflow operations.
pub type Result<T> = std::result::Result<T, ActflowError>;

/// Thread-safe shared lock wrapper using Arc<RwLock<T>>.
pub(crate) type ShareLock<T> = Arc<RwLock<T>>;