Struct StepBuilder 

pub struct StepBuilder<D: WorkflowData> { /* private fields */ }

Builder for configuring a single step in the workflow.

Owns the WorkflowBuilder, consuming self on each method call. This avoids all lifetime/borrow issues.

Implementations

impl<D: WorkflowData> StepBuilder<D>

pub fn name(self, name: &str) -> Self

Set the human-readable display name of the current step.

This name appears in logs, the execution trace, and the web UI.

pub fn id(self, external_id: &str) -> Self

Set an external ID for forward references.

pub fn on_error(self, behavior: ErrorBehavior) -> Self

Set the error handling behavior for this step.

When a step returns Err from its run method, the executor checks this behavior to decide what to do next.

Example

.then::< risky::Step>()
    .name("Risky")
    .on_error(ErrorBehavior::Retry {
        interval: Duration::from_secs(5),
        max_retries: 3,
    })

pub fn config(self, config: Value) -> Self

Attach arbitrary JSON configuration to this step.

The step can read it at runtime via context.step.step_config.

pub fn compensate_with<C: StepBody + Default + 'static>(self) -> Self

Register a compensation step for saga rollback.

When this step fails inside a saga container, the executor runs the compensation steps in reverse order to undo partial work.

Example

.then::<ChargeCard>()
    .name("Charge")
    .compensate_with::<RefundCard>()

pub fn then<S: StepBody + Default + 'static>(self) -> StepBuilder<D>

Chain the next step sequentially.

Wires an outcome from the current step to the new one so that when the current step returns ExecutionResult::next, execution continues with S.

pub fn then_fn( self, f: impl Fn() -> ExecutionResult + Send + Sync + 'static, ) -> StepBuilder<D>

Chain an inline function step.

pub fn wait_for(self, event_name: &str, event_key: &str) -> StepBuilder<D>

Suspend the workflow until an external event arrives.

The workflow pauses and the executor releases the lock. When you call WorkflowHost::publish_event (from the wfe crate) with a matching event_name and event_key, the workflow resumes from this point.

Example

.then::<RequestApproval>()
    .name("Request Approval")
.wait_for("approval", "order-123")
    .name("Wait for approval")

pub fn delay(self, duration: Duration) -> StepBuilder<D>

Pause execution for a fixed duration.

The executor persists the workflow, sleeps for the given duration, then re-queues the instance for continued execution.

pub fn if_do<S: StepBody + Default + 'static>( self, build_children: impl FnOnce(&mut WorkflowBuilder<D>), ) -> StepBuilder<D>

Conditional branching.

The closure builds the child steps that run when the condition evaluates to true. Use .then::<ConditionStep>().if_do(|b| { ... }) where ConditionStep returns ExecutionResult::branch("true") or branch("false") to control which path is taken.

pub fn while_do<S: StepBody + Default + 'static>( self, build_children: impl FnOnce(&mut WorkflowBuilder<D>), ) -> StepBuilder<D>

Loop while a condition holds.

The closure builds the body of the loop. A condition step (type S) should return ExecutionResult::next() to continue looping or ExecutionResult::next() with a condition that evaluates to false to break out.

pub fn for_each<S: StepBody + Default + 'static>( self, build_children: impl FnOnce(&mut WorkflowBuilder<D>), ) -> StepBuilder<D>

Iterate over a collection.

The step type S receives each item via StepExecutionContext::item. The collection is taken from the workflow data field configured in the step’s step_config.

pub fn saga( self, build_children: impl FnOnce(&mut WorkflowBuilder<D>), ) -> StepBuilder<D>

Transaction-like container with compensation on failure.

Child steps run normally. If any child fails, the executor runs compensation steps (registered via compensate_with) in reverse order to undo partial work.

Example

.saga(|b| {
    b.add_step_typed::<ReserveInventory>("reserve", None);
    b.add_step_typed::<ChargeCard>("charge", None);
    b.add_step_typed::<ShipOrder>("ship", None);
})

pub fn parallel( self, build_branches: impl FnOnce(ParallelBuilder<D>) -> ParallelBuilder<D>, ) -> StepBuilder<D>

Run multiple branches concurrently.

All branches inside the [ParallelBuilder] execute in parallel. The workflow continues to the next step only after all branches complete.

pub fn end_workflow(self) -> WorkflowBuilder<D>

Finish building the current branch and return the WorkflowBuilder.

Call this when you are done chaining steps. You can then call WorkflowBuilder::build to compile the definition.

Example

let def = WorkflowBuilder::<MyData>::new()
    .start_with::<A>()
    .then::<B>()
    .end_workflow()
    .build("my-workflow", 1);

pub fn build(self, id: impl Into<String>, version: u32) -> WorkflowDefinition

Shortcut for end_workflow().build(id, version).