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 optional(self) -> Self

Mark step as optional.

If an optional step fails, the workflow continues without triggering compensation of previous steps.

ctx.step("send_notification", || async { notify_slack().await })
    .optional()
    .run()
    .await?; // Won't fail workflow if notification fails

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

Execute the step.

This runs the step with configured timeout and compensation settings. Returns the step result or an error.

Note: For retry support with the fluent API, consider using a retryable wrapper inside your step function, or use the low-level API with manual retry logic.