Skip to main content

yaiko_core/
data_transfer.rs

1//! Bounded data export/import helpers for JSON and CSV payloads.
2
3use 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}