1use serde::{Deserialize, Serialize};
6
7use crate::error::Result;
8use crate::DakeraClient;
9
10#[derive(Debug, Clone, Serialize, Deserialize)]
16pub struct CreateKeyRequest {
17 pub name: String,
19 pub scope: String,
21 #[serde(skip_serializing_if = "Option::is_none")]
23 pub namespaces: Option<Vec<String>>,
24 #[serde(skip_serializing_if = "Option::is_none")]
26 pub expires_in_days: Option<u64>,
27}
28
29#[derive(Debug, Clone, Serialize, Deserialize)]
31pub struct CreateKeyResponse {
32 pub key_id: String,
34 pub key: String,
36 pub name: String,
38 pub scope: String,
40 #[serde(skip_serializing_if = "Option::is_none")]
42 pub namespaces: Option<Vec<String>>,
43 pub created_at: u64,
45 #[serde(skip_serializing_if = "Option::is_none")]
47 pub expires_at: Option<u64>,
48 pub warning: String,
50}
51
52#[derive(Debug, Clone, Serialize, Deserialize)]
54pub struct KeyInfo {
55 pub key_id: String,
56 pub name: String,
57 pub scope: String,
58 #[serde(skip_serializing_if = "Option::is_none")]
59 pub namespaces: Option<Vec<String>>,
60 pub created_at: u64,
61 #[serde(skip_serializing_if = "Option::is_none")]
62 pub expires_at: Option<u64>,
63 pub active: bool,
64}
65
66#[derive(Debug, Clone, Serialize, Deserialize)]
68pub struct ListKeysResponse {
69 pub keys: Vec<KeyInfo>,
70 pub total: usize,
71}
72
73#[derive(Debug, Clone, Serialize, Deserialize)]
75pub struct KeySuccessResponse {
76 pub success: bool,
77 pub message: String,
78}
79
80#[derive(Debug, Clone, Serialize, Deserialize)]
82pub struct RotateKeyResponse {
83 pub new_key: String,
85 pub key_id: String,
87 pub warning: String,
89}
90
91#[derive(Debug, Clone, Serialize, Deserialize)]
93pub struct ApiKeyUsageResponse {
94 pub key_id: String,
95 pub total_requests: u64,
96 pub successful_requests: u64,
97 pub failed_requests: u64,
98 pub rate_limited_requests: u64,
99 pub bytes_transferred: u64,
100 pub avg_latency_ms: f64,
101 #[serde(default)]
102 pub by_endpoint: Vec<EndpointUsageInfo>,
103 #[serde(default)]
104 pub by_namespace: Vec<NamespaceUsageInfo>,
105}
106
107#[derive(Debug, Clone, Serialize, Deserialize)]
109pub struct EndpointUsageInfo {
110 pub endpoint: String,
111 pub requests: u64,
112 pub avg_latency_ms: f64,
113}
114
115#[derive(Debug, Clone, Serialize, Deserialize)]
117pub struct NamespaceUsageInfo {
118 pub namespace: String,
119 pub requests: u64,
120 pub vectors_accessed: u64,
121}
122
123impl DakeraClient {
128 pub async fn create_key(&self, request: CreateKeyRequest) -> Result<CreateKeyResponse> {
130 let url = format!("{}/admin/keys", self.base_url);
131 let response = self.client.post(&url).json(&request).send().await?;
132 self.handle_response(response).await
133 }
134
135 pub async fn list_keys(&self) -> Result<ListKeysResponse> {
137 let url = format!("{}/admin/keys", self.base_url);
138 let response = self.client.get(&url).send().await?;
139 self.handle_response(response).await
140 }
141
142 pub async fn get_key(&self, key_id: &str) -> Result<KeyInfo> {
144 let url = format!("{}/admin/keys/{}", self.base_url, key_id);
145 let response = self.client.get(&url).send().await?;
146 self.handle_response(response).await
147 }
148
149 pub async fn delete_key(&self, key_id: &str) -> Result<KeySuccessResponse> {
151 let url = format!("{}/admin/keys/{}", self.base_url, key_id);
152 let response = self.client.delete(&url).send().await?;
153 self.handle_response(response).await
154 }
155
156 pub async fn deactivate_key(&self, key_id: &str) -> Result<KeySuccessResponse> {
158 let url = format!("{}/admin/keys/{}/deactivate", self.base_url, key_id);
159 let response = self.client.post(&url).send().await?;
160 self.handle_response(response).await
161 }
162
163 pub async fn rotate_key(&self, key_id: &str) -> Result<RotateKeyResponse> {
165 let url = format!("{}/admin/keys/{}/rotate", self.base_url, key_id);
166 let response = self.client.post(&url).send().await?;
167 self.handle_response(response).await
168 }
169
170 pub async fn key_usage(&self, key_id: &str) -> Result<ApiKeyUsageResponse> {
172 let url = format!("{}/admin/keys/{}/usage", self.base_url, key_id);
173 let response = self.client.get(&url).send().await?;
174 self.handle_response(response).await
175 }
176}