use serde::Serialize;
use std::collections::BTreeSet;
use std::path::{Path, PathBuf};
use serde_json::{Map, Value};
use sha2::{Digest, Sha256};
const FINGERPRINT_DOMAIN: &str = "muse.msp.schema-bundle";
const NORMALIZATION_VERSION: u16 = 1;
const STABILITY_KEY: &str = "x-msp-stability";
const OPENNESS_KEY: &str = "x-msp-openness";
#[derive(Serialize)]
struct FingerprintMaterialV1<'a> {
normalization_version: u16,
domain: &'static str,
experimental: bool,
document: &'a Value,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[allow(dead_code)]
pub enum BundleVariant {
Stable,
Experimental,
}
impl BundleVariant {
fn is_experimental(self) -> bool {
matches!(self, Self::Experimental)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum FingerprintError {
UnparseableDocument {
detail: String,
},
DanglingReference {
target: String,
},
EmptiedEnum {
owner: String,
},
UnencodablePreimage {
detail: String,
},
}
impl std::fmt::Display for FingerprintError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::UnparseableDocument { detail } => {
write!(
f,
"bundle document is not valid JSON, refusing to fingerprint: {detail}"
)
}
Self::UnencodablePreimage { detail } => {
write!(f, "fingerprint preimage could not be encoded: {detail}")
}
Self::EmptiedEnum { owner } => write!(
f,
"refusing to fingerprint: stripping experimental surface left \
`{owner}` with an empty `oneOf`, which no value can satisfy"
),
Self::DanglingReference { target } => write!(
f,
"refusing to fingerprint: stripping experimental surface left a \
reference to `{target}`, which the stable document no longer \
defines"
),
}
}
}
impl std::error::Error for FingerprintError {}
pub fn stable_fingerprint_of_bundle_bytes(bytes: &[u8]) -> Result<String, FingerprintError> {
bundle_fingerprint(BundleVariant::Stable, bytes)
}
pub fn rerun_watch_paths(vendored: &Path, live: &Path, build_dir: &Path) -> Vec<PathBuf> {
let mut watched = Vec::with_capacity(2);
if vendored.is_file() {
watched.push(vendored.to_path_buf());
} else {
watched.push(build_dir.to_path_buf());
}
if live.is_file() {
watched.push(live.to_path_buf());
}
watched
}
pub fn bundle_fingerprint(
variant: BundleVariant,
bytes: &[u8],
) -> Result<String, FingerprintError> {
let mut document: Value =
serde_json::from_slice(bytes).map_err(|error| FingerprintError::UnparseableDocument {
detail: error.to_string(),
})?;
if !variant.is_experimental() {
let removed = strip_experimental_surface(&mut document);
if let Some(target) = first_dangling_reference(&document, &removed) {
return Err(FingerprintError::DanglingReference { target });
}
if let Some(owner) = first_emptied_enum(&document) {
return Err(FingerprintError::EmptiedEnum { owner });
}
}
let document = sorted_value(&document);
let material = FingerprintMaterialV1 {
normalization_version: NORMALIZATION_VERSION,
domain: FINGERPRINT_DOMAIN,
experimental: variant.is_experimental(),
document: &document,
};
let encoded =
serde_json::to_vec(&material).map_err(|error| FingerprintError::UnencodablePreimage {
detail: error.to_string(),
})?;
Ok(render_sha256(&Sha256::digest(&encoded)))
}
fn render_sha256(digest: &[u8]) -> String {
use std::fmt::Write as _;
let mut rendered = String::with_capacity(7 + digest.len() * 2);
rendered.push_str("sha256:");
for byte in digest {
let _ = write!(rendered, "{byte:02x}");
}
rendered
}
fn is_experimental(value: &Value) -> bool {
value.get(STABILITY_KEY).and_then(Value::as_str) == Some("experimental")
}
fn strip_experimental_surface(value: &mut Value) -> BTreeSet<String> {
let removed = removed_definition_names(value);
remove_experimental_elements(value);
collapse_single_branch_enums(value);
removed
}
fn removed_definition_names(value: &Value) -> BTreeSet<String> {
value
.get("$defs")
.and_then(Value::as_object)
.map(|defs| {
defs.iter()
.filter(|(_, node)| is_experimental(node))
.map(|(name, _)| name.clone())
.collect()
})
.unwrap_or_default()
}
fn first_dangling_reference(value: &Value, removed: &BTreeSet<String>) -> Option<String> {
if removed.is_empty() {
return None;
}
match value {
Value::Object(map) => {
if let Some(target) = map
.get("$ref")
.and_then(Value::as_str)
.and_then(|reference| reference.strip_prefix("#/$defs/"))
&& removed.contains(target)
{
return Some(target.to_owned());
}
map.values()
.find_map(|member| first_dangling_reference(member, removed))
}
Value::Array(items) => items
.iter()
.find_map(|item| first_dangling_reference(item, removed)),
_ => None,
}
}
fn remove_experimental_elements(value: &mut Value) {
match value {
Value::Object(map) => {
let mut removed_properties: Vec<String> = Vec::new();
for (key, member) in map.iter_mut() {
match member {
Value::Object(children) => {
if key == "properties" {
removed_properties.extend(
children
.iter()
.filter(|(_, child)| is_experimental(child))
.map(|(name, _)| name.clone()),
);
}
children.retain(|_, child| !is_experimental(child));
}
Value::Array(items) => items.retain(|item| !is_experimental(item)),
_ => {}
}
}
if !removed_properties.is_empty()
&& let Some(Value::Array(required)) = map.get_mut("required")
{
required.retain(|entry| {
entry
.as_str()
.is_none_or(|name| !removed_properties.iter().any(|gone| gone == name))
});
if required.is_empty() {
map.remove("required");
}
}
for (_, member) in map.iter_mut() {
remove_experimental_elements(member);
}
}
Value::Array(items) => {
items.retain(|item| !is_experimental(item));
for item in items {
remove_experimental_elements(item);
}
}
_ => {}
}
}
fn collapse_single_branch_enums(value: &mut Value) {
match value {
Value::Object(map) => {
if let Some(collapsed) = lone_string_enum_branch(map) {
map.remove("oneOf");
for (key, entry) in collapsed {
map.insert(key, entry);
}
}
for (_, member) in map.iter_mut() {
collapse_single_branch_enums(member);
}
}
Value::Array(items) => {
for item in items {
collapse_single_branch_enums(item);
}
}
_ => {}
}
}
fn lone_string_enum_branch(map: &Map<String, Value>) -> Option<Vec<(String, Value)>> {
let branches = map.get("oneOf")?.as_array()?;
let [branch] = branches.as_slice() else {
return None;
};
let branch = branch.as_object()?;
let familiar = branch
.keys()
.all(|key| matches!(key.as_str(), "type" | "enum" | OPENNESS_KEY));
if !familiar || branch.get("type")?.as_str()? != "string" {
return None;
}
let entries = branch.get("enum")?.as_array()?;
Some(vec![
("type".to_owned(), Value::String("string".to_owned())),
("enum".to_owned(), Value::Array(entries.clone())),
])
}
fn first_emptied_enum(document: &Value) -> Option<String> {
let defs = document.get("$defs")?.as_object()?;
defs.iter()
.find(|(_, node)| {
node.get("oneOf")
.and_then(Value::as_array)
.is_some_and(|branches| branches.is_empty())
})
.map(|(name, _)| name.clone())
}
fn sorted_value(value: &Value) -> Value {
match value {
Value::Object(map) => {
let mut entries: Vec<(&String, &Value)> = map.iter().collect();
entries.sort_by(|a, b| a.0.cmp(b.0));
let mut sorted = Map::new();
for (key, child) in entries {
sorted.insert(key.clone(), sorted_value(child));
}
Value::Object(sorted)
}
Value::Array(items) => Value::Array(items.iter().map(sorted_value).collect()),
other => other.clone(),
}
}