Skip to main content

vibe/cbor_ast/cbor_ld/
json_uplift.rs

1//! Provider/TLD-Scoped Namespace Uplift for Incoming JSON into W3C CBOR-LD (`0xD9 0x0501`).
2
3use std::collections::BTreeMap;
4
5use super::terms::TAG_CBOR_LD_COMPRESSED;
6use super::value_codec::encode_value_cbor_ld;
7use crate::value::Value;
8
9/// Derives `(normalized_host, effective_tld, namespace_iri)` from a provider domain, URL, or TLD.
10pub fn derive_provider_namespace(
11    provider_host_or_tld: &str,
12) -> Result<(String, String, String), String> {
13    let raw = provider_host_or_tld.trim().to_ascii_lowercase();
14    if raw.is_empty() {
15        return Err("provider host or TLD must not be empty".into());
16    }
17    let is_tld_only = raw.starts_with('.');
18    let without_scheme = raw
19        .strip_prefix("https://")
20        .or_else(|| raw.strip_prefix("http://"))
21        .or_else(|| raw.strip_prefix("did:web:"))
22        .unwrap_or(&raw);
23    let authority = without_scheme
24        .split(&['/', '?', '#'][..])
25        .next()
26        .unwrap_or("");
27    let host_part = authority.split(':').next().unwrap_or("").trim_matches('.');
28    if host_part.is_empty() {
29        return Err(format!("invalid provider host or TLD: '{provider_host_or_tld}'"));
30    }
31    let labels: Vec<&str> = host_part.split('.').filter(|s| !s.is_empty()).collect();
32    if labels.is_empty() {
33        return Err(format!("invalid provider labels in '{provider_host_or_tld}'"));
34    }
35    let effective_tld = labels.last().copied().unwrap().to_string();
36    let normalized_host = if is_tld_only || labels.len() == 1 {
37        format!("tld.{host_part}")
38    } else {
39        host_part.to_string()
40    };
41    let namespace_iri = format!("https://{normalized_host}/ns#");
42    Ok((normalized_host, effective_tld, namespace_iri))
43}
44
45/// Parses raw JSON, uplifts all bare property keys into the provider's domain/TLD namespace
46/// (`https://{host}/ns#{key}`), and encodes the uplifted structure into compressed CBOR-LD (`0x0501`).
47pub fn ingest_json_with_provider_ns(
48    json_src: &str,
49    provider_host_or_tld: &str,
50) -> Result<Value, String> {
51    let (host, tld, ns_iri) = derive_provider_namespace(provider_host_or_tld)?;
52    let mut parser = JsonUpliftParser::new(json_src, &ns_iri);
53    let mut root = parser.parse_value()?;
54    parser.skip_ws();
55    if parser.pos < parser.bytes.len() {
56        return Err("trailing characters after JSON value".into());
57    }
58
59    match &mut root {
60        Value::Record(map) => {
61            map.entry("@context".to_string())
62                .or_insert_with(|| Value::String(ns_iri.clone()));
63            map.insert("@provider_host".to_string(), Value::String(host.clone()));
64            map.insert("@provider_tld".to_string(), Value::String(tld.clone()));
65        }
66        other => {
67            let mut wrapper = BTreeMap::new();
68            wrapper.insert("@context".to_string(), Value::String(ns_iri.clone()));
69            wrapper.insert("@provider_host".to_string(), Value::String(host.clone()));
70            wrapper.insert("@provider_tld".to_string(), Value::String(tld.clone()));
71            wrapper.insert(format!("{ns_iri}value"), other.clone());
72            root = Value::Record(wrapper);
73        }
74    }
75
76    let cbor_bytes = encode_value_cbor_ld(&root, &ns_iri);
77    let mut out = BTreeMap::new();
78    out.insert("__cbor_ld".to_string(), Value::Bool(true));
79    out.insert("tag".to_string(), Value::I64(TAG_CBOR_LD_COMPRESSED as i64));
80    out.insert("context".to_string(), Value::String(ns_iri));
81    out.insert("provider_host".to_string(), Value::String(host));
82    out.insert("provider_tld".to_string(), Value::String(tld));
83    out.insert("byte_len".to_string(), Value::I64(cbor_bytes.len() as i64));
84    out.insert("hex".to_string(), Value::String(super::hex_encode(&cbor_bytes)));
85    out.insert(
86        "bytes".to_string(),
87        Value::List(cbor_bytes.iter().map(|&b| Value::I64(b as i64)).collect()),
88    );
89    out.insert("uplifted".to_string(), root);
90    Ok(Value::Record(out))
91}
92
93fn uplift_key(raw_key: &str, ns_iri: &str) -> String {
94    if raw_key.starts_with('@') || raw_key.contains(':') {
95        raw_key.to_string()
96    } else {
97        format!("{ns_iri}{raw_key}")
98    }
99}
100
101struct JsonUpliftParser<'a> {
102    src: &'a str,
103    bytes: &'a [u8],
104    pos: usize,
105    ns_iri: &'a str,
106}
107
108impl<'a> JsonUpliftParser<'a> {
109    fn new(src: &'a str, ns_iri: &'a str) -> Self {
110        Self {
111            src,
112            bytes: src.as_bytes(),
113            pos: 0,
114            ns_iri,
115        }
116    }
117
118    fn skip_ws(&mut self) {
119        while self.pos < self.bytes.len() && self.bytes[self.pos].is_ascii_whitespace() {
120            self.pos += 1;
121        }
122    }
123
124    fn peek(&mut self) -> Option<u8> {
125        self.skip_ws();
126        self.bytes.get(self.pos).copied()
127    }
128
129    fn parse_value(&mut self) -> Result<Value, String> {
130        let b = self.peek().ok_or_else(|| "unexpected EOF in JSON".to_string())?;
131        match b {
132            b'{' => self.parse_object(),
133            b'[' => self.parse_array(),
134            b'"' => Ok(Value::String(self.parse_string()?)),
135            b't' | b'f' => self.parse_bool(),
136            b'n' => self.parse_null(),
137            b'-' | b'0'..=b'9' => self.parse_number(),
138            _ => Err(format!("unexpected JSON byte '{}'", b as char)),
139        }
140    }
141
142    fn parse_object(&mut self) -> Result<Value, String> {
143        self.pos += 1; // '{'
144        let mut map = BTreeMap::new();
145        if self.peek() == Some(b'}') {
146            self.pos += 1;
147            return Ok(Value::Record(map));
148        }
149        loop {
150            if self.peek() != Some(b'"') {
151                return Err("expected string key in JSON object".into());
152            }
153            let raw_key = self.parse_string()?;
154            let key = uplift_key(&raw_key, self.ns_iri);
155            if self.peek() != Some(b':') {
156                return Err("expected ':' after JSON object key".into());
157            }
158            self.pos += 1;
159            let val = self.parse_value()?;
160            map.insert(key, val);
161            match self.peek() {
162                Some(b',') => self.pos += 1,
163                Some(b'}') => {
164                    self.pos += 1;
165                    break;
166                }
167                _ => return Err("expected ',' or '}' in JSON object".into()),
168            }
169        }
170        Ok(Value::Record(map))
171    }
172
173    fn parse_array(&mut self) -> Result<Value, String> {
174        self.pos += 1; // '['
175        let mut items = Vec::new();
176        if self.peek() == Some(b']') {
177            self.pos += 1;
178            return Ok(Value::List(items));
179        }
180        loop {
181            items.push(self.parse_value()?);
182            match self.peek() {
183                Some(b',') => self.pos += 1,
184                Some(b']') => {
185                    self.pos += 1;
186                    break;
187                }
188                _ => return Err("expected ',' or ']' in JSON array".into()),
189            }
190        }
191        Ok(Value::List(items))
192    }
193
194    fn parse_string(&mut self) -> Result<String, String> {
195        self.skip_ws();
196        if self.bytes.get(self.pos) != Some(&b'"') {
197            return Err("expected '\"'".into());
198        }
199        self.pos += 1;
200        let mut out = String::new();
201        while self.pos < self.bytes.len() {
202            let b = self.bytes[self.pos];
203            self.pos += 1;
204            match b {
205                b'"' => return Ok(out),
206                b'\\' => {
207                    let esc = *self.bytes.get(self.pos).ok_or("EOF in string escape")?;
208                    self.pos += 1;
209                    match esc {
210                        b'"' => out.push('"'),
211                        b'\\' => out.push('\\'),
212                        b'/' => out.push('/'),
213                        b'n' => out.push('\n'),
214                        b'r' => out.push('\r'),
215                        b't' => out.push('\t'),
216                        _ => out.push(esc as char),
217                    }
218                }
219                _ => out.push(b as char),
220            }
221        }
222        Err("unterminated JSON string".into())
223    }
224
225    fn parse_bool(&mut self) -> Result<Value, String> {
226        if self.src[self.pos..].starts_with("true") {
227            self.pos += 4;
228            Ok(Value::Bool(true))
229        } else if self.src[self.pos..].starts_with("false") {
230            self.pos += 5;
231            Ok(Value::Bool(false))
232        } else {
233            Err("invalid boolean literal in JSON".into())
234        }
235    }
236
237    fn parse_null(&mut self) -> Result<Value, String> {
238        if self.src[self.pos..].starts_with("null") {
239            self.pos += 4;
240            Ok(Value::Null)
241        } else {
242            Err("invalid null literal in JSON".into())
243        }
244    }
245
246    fn parse_number(&mut self) -> Result<Value, String> {
247        self.skip_ws();
248        let start = self.pos;
249        let mut is_float = false;
250        while self.pos < self.bytes.len() {
251            match self.bytes[self.pos] {
252                b'0'..=b'9' | b'-' | b'+' => self.pos += 1,
253                b'.' | b'e' | b'E' => {
254                    is_float = true;
255                    self.pos += 1;
256                }
257                _ => break,
258            }
259        }
260        let token = &self.src[start..self.pos];
261        if is_float {
262            let f: f64 = token.parse().map_err(|_| format!("invalid float '{token}'"))?;
263            Ok(Value::F64(f))
264        } else {
265            let n: i64 = token.parse().map_err(|_| format!("invalid int '{token}'"))?;
266            Ok(Value::I64(n))
267        }
268    }
269}