flowfull 0.1.0

Async Rust client for Flowfull and Flowless-compatible backends
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

use std::{sync::Arc, time::Duration};

use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
use url::Url;

use crate::{FlowfullError, error::Result, storage::Storage};

pub type SessionProvider = Arc<
    dyn Fn() -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<Option<String>>> + Send>>
        + Send
        + Sync,
>;

#[derive(Clone)]
pub struct ClientConfig {
    pub base_url: Url,
    pub session_id: Option<String>,
    pub session_provider: Option<SessionProvider>,
    pub include_session: bool,
    pub session_header: HeaderName,
    pub session_cookie: String,
    pub timeout: Duration,
    pub headers: HeaderMap,
    pub retry: RetryConfig,
    pub storage: Option<Arc<dyn Storage>>,
}

#[derive(Debug, Clone)]
pub struct RetryConfig {
    pub attempts: usize,
    pub delay: Duration,
    pub exponential: bool,
    pub max_delay: Option<Duration>,
    pub retry_statuses: Vec<u16>,
    pub retry_non_idempotent: bool,
}

impl Default for RetryConfig {
    fn default() -> Self {
        Self {
            attempts: 1,
            delay: Duration::from_secs(1),
            exponential: false,
            max_delay: Some(Duration::from_secs(30)),
            retry_statuses: vec![408, 429, 500, 502, 503, 504],
            retry_non_idempotent: false,
        }
    }
}

impl RetryConfig {
    pub fn exponential(attempts: usize, delay: Duration) -> Self {
        Self {
            attempts: attempts.max(1),
            delay,
            exponential: true,
            ..Self::default()
        }
    }
}

pub struct ClientConfigBuilder {
    base_url: Url,
    session_id: Option<String>,
    session_provider: Option<SessionProvider>,
    include_session: bool,
    session_header: HeaderName,
    session_cookie: String,
    timeout: Duration,
    headers: HeaderMap,
    retry: RetryConfig,
    storage: Option<Arc<dyn Storage>>,
}

impl ClientConfigBuilder {
    pub fn new(base_url: impl AsRef<str>) -> Result<Self> {
        let mut base_url = Url::parse(base_url.as_ref())?;
        if !base_url.path().ends_with('/') {
            let path = format!("{}/", base_url.path());
            base_url.set_path(&path);
        }

        Ok(Self {
            base_url,
            session_id: None,
            session_provider: None,
            include_session: false,
            session_header: HeaderName::from_static("x-session-id"),
            session_cookie: "session_id".to_string(),
            timeout: Duration::from_secs(30),
            headers: HeaderMap::new(),
            retry: RetryConfig::default(),
            storage: None,
        })
    }

    pub fn session_id(mut self, session_id: impl Into<String>) -> Self {
        self.session_id = Some(session_id.into());
        self
    }

    pub fn session_provider<F, Fut>(mut self, provider: F) -> Self
    where
        F: Fn() -> Fut + Send + Sync + 'static,
        Fut: std::future::Future<Output = Result<Option<String>>> + Send + 'static,
    {
        self.session_provider = Some(Arc::new(move || Box::pin(provider())));
        self
    }

    pub fn include_session(mut self, include_session: bool) -> Self {
        self.include_session = include_session;
        self
    }

    pub fn session_header(mut self, header: impl AsRef<str>) -> Result<Self> {
        self.session_header = HeaderName::from_bytes(header.as_ref().as_bytes())
            .map_err(|err| FlowfullError::Config(format!("invalid session header: {err}")))?;
        Ok(self)
    }

    pub fn session_cookie(mut self, cookie: impl Into<String>) -> Self {
        self.session_cookie = cookie.into();
        self
    }

    pub fn timeout(mut self, timeout: Duration) -> Self {
        self.timeout = timeout;
        self
    }

    pub fn header(mut self, key: impl AsRef<str>, value: impl AsRef<str>) -> Result<Self> {
        let key = HeaderName::from_bytes(key.as_ref().as_bytes())
            .map_err(|err| FlowfullError::Config(format!("invalid header name: {err}")))?;
        let value = HeaderValue::from_str(value.as_ref())
            .map_err(|err| FlowfullError::Config(format!("invalid header value: {err}")))?;
        self.headers.insert(key, value);
        Ok(self)
    }

    pub fn headers(mut self, headers: HeaderMap) -> Self {
        self.headers = headers;
        self
    }

    pub fn retry(mut self, retry: RetryConfig) -> Self {
        self.retry = retry;
        self
    }

    pub fn storage<S>(mut self, storage: S) -> Self
    where
        S: Storage + 'static,
    {
        self.storage = Some(Arc::new(storage));
        self
    }

    pub fn shared_storage(mut self, storage: Arc<dyn Storage>) -> Self {
        self.storage = Some(storage);
        self
    }

    pub fn build(self) -> Result<ClientConfig> {
        Ok(ClientConfig {
            base_url: self.base_url,
            session_id: self.session_id,
            session_provider: self.session_provider,
            include_session: self.include_session,
            session_header: self.session_header,
            session_cookie: self.session_cookie,
            timeout: self.timeout,
            headers: self.headers,
            retry: self.retry,
            storage: self.storage,
        })
    }
}