move rhailib to herolib

rhailib/src/flow/README.md

@@ -0,0 +1,110 @@
+# Flow Manager
+
+A simple, generic flow manager for Rhai scripts with builder pattern API and non-blocking execution.
+
+## Features
+
+- **Builder Pattern API**: Fluent interface for creating steps and flows
+- **Non-blocking Execution**: Uses `tokio::spawn` for async step execution
+- **Simple State Management**: Redis-based state tracking
+- **Retry Logic**: Configurable timeouts and retry attempts
+- **Mock API Support**: Built-in mock API for testing different scenarios
+- **RhaiDispatcher Integration**: Seamless integration with existing Rhai execution system
+
+## Quick Start
+
+```rust
+use flow::{new_step, new_flow, FlowExecutor};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Create executor
+    let executor = FlowExecutor::new("redis://127.0.0.1/").await?;
+
+    // Build steps using fluent API
+    let step1 = new_step("stripe_config")
+        .script("stripe_config_script")
+        .timeout(5)
+        .retries(2)
+        .build();
+
+    let step2 = new_step("stripe_config_confirm")
+        .script("script that looks up stripe config confirmation in db")
+        .timeout(5)
+        .build();
+
+    let step3 = new_step("create_product")
+        .script("create_product_script")
+        .timeout(10)
+        .retries(1)
+        .build();
+
+    // Build flow using fluent API
+    let flow = new_flow("stripe_payment_request")
+        .add_step(step1)
+        .add_step(step2)
+        .add_step(step3)
+        .build();
+
+    // Execute flow (non-blocking)
+    let result = executor.execute_flow(flow).await?;
+    println!("Flow started: {}", result);
+
+    Ok(())
+}
+```
+
+## Architecture
+
+### Core Components
+
+- **Types** (`types.rs`): Core data structures (Flow, Step, Status enums)
+- **Builder** (`builder.rs`): Fluent API for constructing flows and steps
+- **State** (`state.rs`): Simple Redis-based state management
+- **Executor** (`executor.rs`): Non-blocking flow execution engine
+- **Mock API** (`mock_api.rs`): Testing utilities for different response scenarios
+
+### State Management
+
+The system tracks minimal state:
+
+**Flow State:**
+- `flow_id: String` - unique identifier
+- `status: FlowStatus` (Created, Running, Completed, Failed)
+- `current_step: Option<String>` - currently executing step
+- `completed_steps: Vec<String>` - list of finished steps
+
+**Step State:**
+- `step_id: String` - unique identifier  
+- `status: StepStatus` (Pending, Running, Completed, Failed)
+- `attempt_count: u32` - for retry logic
+- `output: Option<String>` - result from script execution
+
+**Storage:**
+- Redis key-value pairs: `flow:{flow_id}` and `step:{flow_id}:{step_id}`
+
+## Examples
+
+Run the example:
+
+```bash
+cd ../rhailib/src/flow
+cargo run --example stripe_flow_example
+```
+
+## Testing
+
+```bash
+cargo test
+```
+
+Note: Some tests require Redis to be running. Set `SKIP_REDIS_TESTS=1` to skip Redis-dependent tests.
+
+## Integration
+
+The flow manager integrates with:
+- **RhaiDispatcher**: For executing Rhai scripts
+- **Redis**: For state persistence
+- **tokio**: For non-blocking async execution
+
+This provides a simple, reliable foundation for orchestrating complex workflows while maintaining the non-blocking execution pattern established in the payment system.