use std::io;
use ciborium::value::Integer;
use ciborium::value::Value as CborValue;
use serde::de::DeserializeOwned;
use serde::Deserialize;
use serde_json::Value as JsonValue;
use crate::error::{SurrealError, SurrealResult};
use crate::protocol::{RpcError, RpcResponse};
fn json_error(msg: impl Into<String>) -> serde_json::Error {
serde_json::Error::io(io::Error::other(msg.into()))
}
pub fn encode_request_cbor(id: u64, method: &str, params: &JsonValue) -> SurrealResult<Vec<u8>> {
let cbor_params = json_to_cbor(params);
let map = CborValue::Map(vec![
(
CborValue::Text("id".into()),
CborValue::Integer(Integer::from(id)),
),
(
CborValue::Text("method".into()),
CborValue::Text(method.into()),
),
(CborValue::Text("params".into()), cbor_params),
]);
let mut buf = Vec::new();
ciborium::into_writer(&map, &mut buf).map_err(|e| {
SurrealError::SerializationFailed(json_error(format!("CBOR 编码失败: {e}")))
})?;
Ok(buf)
}
fn json_to_cbor(v: &JsonValue) -> CborValue {
match v {
JsonValue::Null => CborValue::Null,
JsonValue::Bool(b) => CborValue::Bool(*b),
JsonValue::Number(n) => {
if let Some(i) = n.as_i64() {
CborValue::Integer(Integer::from(i))
} else if let Some(f) = n.as_f64() {
CborValue::Float(f)
} else {
CborValue::Text(n.to_string())
}
}
JsonValue::String(s) => CborValue::Text(s.clone()),
JsonValue::Array(arr) => CborValue::Array(arr.iter().map(json_to_cbor).collect()),
JsonValue::Object(obj) => {
if obj.len() == 1
&& let Some(JsonValue::String(b64)) = obj.get("$cbor_bytes") {
use base64::Engine;
if let Ok(bytes) = base64::engine::general_purpose::STANDARD.decode(b64) {
return CborValue::Bytes(bytes);
}
}
CborValue::Map(
obj.iter()
.map(|(k, v)| (CborValue::Text(k.clone()), json_to_cbor(v)))
.collect(),
)
}
}
}
pub fn encode_request_json(id: u64, method: &str, params: &JsonValue) -> SurrealResult<String> {
let obj = JsonValue::Object({
let mut m = serde_json::Map::new();
m.insert("id".into(), JsonValue::Number(id.into()));
m.insert("method".into(), JsonValue::String(method.to_string()));
m.insert("params".into(), params.clone());
m
});
serde_json::to_string(&obj).map_err(SurrealError::SerializationFailed)
}
pub fn decode_response_cbor(data: &[u8]) -> SurrealResult<RpcResponse> {
let value: CborValue = ciborium::from_reader(data)
.map_err(|e| SurrealError::SerializationFailed(json_error(format!("CBOR 解码失败: {e}"))))?;
cbor_to_response(&value)
}
fn cbor_to_response(map: &CborValue) -> SurrealResult<RpcResponse> {
let fields = match map {
CborValue::Map(m) => m,
_ => {
return Err(SurrealError::SerializationFailed(json_error(
"响应不是 CBOR Map",
)));
}
};
let mut id: Option<u64> = None;
let mut result: Option<CborValue> = None;
let mut error: Option<RpcError> = None;
for (key, val) in fields {
let key_str = match key {
CborValue::Text(s) => s.as_str(),
_ => continue,
};
match key_str {
"id" => {
id = match val {
CborValue::Integer(i) => u64::try_from(*i).ok(),
_ => None,
};
}
"result" => {
result = Some(val.clone());
}
"error" => {
error = parse_cbor_error(val);
}
_ => {}
}
}
let id = id.unwrap_or(0);
let json_result = match result {
Some(ref v) => cbor_to_json(v),
None => JsonValue::Null,
};
Ok(RpcResponse {
id,
result: json_result,
error,
})
}
fn parse_cbor_error(val: &CborValue) -> Option<RpcError> {
match val {
CborValue::Map(fields) => {
let mut code: i64 = -1;
let mut message = String::new();
for (key, val) in fields {
let key_str = match key {
CborValue::Text(s) => s.as_str(),
_ => continue,
};
match key_str {
"code" => {
if let CborValue::Integer(i) = val {
code = i64::try_from(*i).unwrap_or(-1);
}
}
"message" => {
if let CborValue::Text(s) = val {
message = s.clone();
}
}
_ => {}
}
}
Some(RpcError { code, message })
}
_ => None,
}
}
fn cbor_to_json(val: &CborValue) -> JsonValue {
match val {
CborValue::Null => JsonValue::Null,
CborValue::Bool(b) => JsonValue::Bool(*b),
CborValue::Integer(i) => {
if let Ok(n) = i64::try_from(*i) {
JsonValue::Number(n.into())
} else if let Ok(n) = u64::try_from(*i) {
JsonValue::Number(n.into())
} else {
JsonValue::String(i128::from(*i).to_string())
}
}
CborValue::Float(f) => serde_json::Number::from_f64(*f)
.map(JsonValue::Number)
.unwrap_or(JsonValue::Null),
CborValue::Text(s) => JsonValue::String(s.clone()),
CborValue::Bytes(data) => {
use base64::Engine;
JsonValue::String(base64::engine::general_purpose::STANDARD.encode(data))
}
CborValue::Array(arr) => JsonValue::Array(arr.iter().map(cbor_to_json).collect()),
CborValue::Map(fields) => {
let mut obj = serde_json::Map::new();
for (key, val) in fields {
let key_str = match key {
CborValue::Text(s) => s.clone(),
CborValue::Integer(i) => i128::from(*i).to_string(),
_ => continue,
};
obj.insert(key_str, cbor_to_json(val));
}
JsonValue::Object(obj)
}
CborValue::Tag(_tag, inner) => cbor_to_json(inner),
_ => JsonValue::Null,
}
}
pub fn decode_response_json(data: &[u8]) -> SurrealResult<RpcResponse> {
serde_json::from_slice::<RpcResponse>(data).map_err(SurrealError::SerializationFailed)
}
pub fn peek_response_id_cbor(data: &[u8]) -> SurrealResult<u64> {
#[derive(Deserialize)]
struct IdOnly {
id: u64,
}
thread_local! {
static SCRATCH: std::cell::RefCell<[u8; 64 * 1024]> = const { std::cell::RefCell::new([0u8; 64 * 1024]) };
}
SCRATCH.with(|s| {
let mut scratch = s.borrow_mut();
let v: IdOnly = ciborium::from_reader_with_buffer(data, &mut *scratch)
.map_err(|e| SurrealError::CborDecodeFailed(e.to_string()))?;
Ok(v.id)
})
}
pub fn peek_response_id_json(data: &[u8]) -> SurrealResult<u64> {
#[derive(Deserialize)]
struct IdOnly {
id: u64,
}
serde_json::from_slice::<IdOnly>(data)
.map(|v| v.id)
.map_err(SurrealError::SerializationFailed)
}
#[derive(Deserialize)]
#[serde(bound(deserialize = "T: Deserialize<'de>"))]
#[allow(dead_code)]
struct CborRpcResponse<T> {
id: u64,
#[serde(default = "Vec::new")]
result: Vec<CborQueryResult<T>>,
#[serde(default)]
error: Option<CborRpcError>,
}
#[derive(Deserialize)]
#[serde(bound(deserialize = "T: Deserialize<'de>"))]
#[allow(dead_code)]
struct CborQueryResult<T> {
status: String,
#[serde(default)]
time: Option<String>,
result: Vec<T>,
#[serde(default, rename = "type")]
_type: serde::de::IgnoredAny,
}
#[derive(Deserialize)]
#[allow(dead_code)]
struct CborRpcError {
#[serde(default)]
code: Option<i64>,
#[serde(default)]
message: Option<String>,
#[serde(default)]
kind: Option<String>,
}
pub fn decode_query_result_typed<T: DeserializeOwned>(data: &[u8]) -> SurrealResult<Vec<T>> {
thread_local! {
static SCRATCH: std::cell::RefCell<[u8; 64 * 1024]> = const { std::cell::RefCell::new([0u8; 64 * 1024]) };
}
SCRATCH.with(|s| -> SurrealResult<Vec<T>> {
let mut scratch = s.borrow_mut();
let resp: CborRpcResponse<T> = ciborium::from_reader_with_buffer(data, &mut *scratch)
.map_err(|e| SurrealError::CborDecodeFailed(e.to_string()))?;
if let Some(err) = resp.error {
return Err(SurrealError::QueryFailed {
code: err.code.unwrap_or(-1),
message: err.message.unwrap_or_else(|| "未知错误".into()),
});
}
let first = resp.result.into_iter().next().ok_or(SurrealError::NoResult)?;
if first.status != "OK" {
return Err(SurrealError::QueryFailed {
code: -1,
message: format!("查询状态异常: {}", first.status),
});
}
Ok(first.result)
})
}
pub fn decode_query_result_typed_json<T: DeserializeOwned>(data: &[u8]) -> SurrealResult<Vec<T>> {
#[derive(Deserialize)]
#[serde(bound(deserialize = "T: Deserialize<'de>"))]
#[allow(dead_code)]
struct JsonRpcResponse<T> {
id: u64,
#[serde(default = "Vec::new")]
result: Vec<JsonQueryResult<T>>,
#[serde(default)]
error: Option<RpcError>,
}
#[derive(Deserialize)]
#[serde(bound(deserialize = "T: Deserialize<'de>"))]
#[allow(dead_code)]
struct JsonQueryResult<T> {
status: String,
#[serde(default)]
time: Option<String>,
#[serde(default)]
result: Vec<T>,
#[serde(default, rename = "type")]
_type: serde::de::IgnoredAny,
}
let resp: JsonRpcResponse<T> =
serde_json::from_slice(data).map_err(SurrealError::SerializationFailed)?;
if let Some(err) = resp.error {
return Err(SurrealError::QueryFailed {
code: err.code,
message: err.message,
});
}
let first = resp
.result
.into_iter()
.next()
.ok_or(SurrealError::NoResult)?;
if first.status != "OK" {
return Err(SurrealError::QueryFailed {
code: -1,
message: format!("查询状态异常: {}", first.status),
});
}
Ok(first.result)
}
pub fn extract_query_result_bytes(data: &[u8]) -> SurrealResult<Vec<u8>> {
let value: CborValue = ciborium::from_reader(data).map_err(|e| {
SurrealError::SerializationFailed(json_error(format!("CBOR 解码失败: {e}")))
})?;
let rpc_result = match &value {
CborValue::Map(fields) => fields
.iter()
.find(|(k, _)| matches!(k, CborValue::Text(s) if s == "result"))
.map(|(_, v)| v),
_ => None,
}
.ok_or(SurrealError::NoResult)?;
let results: &[CborValue] = match rpc_result {
CborValue::Array(arr) => arr.as_slice(),
_ => &[],
};
let first = results.first().ok_or(SurrealError::NoResult)?;
if let CborValue::Map(fields) = first {
let status_ok = fields.iter().any(|(k, v)| {
matches!(k, CborValue::Text(s) if s == "status")
&& matches!(v, CborValue::Text(s) if s == "OK")
});
if !status_ok {
return Err(SurrealError::QueryFailed {
code: -1,
message: "file::get 查询状态非 OK".into(),
});
}
for (key, val) in fields {
if matches!(key, CborValue::Text(s) if s == "result") {
return match val {
CborValue::Bytes(data) => Ok(data.clone()),
CborValue::Text(s) => {
use base64::Engine;
base64::engine::general_purpose::STANDARD
.decode(s)
.map_err(|e| SurrealError::QueryFailed {
code: -1,
message: format!("base64 解码失败: {e}"),
})
}
_ => Err(SurrealError::QueryFailed {
code: -1,
message: "file::get 返回类型不是 Bytes".into(),
}),
};
}
}
}
Err(SurrealError::NoResult)
}