Struct SagaBuilder 

pub struct SagaBuilder<Input, Output, Ctx, Err, State> { /* private fields */ }

Type-state builder for constructing type-safe sagas.

The builder enforces at compile-time that:

• Each step’s input type matches the previous step’s output type
• The saga’s input type matches the first step’s input
• The saga’s output type matches the last step’s output

Compile-time Type Safety

The builder ensures type safety at compile time. Mismatched types will not compile:

use changeset_saga::{SagaBuilder, SagaStep};

struct StepA;
impl SagaStep for StepA {
    type Input = i32;
    type Output = String;  // Outputs String
    type Context = ();
    type Error = ();
    fn name(&self) -> &'static str { "a" }
    fn execute(&self, _: &(), input: i32) -> Result<String, ()> {
        Ok(input.to_string())
    }
}

struct StepB;
impl SagaStep for StepB {
    type Input = i32;  // Expects i32, not String!
    type Output = i32;
    type Context = ();
    type Error = ();
    fn name(&self) -> &'static str { "b" }
    fn execute(&self, _: &(), input: i32) -> Result<i32, ()> {
        Ok(input * 2)
    }
}

// This should fail: StepB expects i32 but StepA outputs String
let saga = SagaBuilder::new()
    .first_step(StepA)
    .then(StepB)  // Compile error here!
    .build();

An empty saga (without calling first_step()) cannot be built:

use changeset_saga::SagaBuilder;

// Cannot build an empty saga - `build()` is only available after `first_step()`
let saga = SagaBuilder::<(), (), (), ()>::new().build();

Implementations

impl<Ctx, Err> SagaBuilder<(), (), Ctx, Err, Empty>

pub fn new() -> Self

Create a new saga builder in the empty state.

pub fn first_step<S>( self, step: S, ) -> SagaBuilder<S::Input, S::Output, Ctx, Err, HasSteps<S::Output>>

where S: SagaStep<Context = Ctx, Error = Err> + 'static,

Add the first step to the saga.

This establishes the saga’s input type from the step’s input type.

impl<Input, CurrentOutput, Ctx, Err> SagaBuilder<Input, CurrentOutput, Ctx, Err, HasSteps<CurrentOutput>>

pub fn then<S>( self, step: S, ) -> SagaBuilder<Input, S::Output, Ctx, Err, HasSteps<S::Output>>

where S: SagaStep<Input = CurrentOutput, Context = Ctx, Error = Err> + 'static,

Add another step to the saga.

The step’s input type must match the current output type.

pub fn build(self) -> Saga<Input, CurrentOutput, Ctx, Err>

where Input: Clone + Send + 'static, CurrentOutput: Send + 'static, Err: Debug,

Build the saga from the accumulated steps.

Trait Implementations

impl<Ctx, Err> Default for SagaBuilder<(), (), Ctx, Err, Empty>

fn default() -> Self

Returns the “default value” for a type.