use serde_json::Value;
use std::time::Duration;
use tokio::sync::mpsc::UnboundedSender;
use crate::error::{SurrealError, SurrealResult};
use crate::query::{send_command, send_command_void};
use crate::router::RouterCommand;
pub struct BucketOps<'c> {
pub(crate) request_tx: UnboundedSender<RouterCommand>,
pub(crate) bucket_name: String,
pub(crate) query_timeout: Duration,
pub(crate) _phantom: std::marker::PhantomData<&'c ()>,
}
impl<'c> BucketOps<'c> {
fn file_ptr(&self, path: &str) -> String {
let key = path.strip_prefix('/').unwrap_or(path);
format!("f\"{}:/{}\"", self.bucket_name, key)
}
pub async fn get_bytes(&self, path: &str) -> SurrealResult<Vec<u8>> {
let sql = format!("{}.get()", self.file_ptr(path));
let result = send_command(
&self.request_tx,
"query",
crate::protocol::query_params(&sql, None),
self.query_timeout,
)
.await?;
let results: Vec<crate::protocol::SurrealQueryResult> =
serde_json::from_value(result).map_err(SurrealError::SerializationFailed)?;
let first = results.first().ok_or(SurrealError::NoResult)?;
if !first.is_ok() {
return Err(SurrealError::QueryFailed {
code: -1,
message: format!("Bucket get 失败: {}", first.status),
});
}
match &first.result {
Value::String(b64) => {
use base64::Engine;
base64::engine::general_purpose::STANDARD
.decode(b64)
.map_err(|e| SurrealError::QueryFailed {
code: -1,
message: format!("base64 解码失败: {e}"),
})
}
Value::Array(_) => {
let bytes: Vec<u8> = serde_json::from_value(first.result.clone())
.map_err(SurrealError::SerializationFailed)?;
Ok(bytes)
}
_ => Err(SurrealError::QueryFailed {
code: -1,
message: "Bucket get 返回类型非预期".into(),
}),
}
}
pub async fn put_bytes(&self, path: &str, data: &[u8]) -> SurrealResult<()> {
use base64::Engine;
let b64 = base64::engine::general_purpose::STANDARD.encode(data);
let bindings = serde_json::json!({
"data": {"$cbor_bytes": b64}
});
let sql = format!("{}.put($data)", self.file_ptr(path));
let params = crate::protocol::query_params(&sql, Some(&bindings));
send_command_void(&self.request_tx, "query", params, self.query_timeout).await
}
pub async fn delete(&self, path: &str) -> SurrealResult<()> {
let sql = format!("{}.delete()", self.file_ptr(path));
send_command_void(
&self.request_tx,
"query",
crate::protocol::query_params(&sql, None),
self.query_timeout,
)
.await
}
pub async fn list(&self, prefix: Option<&str>) -> SurrealResult<Vec<Value>> {
let prefix_filter = match prefix {
Some(p) if p.starts_with('/') => p.to_string(),
Some(p) => format!("/{p}"),
None => "/".to_string(),
};
let sql = format!(
"file::list('{}', {{ prefix: '{}' }})",
self.bucket_name, prefix_filter
);
let result = send_command(
&self.request_tx,
"query",
crate::protocol::query_params(&sql, None),
self.query_timeout,
)
.await?;
let results: Vec<crate::protocol::SurrealQueryResult> =
serde_json::from_value(result).map_err(SurrealError::SerializationFailed)?;
let first = results.first().ok_or(SurrealError::NoResult)?;
if !first.is_ok() {
return Err(SurrealError::QueryFailed {
code: -1,
message: format!("Bucket list 失败: {}", first.status),
});
}
Ok(first.result.as_array().cloned().unwrap_or_default())
}
}