use core::fmt;
use fhir_types::codec::Object;
use fhir_types::codec::Value;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Breach {
key: &'static str,
location: String,
}
impl Breach {
#[must_use]
pub const fn key(&self) -> &'static str {
self.key
}
#[must_use]
pub fn location(&self) -> &str {
&self.location
}
}
impl fmt::Display for Breach {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{} breaks {}", self.location, self.key)
}
}
impl core::error::Error for Breach {}
pub fn check(document: &Value) -> Result<(), Breach> {
let root = document
.get("resourceType")
.and_then(Value::as_str)
.unwrap_or("Resource");
walk(document, root)
}
fn walk(value: &Value, at: &str) -> Result<(), Breach> {
match value {
Value::Object(object) => {
for (key, member) in object {
let below = format!("{at}.{key}");
if key == "extension" || key == "modifierExtension" {
extensions(member, &below)?;
}
walk(member, &below)?;
}
Ok(())
}
Value::Array(items) => {
for (index, item) in items.iter().enumerate() {
walk(item, &format!("{at}[{index}]"))?;
}
Ok(())
}
_ => Ok(()),
}
}
fn extensions(member: &Value, at: &str) -> Result<(), Breach> {
let Value::Array(items) = member else {
return Ok(());
};
for (index, item) in items.iter().enumerate() {
if let Value::Object(extension) = item
&& valued(extension) == extension.contains_key("extension")
{
return Err(Breach {
key: "ext-1",
location: format!("{at}[{index}]"),
});
}
}
Ok(())
}
fn valued(extension: &Object) -> bool {
extension.keys().any(|key| {
key.strip_prefix("value")
.and_then(|suffix| suffix.chars().next())
.is_some_and(char::is_uppercase)
})
}
#[cfg(test)]
mod tests {
use super::check;
use fhir_types::codec::Value;
fn document(json: &serde_json::Value) -> Value {
Value::from_serde_json(json.clone())
}
#[test]
fn an_extension_with_a_url_and_no_value_breaks_ext_1() {
let condition = document(&serde_json::json!({
"resourceType": "Condition",
"code": {"coding": [{"system": "http://example.org/cs", "code": "c",
"extension": [{"url": "http://example.org/certainty"}]}]}
}));
let breach = check(&condition).expect_err("a url alone breaks ext-1");
assert_eq!(breach.key(), "ext-1");
assert_eq!(breach.location(), "Condition.code.coding[0].extension[0]");
}
#[test]
fn an_extension_with_a_value_and_extensions_breaks_ext_1() {
let patient = document(&serde_json::json!({
"resourceType": "Patient",
"extension": [{"url": "http://example.org/e", "valueString": "x",
"extension": [{"url": "part", "valueCode": "y"}]}]
}));
let breach = check(&patient).expect_err("both break ext-1");
assert_eq!(breach.location(), "Patient.extension[0]");
}
#[test]
fn a_primitive_sibling_extension_and_a_modifier_extension_are_held_too() {
let patient = document(&serde_json::json!({
"resourceType": "Patient",
"_gender": {"extension": [{"url": "http://example.org/e"}]}
}));
assert_eq!(
check(&patient).map_err(|breach| breach.location().to_owned()),
Err(String::from("Patient._gender.extension[0]"))
);
let observation = document(&serde_json::json!({
"resourceType": "Observation",
"modifierExtension": [{"url": "http://example.org/m"}]
}));
assert!(check(&observation).is_err());
}
#[test]
fn valued_and_nested_extensions_hold_ext_1() {
let patient = document(&serde_json::json!({
"resourceType": "Patient",
"extension": [
{"url": "http://example.org/a", "valueCodeableConcept": {"text": "t"}},
{"url": "http://example.org/b", "extension": [{"url": "part", "valueString": "p"}]}
],
"_gender": {"extension": [{"url": "http://example.org/e", "valueBoolean": true}]}
}));
assert_eq!(check(&patient), Ok(()));
}
}