blooio 0.1.0

Typed, low-overhead Rust client for the Blooio API (iMessage/SMS automation), with sync and async surfaces.
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

//! Response parsing shared by both executors.

use serde::de::DeserializeOwned;

use crate::error::{ApiErrorBody, Error, Result};

/// Parse a raw HTTP response into the operation's output type, or map a non-2xx
/// status to [`Error::Api`].
///
/// On success the body is deserialized into `T`. On failure the body is decoded
/// from the Blooio `Error` schema; if that fails, the raw (truncated) body text
/// is used as the message so the caller still gets something actionable. The
/// raw body is never logged here — only the status and machine `code` are safe
/// to log, which the executors do.
pub fn parse<T: DeserializeOwned>(status: u16, bytes: &[u8]) -> Result<T> {
    if (200..300).contains(&status) {
        // A handful of 2xx responses may legitimately carry an empty body.
        // `serde_json` can deserialize `()` and `Option<_>` from "null", but
        // not from "", so normalize an empty body to `null`.
        let bytes: &[u8] = if bytes.is_empty() { b"null" } else { bytes };
        serde_json::from_slice(bytes).map_err(Error::decode)
    } else {
        Err(map_error(status, bytes))
    }
}

/// Map a non-2xx response body to [`Error::Api`].
pub fn map_error(status: u16, bytes: &[u8]) -> Error {
    if let Ok(body) = serde_json::from_slice::<ApiErrorBody>(bytes) {
        Error::Api {
            status,
            code: body.code,
            message: body
                .message
                .or(body.error.clone())
                .unwrap_or_else(|| format!("HTTP {status}")),
            error: body.error,
        }
    } else {
        // Body wasn't the documented error schema. Fall back to the raw
        // text, truncated to keep the message bounded.
        let raw = String::from_utf8_lossy(bytes);
        let message = if raw.trim().is_empty() {
            format!("HTTP {status}")
        } else {
            raw.chars().take(512).collect()
        };
        Error::Api {
            status,
            code: None,
            message,
            error: None,
        }
    }
}

#[cfg(test)]
#[allow(
    clippy::unwrap_used,
    clippy::expect_used,
    clippy::panic,
    clippy::print_stdout,
    clippy::unreadable_literal
)]
mod tests {
    use super::*;
    use serde::Deserialize;

    #[derive(Debug, Deserialize, PartialEq)]
    struct Thing {
        id: String,
    }

    #[test]
    fn parses_success_body() {
        let t: Thing = parse(200, br#"{"id":"abc"}"#).unwrap();
        assert_eq!(t, Thing { id: "abc".into() });
    }

    #[test]
    fn maps_error_schema() {
        let body = br#"{"error":"rate_limited","message":"slow down","status":429,"code":"outbound_limit_reached"}"#;
        let err = parse::<Thing>(429, body).unwrap_err();
        match err {
            Error::Api {
                status,
                code,
                message,
                error,
            } => {
                assert_eq!(status, 429);
                assert_eq!(code.as_deref(), Some("outbound_limit_reached"));
                assert_eq!(message, "slow down");
                assert_eq!(error.as_deref(), Some("rate_limited"));
            }
            other => panic!("expected Api error, got {other:?}"),
        }
    }

    #[test]
    fn maps_non_schema_error_body() {
        let err = parse::<Thing>(500, b"upstream exploded").unwrap_err();
        assert_eq!(err.status(), Some(500));
        assert_eq!(err.code(), None);
    }
}