Struct StepRunner 

pub struct StepRunner<'a, T>
where
    T: Serialize + DeserializeOwned + Clone + Send + Sync + 'static,
{ /* private fields */ }

A fluent builder for executing workflow steps.

Created via WorkflowContext::step().

Implementations

impl<'a, T> StepRunner<'a, T>

where T: Serialize + DeserializeOwned + Clone + Send + Sync + 'static,

pub fn compensate<F, Fut>(self, f: F) -> Self

where F: Fn(T) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<()>> + Send + 'static,

Set a compensation function (rollback handler).

If a later step fails, this compensation function will be called with the step’s result to undo its effects (saga pattern).

ctx.step("charge_card", || async { charge(&card).await })
    .compensate(|charge_result| async move {
        refund(&charge_result.charge_id).await
    })
    .run()
    .await?;

pub fn timeout(self, duration: Duration) -> Self

Set a timeout for this step.

ctx.step("slow_operation", || async { slow_op().await })
    .timeout(Duration::from_secs(30))
    .run()
    .await?;

pub fn retry(self, count: u32, delay: Duration) -> Self

Configure retry behavior for this step.

If the step fails, it will be retried up to count times with a fixed delay between attempts. The step succeeds if any attempt succeeds.

ctx.step("call_flaky_api", || async { external_api_call().await })
    .retry(3, Duration::from_secs(5))  // 3 retries, 5 second delay
    .run()
    .await?;

pub fn optional(self) -> Self

Mark step as optional.

If an optional step fails, the workflow continues without triggering compensation of previous steps. The step returns Ok(None) on failure instead of propagating the error.

let result = ctx.step("send_notification", || async { notify_slack().await })
    .optional()
    .run()
    .await?; // Returns Ok(None) if notification fails

if let Some(notification_id) = result {
    println!("Notification sent: {}", notification_id);
}

pub async fn run(self) -> Result<Option<T>>

Execute the step.

This runs the step with configured timeout, retry, and compensation settings. Returns Ok(Some(result)) on success. For optional steps, returns Ok(None) on failure instead of propagating the error.