yaiko_core/
data_transfer.rs1use serde::{de::DeserializeOwned, Serialize};
4use serde_json::Value;
5use std::collections::BTreeMap;
6
7#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8pub enum DataFormat {
9 Json,
10 Csv,
11}
12
13#[derive(Debug, Clone, PartialEq, Eq)]
14pub struct ExportPayload {
15 pub bytes: Vec<u8>,
16 pub content_type: String,
17 pub filename: String,
18}
19
20#[derive(Debug, Clone, PartialEq, Eq)]
21pub enum DataTransferError {
22 Serialization,
23 InvalidInput,
24 TooLarge,
25 UnsupportedFormat,
26 InvalidFilename,
27}
28
29pub fn export_json<T: Serialize>(
30 value: &T,
31 filename: &str,
32 max_bytes: usize,
33) -> Result<ExportPayload, DataTransferError> {
34 let bytes = serde_json::to_vec(value).map_err(|_| DataTransferError::Serialization)?;
35 make_payload(bytes, "application/json", filename, max_bytes)
36}
37
38pub fn export_csv(
39 rows: &[BTreeMap<String, String>],
40 filename: &str,
41 max_bytes: usize,
42) -> Result<ExportPayload, DataTransferError> {
43 let mut columns = Vec::new();
44 for row in rows {
45 for key in row.keys() {
46 if !columns.contains(key) {
47 columns.push(key.clone());
48 }
49 }
50 }
51 let mut output = String::new();
52 output.push_str(
53 &columns
54 .iter()
55 .map(|column| csv_cell(column))
56 .collect::<Vec<_>>()
57 .join(","),
58 );
59 output.push('\n');
60 for row in rows {
61 output.push_str(
62 &columns
63 .iter()
64 .map(|column| csv_cell(row.get(column).map(String::as_str).unwrap_or_default()))
65 .collect::<Vec<_>>()
66 .join(","),
67 );
68 output.push('\n');
69 }
70 make_payload(
71 output.into_bytes(),
72 "text/csv; charset=utf-8",
73 filename,
74 max_bytes,
75 )
76}
77
78pub fn import_json<T: DeserializeOwned>(
79 bytes: &[u8],
80 max_bytes: usize,
81) -> Result<T, DataTransferError> {
82 if bytes.len() > max_bytes {
83 return Err(DataTransferError::TooLarge);
84 }
85 serde_json::from_slice(bytes).map_err(|_| DataTransferError::InvalidInput)
86}
87
88pub fn import_json_value(bytes: &[u8], max_bytes: usize) -> Result<Value, DataTransferError> {
89 import_json(bytes, max_bytes)
90}
91
92fn make_payload(
93 bytes: Vec<u8>,
94 content_type: &str,
95 filename: &str,
96 max_bytes: usize,
97) -> Result<ExportPayload, DataTransferError> {
98 if bytes.len() > max_bytes {
99 return Err(DataTransferError::TooLarge);
100 }
101 let filename = safe_filename(filename)?;
102 Ok(ExportPayload {
103 bytes,
104 content_type: content_type.to_string(),
105 filename,
106 })
107}
108
109pub fn safe_filename(filename: &str) -> Result<String, DataTransferError> {
110 let trimmed = filename.trim();
111 if trimmed.is_empty()
112 || trimmed.contains('/')
113 || trimmed.contains('\\')
114 || trimmed.contains("..")
115 || trimmed.chars().any(|character| character.is_control())
116 {
117 return Err(DataTransferError::InvalidFilename);
118 }
119 Ok(trimmed.to_string())
120}
121
122fn csv_cell(value: &str) -> String {
123 if value.contains(',') || value.contains('"') || value.contains('\n') {
124 format!("\"{}\"", value.replace('"', "\"\""))
125 } else {
126 value.to_string()
127 }
128}
129
130#[cfg(test)]
131mod tests {
132 use super::*;
133 use serde_json::json;
134
135 #[test]
136 fn exports_json_with_metadata_and_round_trips_import() {
137 let payload = export_json(&json!({"id": 1}), "records.json", 100).unwrap();
138 assert_eq!(payload.content_type, "application/json");
139 let value: Value = import_json(&payload.bytes, 100).unwrap();
140 assert_eq!(value["id"], 1);
141 }
142
143 #[test]
144 fn exports_csv_with_headers_and_escaping() {
145 let rows = vec![BTreeMap::from([(
146 String::from("name"),
147 String::from("Ada, Lovelace"),
148 )])];
149 let payload = export_csv(&rows, "users.csv", 100).unwrap();
150 assert_eq!(
151 String::from_utf8(payload.bytes).unwrap(),
152 "name\n\"Ada, Lovelace\"\n"
153 );
154 }
155
156 #[test]
157 fn enforces_size_and_filename_safety() {
158 assert_eq!(
159 export_json(&json!({"large": "payload"}), "safe.json", 1),
160 Err(DataTransferError::TooLarge)
161 );
162 assert_eq!(
163 safe_filename("../secret.json"),
164 Err(DataTransferError::InvalidFilename)
165 );
166 assert_eq!(safe_filename("report.csv").unwrap(), "report.csv");
167 }
168}