squarecloud 0.1.1

Async Rust client for the SquareCloud API
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

use std::sync::{Once, OnceLock};

use squarecloud::ApiClient;

mod account;
mod app;
mod client;
mod database;
pub mod helpers;
mod workspace;

static ENV: Once = Once::new();
static APP_ID: OnceLock<Result<String, String>> = OnceLock::new();
static DATABASE_ID: OnceLock<Result<String, String>> = OnceLock::new();

pub fn setup() {
    ENV.call_once(|| {
        dotenvy::from_filename(".env.test")
            .expect(".env.test not found — copy .env.test.example");
    });
}

/// Returns the shared dummy app ID, uploading it on first call.
///
/// Stores `Result` so a failed upload is cached: subsequent tests fail
/// immediately instead of retrying the upload and compounding rate limits.
pub fn shared_app_id() -> &'static str {
    APP_ID
        .get_or_init(|| {
            setup();
            std::thread::spawn(|| {
                tokio::runtime::Runtime::new()
                    .expect("failed to create tokio runtime for app upload")
                    .block_on(async {
                        ApiClient::new()
                            .upload_app(helpers::dummy_zip())
                            .await
                            .map(|a| a.id)
                            .map_err(|e| format!("{e:?}"))
                    })
            })
            .join()
            .unwrap_or_else(|_| Err("upload thread panicked".to_string()))
        })
        .as_deref()
        .expect("shared app upload failed — check API token and rate limit")
}

/// Returns the shared app ID only if it was already initialized.
///
/// Used by the cleanup test to avoid uploading just to delete.
pub fn shared_app_id_if_initialized() -> Option<&'static str> {
    APP_ID.get().and_then(|r| r.as_deref().ok())
}

/// Returns the shared database ID, or `None` if creation failed.
///
/// Skips the test rather than panicking, since the plan may not support
/// database creation.
pub fn shared_database_id() -> Option<&'static str> {
    DATABASE_ID
        .get_or_init(|| {
            setup();
            std::thread::spawn(|| {
                tokio::runtime::Runtime::new()
                    .expect(
                        "failed to create tokio runtime for database create",
                    )
                    .block_on(async {
                        ApiClient::new()
                            .create_database(
                                "squarecloud-rs-test".to_string(),
                                256,
                                squarecloud::DatabaseType::Postgres,
                                "16".to_string(),
                            )
                            .await
                            .map(|d| d.id)
                            .map_err(|e| {
                                eprintln!(
                                    "[database] create_database failed: {e:?}"
                                );
                                format!("{e:?}")
                            })
                    })
            })
            .join()
            .unwrap_or_else(|_| Err("database thread panicked".to_string()))
        })
        .as_deref()
        .ok()
}

pub fn shared_database_id_if_initialized() -> Option<&'static str> {
    DATABASE_ID.get().and_then(|r| r.as_deref().ok())
}

/// Waits briefly between tests to avoid hitting the SquareCloud rate limit.
pub async fn throttle() {
    tokio::time::sleep(std::time::Duration::from_millis(5000)).await;
}