Dive deeper into ObzenFlow’s vocabulary.

// flow.rs — the stage names the effect boundary.
authorize_payment = effectful_transform!(
    ValidatedOrder -> {
        PaymentAuthorized,
        PaymentDeclined,
        CancelledOrder,
        PaymentAuthorizationUnavailable
    }
    uses AuthorizePayment
        with gateway_resilience
    => gateway_transform,
    observers: [/* observation only */]
);

// gateway.rs — the handler returns the call as a value.
let outcome = fx
    .perform(AuthorizePayment { order: order.clone() })
    .await;

// PaymentAuthorized or PaymentDeclined is already
// journaled; outcome is matched only for consequences.

// stripe_gateway.rs — execute is where the flow touches the world.
#[async_trait]
impl Effect for AuthorizePayment {
    const SAFETY: EffectSafety =
        EffectSafety::NonIdempotentRequiresKey;

    type Outcome = AuthorizePaymentOutcome;

    async fn execute(&self, ctx: &mut EffectContext)
        -> Result<Self::Outcome, EffectError>
    {
        // One real POST to Stripe. The effect's key rides
        // the Idempotency-Key header, so a crash-and-retry
        // can never become a second authorization.
        let intent = self.stripe
            .create_payment_intent(CreatePaymentIntent {
                amount: self.order.amount_cents,
                currency: Currency::Usd,
                payment_method: self.order.payment_method.clone(),
                capture_method: CaptureMethod::Manual,
                confirm: true,
            })
            .idempotency_key(self.idempotency_key())
            .await?;

        match intent.status {
            PaymentIntentStatus::RequiresCapture =>
                Ok(Authorized(/* PaymentAuthorized fact */)),
            _ => Ok(Declined(/* PaymentDeclined fact */)),
        }
    }

    fn idempotency_key(&self) -> Option<IdempotencyKey> {
        Some(IdempotencyKey(format!(
            "payment-authorize:{}", self.order.order_id
        )))
    }
}