use crate::error::{Error, Result};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
pub use orcher_sdk_core::payload::Payload;
pub trait PayloadCodec: Sized {
fn encode(&self) -> Result<Vec<u8>>;
fn decode(bytes: &[u8]) -> Result<Self>;
fn to_payload(&self) -> Result<Payload> {
let bytes = self.encode()?;
Ok(Payload::new_data(bytes))
}
fn from_payload(payload: &Payload) -> Result<Self> {
Self::decode(&payload.data)
}
}
pub trait PayloadExt {
#[allow(clippy::wrong_self_convention)]
fn from_payload<T: PayloadCodec>(&self) -> Result<T>;
}
impl PayloadExt for Payload {
fn from_payload<T: PayloadCodec>(&self) -> Result<T> {
T::from_payload(self)
}
}
impl<T> PayloadCodec for T
where
T: Serialize + for<'de> Deserialize<'de>,
{
fn encode(&self) -> Result<Vec<u8>> {
serde_json::to_vec(self).map_err(|e| Error::Serialization(e.to_string()))
}
fn decode(bytes: &[u8]) -> Result<Self> {
serde_json::from_slice(bytes).map_err(|e| Error::Serialization(e.to_string()))
}
fn to_payload(&self) -> Result<Payload> {
Payload::from_json(self).map_err(|e| Error::Serialization(e.to_string()))
}
fn from_payload(payload: &Payload) -> Result<Self> {
payload
.to_json()
.map_err(|e| Error::Serialization(e.to_string()))
}
}
pub fn to_payload<T: Serialize>(value: &T) -> Result<Payload> {
Payload::from_json(value).map_err(|e| Error::Serialization(e.to_string()))
}
pub fn from_payload<T: PayloadCodec>(payload: &Payload) -> Result<T> {
T::from_payload(payload)
}
pub fn to_json_bytes<T: Serialize>(value: &T) -> Result<Vec<u8>> {
serde_json::to_vec(value).map_err(|e| Error::Serialization(e.to_string()))
}
pub fn from_json_bytes<T: for<'de> Deserialize<'de>>(bytes: &[u8]) -> Result<T> {
serde_json::from_slice(bytes).map_err(|e| Error::Serialization(e.to_string()))
}
pub fn to_json_string<T: Serialize>(value: &T) -> Result<String> {
serde_json::to_string_pretty(value).map_err(|e| Error::Serialization(e.to_string()))
}
pub fn from_json_string<T: for<'de> Deserialize<'de>>(json: &str) -> Result<T> {
serde_json::from_str(json).map_err(|e| Error::Serialization(e.to_string()))
}
pub fn to_binary_bytes<T: Serialize>(value: &T) -> Result<Vec<u8>> {
bincode::serialize(value).map_err(|e| Error::Serialization(e.to_string()))
}
pub fn from_binary_bytes<T: for<'de> Deserialize<'de>>(bytes: &[u8]) -> Result<T> {
bincode::deserialize(bytes).map_err(|e| Error::Serialization(e.to_string()))
}
pub fn to_binary_payload<T: Serialize>(value: &T) -> Result<Payload> {
let bytes = to_binary_bytes(value)?;
let payload = Payload::new_data(bytes)
.with_metadata("encoding", "bincode")
.with_metadata("content-type", "application/octet-stream");
Ok(payload)
}
pub fn from_binary_payload<T: for<'de> Deserialize<'de>>(payload: &Payload) -> Result<T> {
from_binary_bytes(&payload.data)
}
#[cfg(feature = "compression")]
use flate2::{read::GzDecoder, write::GzEncoder, Compression};
#[cfg(feature = "compression")]
use std::io::{Read, Write};
#[cfg(feature = "compression")]
pub fn compress_bytes(bytes: &[u8]) -> Result<Vec<u8>> {
let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
encoder
.write_all(bytes)
.map_err(|e| Error::Serialization(format!("Compression failed: {}", e)))?;
encoder
.finish()
.map_err(|e| Error::Serialization(format!("Compression failed: {}", e)))
}
#[cfg(feature = "compression")]
pub fn decompress_bytes(bytes: &[u8]) -> Result<Vec<u8>> {
let mut decoder = GzDecoder::new(bytes);
let mut decompressed = Vec::new();
decoder
.read_to_end(&mut decompressed)
.map_err(|e| Error::Serialization(format!("Decompression failed: {}", e)))?;
Ok(decompressed)
}
#[cfg(feature = "compression")]
pub fn to_compressed_payload<T: Serialize>(value: &T) -> Result<Payload> {
let json_bytes = to_json_bytes(value)?;
let compressed = compress_bytes(&json_bytes)?;
let payload = Payload::new_data(compressed)
.with_metadata("encoding", "json+gzip")
.with_metadata("content-type", "application/json")
.with_metadata("compressed", "true");
Ok(payload)
}
#[cfg(feature = "compression")]
pub fn from_compressed_payload<T: for<'de> Deserialize<'de>>(payload: &Payload) -> Result<T> {
let decompressed = decompress_bytes(&payload.data)?;
from_json_bytes(&decompressed)
}
pub struct PayloadBuilder {
data: Vec<u8>,
metadata: HashMap<String, Vec<u8>>,
}
impl PayloadBuilder {
pub fn new() -> Self {
Self {
data: Vec::new(),
metadata: HashMap::new(),
}
}
pub fn json<T: Serialize>(mut self, value: &T) -> Result<Self> {
self.data = to_json_bytes(value)?;
self.metadata
.insert("encoding".to_string(), b"json".to_vec());
self.metadata
.insert("content-type".to_string(), b"application/json".to_vec());
Ok(self)
}
pub fn binary<T: Serialize>(mut self, value: &T) -> Result<Self> {
self.data = to_binary_bytes(value)?;
self.metadata
.insert("encoding".to_string(), b"bincode".to_vec());
self.metadata.insert(
"content-type".to_string(),
b"application/octet-stream".to_vec(),
);
Ok(self)
}
pub fn bytes(mut self, bytes: Vec<u8>) -> Self {
self.data = bytes;
self
}
pub fn string(mut self, value: impl Into<String>) -> Self {
self.data = value.into().into_bytes();
self.metadata
.insert("encoding".to_string(), b"utf-8".to_vec());
self.metadata
.insert("content-type".to_string(), b"text/plain".to_vec());
self
}
pub fn metadata(mut self, key: impl Into<String>, value: impl Into<Vec<u8>>) -> Self {
self.metadata.insert(key.into(), value.into());
self
}
pub fn build(self) -> Payload {
Payload {
data: self.data,
metadata: self.metadata,
}
}
}
impl Default for PayloadBuilder {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
struct TestData {
name: String,
value: i32,
}
#[test]
fn test_to_from_payload() {
let data = TestData {
name: "test".to_string(),
value: 42,
};
let payload = to_payload(&data).unwrap();
let decoded: TestData = from_payload(&payload).unwrap();
assert_eq!(data, decoded);
}
#[test]
fn test_payload_codec_trait() {
let data = TestData {
name: "test".to_string(),
value: 42,
};
let payload = data.to_payload().unwrap();
let decoded = TestData::from_payload(&payload).unwrap();
assert_eq!(data, decoded);
}
#[test]
fn test_json_bytes() {
let data = TestData {
name: "test".to_string(),
value: 42,
};
let bytes = to_json_bytes(&data).unwrap();
let decoded: TestData = from_json_bytes(&bytes).unwrap();
assert_eq!(data, decoded);
}
#[test]
fn test_json_string() {
let data = TestData {
name: "test".to_string(),
value: 42,
};
let json = to_json_string(&data).unwrap();
assert!(json.contains("test"));
assert!(json.contains("42"));
let decoded: TestData = from_json_string(&json).unwrap();
assert_eq!(data, decoded);
}
#[test]
fn test_binary_serialization() {
let data = TestData {
name: "test".to_string(),
value: 42,
};
let bytes = to_binary_bytes(&data).unwrap();
let decoded: TestData = from_binary_bytes(&bytes).unwrap();
assert_eq!(data, decoded);
}
#[test]
fn test_binary_payload() {
let data = TestData {
name: "test".to_string(),
value: 42,
};
let payload = to_binary_payload(&data).unwrap();
assert_eq!(
payload.get_metadata_string("encoding"),
Some("bincode".to_string())
);
let decoded: TestData = from_binary_payload(&payload).unwrap();
assert_eq!(data, decoded);
}
#[test]
fn test_payload_builder() {
let data = TestData {
name: "builder".to_string(),
value: 100,
};
let payload = PayloadBuilder::new()
.json(&data)
.unwrap()
.metadata("version", "1.0")
.metadata("custom", "value")
.build();
assert_eq!(
payload.get_metadata_string("version"),
Some("1.0".to_string())
);
assert_eq!(
payload.get_metadata_string("custom"),
Some("value".to_string())
);
let decoded: TestData = from_payload(&payload).unwrap();
assert_eq!(data, decoded);
}
#[test]
fn test_payload_builder_string() {
let payload = PayloadBuilder::new()
.string("Hello, World!")
.metadata("author", "test")
.build();
let text = String::from_utf8(payload.data.clone()).unwrap();
assert_eq!(text, "Hello, World!");
assert_eq!(
payload.get_metadata_string("author"),
Some("test".to_string())
);
}
#[test]
fn test_payload_builder_bytes() {
let bytes = vec![1, 2, 3, 4, 5];
let payload = PayloadBuilder::new()
.bytes(bytes.clone())
.metadata("type", "binary")
.build();
assert_eq!(payload.data, bytes);
assert_eq!(
payload.get_metadata_string("type"),
Some("binary".to_string())
);
}
#[test]
fn test_empty_payload() {
let payload = Payload::default();
assert!(payload.is_empty());
assert_eq!(payload.len(), 0);
}
#[test]
fn test_payload_metadata() {
let payload = Payload::new_data(vec![1, 2, 3])
.with_metadata("key1", "value1")
.with_metadata("key2", b"value2".to_vec());
assert_eq!(
payload.get_metadata_string("key1"),
Some("value1".to_string())
);
assert_eq!(payload.get_metadata("key2"), Some(b"value2".as_slice()));
}
#[cfg(feature = "compression")]
#[test]
fn test_compression() {
let data = b"Hello, World!".repeat(100);
let compressed = compress_bytes(&data).unwrap();
assert!(compressed.len() < data.len());
let decompressed = decompress_bytes(&compressed).unwrap();
assert_eq!(data.to_vec(), decompressed);
}
#[cfg(feature = "compression")]
#[test]
fn test_compressed_payload() {
let data = TestData {
name: "compressed".to_string(),
value: 999,
};
let payload = to_compressed_payload(&data).unwrap();
assert_eq!(
payload.get_metadata_string("compressed"),
Some("true".to_string())
);
let decoded: TestData = from_compressed_payload(&payload).unwrap();
assert_eq!(data, decoded);
}
}