Resilience — `nestrs-resilience`

[dependencies]
nestrs = { version = "1.7.1", features = ["resilience"] }
# or:
nestrs-resilience = "1.7.1"

use nestrs::prelude::*;
use nestrs::resilience::{ResilienceModule, ResilienceOptions};

#[module(
    imports = [ResilienceModule::register(ResilienceOptions::default())],
    providers = [PaymentsService],
)]
struct AppModule;

use nestrs::resilience::{
    PolicyBundle, ResilienceError, ResilienceService, RetryPolicy, TimeoutPolicy,
};
use std::sync::Arc;
use std::time::Duration;

async fn charge(svc: Arc<ResilienceService>) -> Result<u64, ResilienceError> {
    let policy = PolicyBundle {
        retry: Some(RetryPolicy {
            attempts: 4,
            delay: Duration::from_millis(50),
            factor: 2.0,
            max_delay: Duration::from_secs(2),
            jitter: true, // default on RetryPolicy::default() — keep it for production
        }),
        timeout: Some(TimeoutPolicy {
            timeout: Duration::from_secs(3),
        }),
        circuit_name: Some("payments".into()),
        ..Default::default()
    };

    svc.execute("payments.charge", policy, || async {
        // call downstream; map transport errors to ResilienceError::Other(...)
        Ok(42u64)
    })
    .await
}

use nestrs::prelude::*;
use nestrs::resilience::ResilienceError;

fn map_resilience(err: ResilienceError) -> HttpException {
    match err {
        ResilienceError::Timeout => {
            GatewayTimeoutException::new("upstream timed out").with_error_code("UPSTREAM_TIMEOUT")
        }
        ResilienceError::CircuitOpen { retry_after_secs } => ServiceUnavailableException::new(
            format!("circuit open; retry after {retry_after_secs}s"),
        )
        .with_error_code("CIRCUIT_OPEN"),
        other => InternalServerErrorException::new(other.to_string()),
    }
}