Mistakes caught before a journey

//! Two steps of one workflow under the same name.

use itinera::error::Error;
use itinera::executor::local_executor_for;
use itinera::step::{Outcome, Step, step};
use itinera::workflow::workflow;

/// Charges an order.
#[derive(Step)]
struct Charge;

#[step]
impl Charge {
    fn run(self) -> Result<Outcome, Error> {
        Self::succeed()
    }
}

/// Ships an order through the carrier.
#[derive(Step)]
struct Ship;

#[step]
impl Ship {
    fn run(self) -> Result<Outcome, Error> {
        Self::succeed()
    }
}

/// The shop's workflow, with `ship` listed twice.
#[workflow(name = "orders")]
#[with_step(Charge, name = "charge")]
#[with_step(Ship, name = "ship")]
#[with_step(Ship, name = "ship", retry_budget = 1)]
struct Orders;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let result = local_executor_for!(Orders).run(Orders::builder().create()?)?;
    println!("the journey {}", result.status.kind());
    Ok(())
}

//! Two policies of one step that both define `on step success`.

use itinera::error::Error;
use itinera::executor::local_executor_for;
use itinera::journey::Contributor;
use itinera::policy::{OnSuccess, step_policy};
use itinera::step::{Outcome, Step, step};
use itinera::workflow::workflow;

/// Charges an order.
#[derive(Step)]
struct Charge;

#[step]
impl Charge {
    fn run(self, #[contributor] mut contributor: Contributor<'_>) -> Result<Outcome, Error> {
        contributor.contribute("charged", 40);
        Self::succeed()
    }
}

/// Audits every successful charge.
#[derive(Default)]
struct Audit;

#[step_policy(name = "audit")]
impl Audit {
    #[on_step_success]
    fn audited(&self, #[from_step] charged: i64) -> Result<Option<OnSuccess>, Error> {
        println!("audit: charged {charged}");
        Self::carry_on()
    }
}

/// Writes a receipt for every successful charge.
#[derive(Default)]
struct Receipts;

#[step_policy(name = "receipts")]
impl Receipts {
    #[on_step_success]
    fn written(&self, #[from_step] charged: i64) -> Result<Option<OnSuccess>, Error> {
        println!("receipt: R-{charged}");
        Self::carry_on()
    }
}

/// The shop's workflow, with both policies attached to the charge.
#[workflow(name = "orders")]
#[with_step(Charge, name = "charge", policies = [Audit, Receipts])]
struct Orders;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let result = local_executor_for!(Orders).run(Orders::builder().create()?)?;
    println!("the journey {}", result.status.kind());
    Ok(())
}

//! A policy that needs a role the workflow does not provide.

use itinera::error::Error;
use itinera::executor::local_executor_for;
use itinera::policy::workflow_policy;
use itinera::step::{Outcome, Step, step};
use itinera::workflow::workflow;

/// Charges an order.
#[derive(Step)]
struct Charge;

#[step]
impl Charge {
    fn run(self) -> Result<Outcome, Error> {
        Self::succeed()
    }
}

/// The shop's way of telling a customer something.
trait Messages {
    fn tell(&self, customer: &str, message: &str);
}

/// Tells the customer once the order is complete.
#[derive(Default)]
struct Notify;

#[workflow_policy(name = "notify")]
impl Notify {
    #[on_workflow_success]
    fn completed(
        &self,
        #[from_workflow] customer: String,
        #[role] messages: &dyn Messages,
    ) -> Result<(), Error> {
        messages.tell(&customer, "your order is complete");
        Ok(())
    }
}

/// The shop's workflow. It can tell a customer something, but does not provide it as a role.
#[workflow(name = "orders", policies = [Notify])]
#[with_step(Charge, name = "charge")]
struct Orders;

impl Messages for Orders {
    fn tell(&self, customer: &str, message: &str) {
        println!("to {customer}: {message}");
    }
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let result = local_executor_for!(Orders).run(Orders::builder().create()?)?;
    println!("the journey {}", result.status.kind());
    Ok(())
}

//! A hook that returns a lifecycle it may not return: finishing the journey after a failure.

use itinera::error::Error;
use itinera::executor::local_executor_for;
use itinera::policy::{FailWorkflow, step_policy};
use itinera::step::{Outcome, Step, step};
use itinera::workflow::workflow;

/// Charges an order, and fails when there is nothing to charge.
#[derive(Step)]
struct Charge;

#[step]
impl Charge {
    fn run(self) -> Result<Outcome, Error> {
        Self::fail("nothing-to-charge")
    }
}

/// Tries to end the journey as succeeded when the charge fails.
#[derive(Default)]
struct Forgive;

#[step_policy(name = "forgive")]
impl Forgive {
    #[on_step_failure]
    fn forgiven(&self) -> Result<Option<FailWorkflow>, Error> {
        Self::finish_workflow()
    }
}

/// The shop's workflow.
#[workflow(name = "orders")]
#[with_step(Charge, name = "charge", policies = [Forgive])]
struct Orders;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let result = local_executor_for!(Orders).run(Orders::builder().create()?)?;
    println!("the journey {}", result.status.kind());
    Ok(())
}

//! A step that contributes something that is not a value: its connection to the bank.

use itinera::error::Error;
use itinera::executor::local_executor_for;
use itinera::journey::Contributor;
use itinera::step::{Outcome, Step, step};
use itinera::workflow::workflow;

/// A connection to the customer's bank, faked.
struct BankConnection {
    bank: &'static str,
}

/// Charges an order, and hands its bank connection on.
#[derive(Step)]
struct Charge;

#[step]
impl Charge {
    fn run(self, #[contributor] mut contributor: Contributor<'_>) -> Result<Outcome, Error> {
        let connection = BankConnection {
            bank: "the customer's bank",
        };
        contributor.contribute("bank", connection);
        Self::succeed()
    }
}

/// The shop's workflow.
#[workflow(name = "orders")]
#[with_step(Charge, name = "charge")]
struct Orders;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let result = local_executor_for!(Orders).run(Orders::builder().create()?)?;
    println!("the journey {}", result.status.kind());
    Ok(())
}

//! An asynchronous workflow whose journey is run without awaiting it.

use itinera::error::Error;
use itinera::executor::local_executor_for;
use itinera::step::{Outcome, Step, step};
use itinera::workflow::workflow;

/// Charges an order, asynchronously.
#[derive(Step)]
struct Charge;

#[step]
impl Charge {
    async fn run(self) -> Result<Outcome, Error> {
        Self::succeed()
    }
}

/// The shop's workflow, asynchronous because its steps are.
#[workflow(name = "orders")]
#[with_step(Charge, name = "charge")]
struct Orders;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let result = local_executor_for!(Orders).run(Orders::builder().create()?)?;
    println!("the journey {}", result.status.kind());
    Ok(())
}