flags-rs 0.1.12

Rust Library for Flags.gg
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

#[cfg(feature = "tower-middleware")]
use flags_rs::{Auth, Client, middleware::{FlagsLayer, RequestExt}};
use http::{Request, Response, StatusCode};
use http_body_util::{BodyExt, Empty, Full};
use std::convert::Infallible;
use tower::{ServiceBuilder, ServiceExt};
use bytes::Bytes;

#[cfg(not(feature = "tower-middleware"))]
fn main() {
    eprintln!("This example requires the 'tower-middleware' feature. Run with:");
    eprintln!("cargo run --example tower_middleware --features tower-middleware");
}

#[cfg(feature = "tower-middleware")]
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let auth = Auth {
        project_id: std::env::var("FLAGS_PROJECT_ID").unwrap_or_else(|_| "test-project".to_string()),
        agent_id: std::env::var("FLAGS_AGENT_ID").unwrap_or_else(|_| "test-agent".to_string()),
        environment_id: std::env::var("FLAGS_ENVIRONMENT_ID").unwrap_or_else(|_| "development".to_string()),
    };

    let client = Client::builder()
        .with_auth(auth)
        .build()
        .map_err(|e| Box::new(e) as Box<dyn std::error::Error>)?;

    let flags_layer = FlagsLayer::new(client)
        .with_header_name("X-Feature-Flags");

    let service = ServiceBuilder::new()
        .layer(flags_layer)
        .service_fn(handle_request);

    let request = Request::builder()
        .uri("/")
        .header("X-Feature-Flags", "feature-1,feature-2,feature-3")
        .body(Empty::<Bytes>::new())?;

    let response = service.oneshot(request).await?;
    
    println!("Response status: {}", response.status());
    if let Some(enabled_flags) = response.headers().get("X-Enabled-Flags") {
        println!("Enabled flags: {:?}", enabled_flags);
    }

    let auth2 = Auth {
        project_id: std::env::var("FLAGS_PROJECT_ID").unwrap_or_else(|_| "test-project".to_string()),
        agent_id: std::env::var("FLAGS_AGENT_ID").unwrap_or_else(|_| "test-agent".to_string()),
        environment_id: std::env::var("FLAGS_ENVIRONMENT_ID").unwrap_or_else(|_| "development".to_string()),
    };
    
    let client2 = Client::builder()
        .with_auth(auth2)
        .build()
        .map_err(|e| Box::new(e) as Box<dyn std::error::Error>)?;
    
    let service = ServiceBuilder::new()
        .layer(FlagsLayer::new(client2))
        .service_fn(handle_request_with_flag_check);

    let request = Request::builder()
        .uri("/protected")
        .body(Empty::<Bytes>::new())?;

    let response = service.oneshot(request).await?;
    println!("\nProtected endpoint response: {}", response.status());
    
    let body_bytes = response.into_body().collect().await?.to_bytes();
    let body_str = String::from_utf8_lossy(&body_bytes);
    println!("Response body: {}", body_str);

    Ok(())
}

#[cfg(feature = "tower-middleware")]
async fn handle_request<B>(_req: Request<B>) -> Result<Response<Full<Bytes>>, Infallible> {
    Ok(Response::builder()
        .status(StatusCode::OK)
        .body(Full::new("Hello from the service!".into()))
        .expect("Failed to build response"))
}

#[cfg(feature = "tower-middleware")]
async fn handle_request_with_flag_check<B>(req: Request<B>) -> Result<Response<Full<Bytes>>, Infallible> {
    if let Some(client) = req.flags_client() {
        if client.is("premium-features").enabled().await {
            Ok(Response::builder()
                .status(StatusCode::OK)
                .body(Full::new("Premium features are enabled!".into()))
                .expect("Failed to build response"))
        } else {
            Ok(Response::builder()
                .status(StatusCode::FORBIDDEN)
                .body(Full::new("Premium features are not enabled".into()))
                .expect("Failed to build response"))
        }
    } else {
        Ok(Response::builder()
            .status(StatusCode::INTERNAL_SERVER_ERROR)
            .body(Full::new("Flags client not available".into()))
            .expect("Failed to build response"))
    }
}