vibe/cbor_ast/cbor_ld/
json_uplift.rs1use std::collections::BTreeMap;
4
5use super::terms::TAG_CBOR_LD_COMPRESSED;
6use super::value_codec::encode_value_cbor_ld;
7use crate::value::Value;
8
9pub 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
45pub 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; 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; 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}