suparust 0.2.3

Supabase client for Rust with support for WASM
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

pub mod object;

use crate::Supabase;

impl Supabase {
    /// Gives you an authenticated [`Storage`] client meant for making one storage request. For multiple
    /// requests, call this function each time.
    ///
    /// This interface is modeled after the definitions [here](https://supabase.github.io/storage/),
    /// but is not yet complete.
    pub async fn storage(&self) -> crate::Result<Storage> {
        let url_base = format!("{}/storage/v1", self.url_base);

        self.refresh_login().await?;

        let access_token = self
            .session
            .read()
            .await
            .as_ref()
            .map(|session| session.access_token.clone());

        Ok(Storage {
            client: AuthenticatedClient {
                client: self.storage_client.clone(),
                access_token,
                apikey: self.api_key.clone(),
            },
            url_base,
        })
    }
}

struct AuthenticatedClient {
    client: reqwest::Client,
    access_token: Option<String>,
    apikey: String,
}

pub struct Storage {
    client: AuthenticatedClient,
    url_base: String,
}

/// errorSchema as defined under schemas at [the api documentation](https://supabase.github.io/storage/)
#[derive(Debug, Clone, PartialEq, serde::Deserialize, thiserror::Error)]
pub struct Error {
    #[serde(rename = "statusCode")]
    pub status_code: String,
    pub error: String,
    pub message: String,
}

impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{self:?}")
    }
}

impl Storage {
    /// Object end-points
    pub fn object(self) -> object::Object {
        object::Object {
            client: self.client,
            url_base: format!("{}/object", self.url_base),
        }
    }
}

trait AuthenticateClient {
    fn authenticate(self, authenticator: &AuthenticatedClient) -> reqwest::RequestBuilder;
}

impl AuthenticateClient for reqwest::RequestBuilder {
    fn authenticate(self, authenticator: &AuthenticatedClient) -> reqwest::RequestBuilder {
        match &authenticator.access_token {
            Some(access_token) => self.header("Authorization", format!("Bearer {}", access_token)),
            None => self,
        }
        .header("apikey", authenticator.apikey.clone())
    }
}

trait DecodeStorageErrorResponse {
    async fn decode_storage_error_response(self) -> crate::Result<reqwest::Response>;
}

impl DecodeStorageErrorResponse for reqwest::Response {
    async fn decode_storage_error_response(self) -> crate::Result<reqwest::Response> {
        let status = self.status();
        if status.is_client_error() || status.is_server_error() {
            let error = self.json::<Error>().await?;
            Err(error.into())
        } else {
            Ok(self)
        }
    }
}

trait SendAndDecodeStorageRequest<Type> {
    async fn send_and_decode_storage_request(self) -> crate::Result<Type>;
}

impl<Type> SendAndDecodeStorageRequest<Type> for reqwest::RequestBuilder
where
    Type: serde::de::DeserializeOwned,
{
    async fn send_and_decode_storage_request(self) -> crate::Result<Type> {
        Ok(self
            .send()
            .await?
            .decode_storage_error_response()
            .await?
            .json()
            .await?)
    }
}