supabase-client-rs 0.1.0

A unified Rust client for Supabase with database, realtime, auth, storage, and functions support
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

//! Configuration types for the Supabase client.

use std::time::Duration;

/// Configuration options for the Supabase client.
#[derive(Debug, Clone)]
pub struct SupabaseConfig {
    /// The Supabase project URL (e.g., `https://xyzcompany.supabase.co`)
    pub url: String,

    /// The Supabase API key (anon key or service role key)
    pub api_key: String,

    /// Optional JWT for authenticated requests
    pub jwt: Option<String>,

    /// Custom schema (default: "public")
    pub schema: String,

    /// Request timeout
    pub timeout: Duration,

    /// Custom headers to include in all requests
    pub headers: Vec<(String, String)>,

    /// Auto-refresh token settings
    pub auto_refresh_token: bool,

    /// Persist session
    pub persist_session: bool,
}

impl SupabaseConfig {
    /// Create a new configuration with the given URL and API key.
    pub fn new(url: impl Into<String>, api_key: impl Into<String>) -> Self {
        Self {
            url: url.into(),
            api_key: api_key.into(),
            jwt: None,
            schema: "public".to_string(),
            timeout: Duration::from_secs(30),
            headers: Vec::new(),
            auto_refresh_token: true,
            persist_session: true,
        }
    }

    /// Set a custom schema.
    pub fn schema(mut self, schema: impl Into<String>) -> Self {
        self.schema = schema.into();
        self
    }

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

    /// Set a JWT for authenticated requests.
    pub fn jwt(mut self, jwt: impl Into<String>) -> Self {
        self.jwt = Some(jwt.into());
        self
    }

    /// Add a custom header.
    pub fn header(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
        self.headers.push((key.into(), value.into()));
        self
    }

    /// Disable auto-refresh token.
    pub fn auto_refresh_token(mut self, enabled: bool) -> Self {
        self.auto_refresh_token = enabled;
        self
    }

    /// Disable session persistence.
    pub fn persist_session(mut self, enabled: bool) -> Self {
        self.persist_session = enabled;
        self
    }

    /// Get the REST API URL.
    pub fn rest_url(&self) -> String {
        format!("{}/rest/v1", self.url.trim_end_matches('/'))
    }

    /// Get the Auth API URL.
    pub fn auth_url(&self) -> String {
        format!("{}/auth/v1", self.url.trim_end_matches('/'))
    }

    /// Get the Storage API URL.
    pub fn storage_url(&self) -> String {
        format!("{}/storage/v1", self.url.trim_end_matches('/'))
    }

    /// Get the Realtime URL.
    pub fn realtime_url(&self) -> String {
        let base = self.url.trim_end_matches('/');
        let ws_url = base
            .replace("https://", "wss://")
            .replace("http://", "ws://");
        format!("{}/realtime/v1", ws_url)
    }

    /// Get the Functions URL.
    pub fn functions_url(&self) -> String {
        format!("{}/functions/v1", self.url.trim_end_matches('/'))
    }
}