use serde::de::DeserializeOwned;
use serde_json::Value;
use crate::error::{Error, Result};
pub const MAX_REPAIRS: usize = 16;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Repair {
Narrowed,
Dropped,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FieldRepair {
pub path: String,
pub reason: String,
pub repair: Repair,
}
impl FieldRepair {
#[must_use]
pub fn is_lossy(&self) -> bool {
self.repair == Repair::Dropped
}
}
impl std::fmt::Display for FieldRepair {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let what = match self.repair {
Repair::Narrowed => "narrowed to an integer",
Repair::Dropped => "dropped",
};
write!(f, "{} {what}: {}", self.path, self.reason)
}
}
pub fn deserialize<T: DeserializeOwned>(value: Value) -> Result<(T, Vec<FieldRepair>)> {
let mut value = value;
let mut repaired = Vec::new();
loop {
let mut track = serde_path_to_error::Track::new();
let de = serde_path_to_error::Deserializer::new(&value, &mut track);
match T::deserialize(de) {
Ok(model) => return Ok((model, repaired)),
Err(err) => {
let path = track.path().to_string();
let reason = err.to_string();
if path.is_empty() || path == "." {
return Err(Error::InvalidResponse(reason));
}
let distinct = repaired
.iter()
.map(|r: &FieldRepair| field_of(&r.path))
.chain(std::iter::once(field_of(&path)))
.collect::<std::collections::HashSet<_>>()
.len();
if distinct > MAX_REPAIRS {
return Err(Error::InvalidResponse(format!(
"gave up after repairing {MAX_REPAIRS} distinct mistyped fields; last was {path}: {reason}"
)));
}
let Some(repair) = repair_field(&mut value, &path) else {
return Err(Error::InvalidResponse(format!("{path}: {reason}")));
};
repaired.push(FieldRepair {
path,
reason,
repair,
});
},
}
}
}
fn narrow_value(cursor: &mut Value) -> bool {
const LIMIT: f64 = 9_223_372_036_854_775_808.0;
let Some(float) = cursor.as_f64() else {
return false;
};
if cursor.is_i64() || cursor.is_u64() {
return false; }
if float.fract() != 0.0 || !float.is_finite() {
return false;
}
if !(-LIMIT..LIMIT).contains(&float) {
return false;
}
#[allow(clippy::cast_possible_truncation)]
let exact = float as i64;
*cursor = Value::from(exact);
true
}
fn field_of(path: &str) -> String {
let mut out = String::with_capacity(path.len());
let mut in_index = false;
for c in path.chars() {
match c {
'[' => in_index = true,
']' => in_index = false,
_ if in_index => {},
c => out.push(c),
}
}
out.trim_start_matches('.').to_owned()
}
fn repair_field(root: &mut Value, path: &str) -> Option<Repair> {
let offender = kind_of(resolve(root, path)?);
let mut narrowed = false;
let mut dropped = false;
for cursor in resolve_siblings(root, path) {
if kind_of(cursor) != offender {
continue;
}
if narrow_value(cursor) {
narrowed = true;
} else if !cursor.is_null() {
*cursor = Value::Null;
dropped = true;
}
}
match (dropped, narrowed) {
(true, _) => Some(Repair::Dropped),
(false, true) => Some(Repair::Narrowed),
(false, false) => None,
}
}
fn kind_of(value: &Value) -> u8 {
match value {
Value::Null => 0,
Value::Bool(_) => 1,
Value::Number(_) => 2,
Value::String(_) => 3,
Value::Array(_) => 4,
Value::Object(_) => 5,
}
}
fn resolve_siblings<'v>(root: &'v mut Value, path: &str) -> Vec<&'v mut Value> {
fn walk<'v>(cursor: &'v mut Value, segments: &[Segment], out: &mut Vec<&'v mut Value>) {
let Some((head, tail)) = segments.split_first() else {
out.push(cursor);
return;
};
match head {
Segment::Key(key) => {
if let Some(next) = cursor.as_object_mut().and_then(|o| o.get_mut(key.as_str())) {
walk(next, tail, out);
}
},
Segment::Index(_) => {
if let Some(array) = cursor.as_array_mut() {
for item in array {
walk(item, tail, out);
}
}
},
}
}
let mut out = Vec::new();
walk(root, &segments(path), &mut out);
out
}
pub fn deserialize_lossy<T: DeserializeOwned>(value: Value) -> Result<T> {
deserialize(value).map(|(model, _)| model)
}
fn resolve<'v>(root: &'v mut Value, path: &str) -> Option<&'v mut Value> {
let mut cursor = root;
for segment in segments(path) {
cursor = match segment {
Segment::Key(key) => cursor.as_object_mut()?.get_mut(&key)?,
Segment::Index(index) => cursor.as_array_mut()?.get_mut(index)?,
};
}
Some(cursor)
}
enum Segment {
Key(String),
Index(usize),
}
fn segments(path: &str) -> Vec<Segment> {
let mut out = Vec::new();
for part in path.split('.') {
let (name, rest) = match part.find('[') {
Some(at) => (&part[..at], &part[at..]),
None => (part, ""),
};
if !name.is_empty() {
out.push(Segment::Key(name.to_owned()));
}
for index in rest.split(']').filter(|s| !s.is_empty()) {
if let Ok(index) = index.trim_start_matches('[').parse() {
out.push(Segment::Index(index));
}
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
use crate::models::{Search, Track};
#[test]
fn a_matching_payload_drops_nothing() {
let raw = serde_json::json!({ "id": 42, "title": "t", "available": true });
let (track, dropped): (Track, _) = deserialize(raw).unwrap();
assert_eq!(track.title.as_deref(), Some("t"));
assert_eq!(track.available, Some(true));
assert!(dropped.is_empty());
}
#[test]
fn a_boolean_that_became_an_array_costs_only_that_field() {
let raw = serde_json::json!({
"id": 42,
"title": "kept",
"available": true,
"best": ["not", "a", "boolean"],
});
let (track, dropped): (Track, _) = deserialize(raw).unwrap();
assert_eq!(
track.title.as_deref(),
Some("kept"),
"the rest of the track survives"
);
assert_eq!(track.available, Some(true));
assert_eq!(
track.best, None,
"the mistyped field is dropped, not guessed at"
);
assert_eq!(dropped.len(), 1);
assert_eq!(dropped[0].path, "best");
assert_eq!(dropped[0].repair, Repair::Dropped);
assert!(dropped[0].is_lossy());
assert!(
dropped[0].reason.contains("boolean"),
"{}",
dropped[0].reason
);
}
#[test]
fn a_json_float_standing_in_for_an_integer_is_narrowed_not_dropped() {
let raw = serde_json::json!({
"autoRenewable": [{ "product": { "price": { "amount": 0.0, "currency": "RUB" } } }],
});
let (subscription, repaired): (crate::models::Subscription, _) = deserialize(raw).unwrap();
let raw_int = serde_json::json!({ "id": 1, "durationMs": 210_000.0 });
let (track, track_repairs): (Track, _) = deserialize(raw_int).unwrap();
assert_eq!(
track.duration_ms,
Some(210_000),
"the value is kept, not dropped"
);
assert_eq!(track_repairs[0].repair, Repair::Narrowed);
assert!(!track_repairs[0].is_lossy(), "narrowing loses nothing");
assert!(repaired.is_empty());
let amount = subscription.auto_renewable[0]
.product
.as_ref()
.unwrap()
.price
.as_ref()
.unwrap()
.amount;
assert_eq!(amount, Some(0.0));
}
#[test]
fn a_float_with_a_real_fraction_is_dropped_rather_than_rounded() {
let raw = serde_json::json!({ "id": 1, "durationMs": 210_000.5 });
let (track, repaired): (Track, _) = deserialize(raw).unwrap();
assert_eq!(track.duration_ms, None);
assert_eq!(repaired[0].repair, Repair::Dropped);
}
#[test]
fn a_mistyped_field_deep_inside_a_search_response_is_reported_with_its_path() {
let raw = serde_json::json!({
"text": "query",
"tracks": {
"total": 2,
"results": [
{ "id": 1, "title": "first" },
{ "id": 2, "title": "second", "explicit": [] },
],
},
});
let (search, dropped): (Search, _) = deserialize(raw).unwrap();
assert_eq!(search.track_results().len(), 2, "both tracks still arrive");
assert_eq!(search.track_results()[1].title.as_deref(), Some("second"));
assert_eq!(dropped.len(), 1);
assert_eq!(dropped[0].path, "tracks.results[1].explicit");
assert_eq!(dropped[0].repair, Repair::Dropped);
}
#[test]
fn several_mistyped_fields_are_all_dropped_and_all_reported() {
let raw = serde_json::json!({
"id": 1,
"available": ["x"],
"explicit": 7,
"title": "kept",
});
let (track, dropped): (Track, _) = deserialize(raw).unwrap();
assert_eq!(track.title.as_deref(), Some("kept"));
assert_eq!(dropped.len(), 2);
let paths: Vec<&str> = dropped.iter().map(|d| d.path.as_str()).collect();
assert!(paths.contains(&"available"));
assert!(paths.contains(&"explicit"));
}
#[test]
fn a_mistyped_field_inside_a_nested_object_is_handled() {
let raw = serde_json::json!({ "id": 1, "major": { "id": 2, "name": ["a"] } });
let (track, dropped): (Track, _) = deserialize(raw).unwrap();
assert_eq!(track.major.as_ref().unwrap().id, Some(2));
assert_eq!(track.major.as_ref().unwrap().name, None);
assert_eq!(dropped[0].path, "major.name");
}
#[test]
fn a_wholly_wrong_document_still_fails() {
let err = deserialize::<Track>(serde_json::json!("not a track")).unwrap_err();
assert!(matches!(err, Error::InvalidResponse(_)));
}
#[test]
fn a_payload_needing_too_many_drops_fails_rather_than_arriving_empty() {
let mut raw = serde_json::Map::new();
for field in [
"available",
"explicit",
"best",
"canPublish",
"availableAsRbt",
"lyricsAvailable",
"rememberPosition",
"isSuitableForChildren",
"availableForPremiumUsers",
"availableFullWithoutPermission",
"durationMs",
"fileSize",
"previewDurationMs",
"title",
"type",
"coverUri",
"storageDir",
] {
raw.insert(field.into(), serde_json::json!(["wrong"]));
}
let err = deserialize::<Track>(Value::Object(raw)).unwrap_err();
assert!(matches!(err, Error::InvalidResponse(_)));
assert!(err.to_string().contains("gave up"), "{err}");
}
#[test]
fn the_lossy_helper_hides_the_report() {
let raw = serde_json::json!({ "id": 1, "best": [] });
let track: Track = deserialize_lossy(raw).unwrap();
assert_eq!(track.best, None);
}
#[test]
fn paths_split_into_keys_and_indices() {
let parsed: Vec<String> = segments("tracks.results[1].albums[0].title")
.iter()
.map(|s| match s {
Segment::Key(k) => k.clone(),
Segment::Index(i) => format!("#{i}"),
})
.collect();
assert_eq!(
parsed,
vec!["tracks", "results", "#1", "albums", "#0", "title"]
);
}
#[test]
fn a_flag_field_accepts_the_list_the_api_actually_sends() {
use crate::models::{FlagOrList, Status};
let as_list: Status =
deserialize_lossy(serde_json::json!({ "hasOptions": ["option-a", "option-b"] }))
.unwrap();
let options = as_list.has_options.unwrap();
assert!(options.is_set());
assert_eq!(options.list().len(), 2);
let as_flag: Status = deserialize_lossy(serde_json::json!({ "hasOptions": true })).unwrap();
assert!(as_flag.has_options.unwrap().is_set());
let empty_list: Status =
deserialize_lossy(serde_json::json!({ "hasOptions": [] })).unwrap();
assert!(
!empty_list.has_options.unwrap().is_set(),
"an empty list is not set"
);
assert!(!FlagOrList::Flag(false).is_set());
assert!(FlagOrList::Flag(true).list().is_empty());
}
#[test]
fn repairing_reports_whether_it_changed_anything() {
let mut value = serde_json::json!({ "a": { "b": [1, 2] } });
assert_eq!(repair_field(&mut value, "a.b[0]"), Some(Repair::Dropped));
assert_eq!(repair_field(&mut value, "a.b[0]"), None);
assert_eq!(repair_field(&mut value, "a.missing"), None);
assert_eq!(repair_field(&mut value, "a.b[9]"), None);
}
#[test]
fn one_bad_element_repairs_the_whole_list_in_a_single_pass() {
let mut value = serde_json::json!({ "items": [{ "id": 1 }, { "id": 2 }, { "id": 3 }] });
assert_eq!(
repair_field(&mut value, "items[0].id"),
Some(Repair::Dropped)
);
assert_eq!(
value,
serde_json::json!({ "items": [{ "id": null }, { "id": null }, { "id": null }] })
);
}
#[test]
fn a_sibling_of_a_different_json_type_is_left_alone() {
let mut value = serde_json::json!({ "items": [{ "id": 1 }, { "id": "ok" }, { "id": 3 }] });
assert_eq!(
repair_field(&mut value, "items[0].id"),
Some(Repair::Dropped)
);
assert_eq!(
value,
serde_json::json!({ "items": [{ "id": null }, { "id": "ok" }, { "id": null }] })
);
}
#[test]
fn a_field_path_ignores_the_array_positions_it_passes_through() {
assert_eq!(field_of("[16].id"), "id");
assert_eq!(field_of("tracks.results[0].best"), "tracks.results.best");
assert_eq!(field_of("plain.path"), "plain.path");
}
#[test]
fn the_budget_counts_distinct_fields_not_repeated_ones() {
#[derive(serde::Deserialize)]
struct Item {
#[serde(default)]
#[allow(dead_code)]
id: Option<String>,
}
let raw: Value = serde_json::from_str(&format!(
"[{}]",
(0..MAX_REPAIRS * 8)
.map(|i| format!(r#"{{"id":{i}}}"#))
.collect::<Vec<_>>()
.join(",")
))
.unwrap();
let (items, repaired): (Vec<Item>, _) = deserialize(raw).unwrap();
assert_eq!(items.len(), MAX_REPAIRS * 8);
assert_eq!(repaired.len(), 1);
}
}