edgebase-admin 0.2.9

EdgeBase Admin SDK — server-side admin operations
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

use edgebase_core::http_client::HttpClient;
use edgebase_core::table::TableRef;
use edgebase_core::storage::StorageClient;
use edgebase_core::Error;
use crate::generated::admin_api_core::GeneratedAdminApi;
use crate::admin_auth::AdminAuthClient;
use crate::analytics::AnalyticsClient;
use crate::kv::KvClient;
use crate::d1::D1Client;
use crate::functions::FunctionsClient;
use crate::vectorize::VectorizeClient;
use crate::push::PushClient;
use serde::Serialize;
use serde_json::Value;
use std::sync::Arc;

/// DB namespace block reference for table access (#133 §2).
pub struct DbRef {
    http: Arc<HttpClient>,
    ns: String,
    instance_id: Option<String>,
}

impl DbRef {
    /// Get a [TableRef] for the named table.
    pub fn table(&self, name: &str) -> TableRef {
        TableRef::with_db(Arc::clone(&self.http), name, &self.ns, self.instance_id.as_deref())
    }
}


/// Server-side EdgeBase client — requires Service Key.
pub struct EdgeBase {
    http: Arc<HttpClient>,
}

impl EdgeBase {
    /// Create a server-side SDK instance.
    pub fn server(base_url: &str, service_key: &str) -> Result<Self, Error> {
        let http = HttpClient::new(base_url, service_key)?;
        Ok(Self { http: Arc::new(http) })
    }

    /// Admin Auth operations (create/get/list/delete users).
    pub fn admin_auth(&self) -> AdminAuthClient {
        AdminAuthClient::new(Arc::clone(&self.http))
    }

    /// Select a DB block by namespace and optional instance ID (#133 §2).
    pub fn db(&self, ns: &str, instance_id: Option<&str>) -> DbRef {
        DbRef {
            http: Arc::clone(&self.http),
            ns: ns.to_string(),
            instance_id: instance_id.map(|s| s.to_string()),
        }
    }

    /// Storage operations.
    pub fn storage(&self) -> StorageClient {
        StorageClient::new(Arc::clone(&self.http))
    }

    /// Access a user-defined KV namespace.
    pub fn kv(&self, namespace: &str) -> KvClient {
        KvClient::new(Arc::clone(&self.http), namespace)
    }

    /// Access a user-defined D1 database.
    pub fn d1(&self, database: &str) -> D1Client {
        D1Client::new(Arc::clone(&self.http), database)
    }

    /// Access a user-defined Vectorize index.
    pub fn vector(&self, index: &str) -> VectorizeClient {
        VectorizeClient::new(Arc::clone(&self.http), index)
    }

    /// Push notification management.
    pub fn push(&self) -> PushClient {
        PushClient::new(Arc::clone(&self.http))
    }

    /// Call app functions with the admin service key.
    pub fn functions(&self) -> FunctionsClient {
        FunctionsClient::new(Arc::clone(&self.http))
    }

    /// Query analytics metrics and track custom events.
    pub fn analytics(&self) -> AnalyticsClient {
        AnalyticsClient::new(Arc::clone(&self.http))
    }

    fn core(&self) -> GeneratedAdminApi<'_> {
        GeneratedAdminApi::new(&self.http)
    }

    /// Raw SQL query     /// namespace: DB namespace ('shared' | 'workspace' | ...), id: instance ID for dynamic DOs.
    pub async fn sql<T: Serialize>(&self, namespace: &str, id: Option<&str>, query: &str, params: &[T]) -> Result<Value, Error> {
        if query.trim().is_empty() {
            return Err(Error::Api {
                status: 400,
                message: "Invalid sql() signature: query must be a non-empty string".to_string(),
            });
        }

        let serialized_params = serde_json::to_value(params)?;
        let mut body = serde_json::json!({
            "namespace": namespace,
            "sql": query,
            "params": serialized_params,
        });
        if let Some(id_val) = id {
            body["id"] = serde_json::Value::String(id_val.to_string());
        }
        self.core().execute_sql(&body).await
    }

    /// Server-side broadcast to a database-live channel.
    pub async fn broadcast(&self, channel: &str, event: &str, payload: Value) -> Result<Value, Error> {
        let body = serde_json::json!({
            "channel": channel,
            "event": event,
            "payload": payload,
        });
        self.core().database_live_broadcast(&body).await
    }

}