use std::path::{Path, PathBuf};
use sha2::{Digest, Sha256};
pub const ENV_SPEC_DIR: &str = "FHIR_SQLITE_SPEC_DIR";
const ASSET_PREFIX: &str = "fhir-sqlite";
pub const VERSIONS: &[&str] = &["r3", "r4", "r5"];
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Artifact {
pub name: String,
pub sha256: String,
pub previous_sha256: Option<String>,
pub file_sha256: String,
pub rewritten: bool,
}
impl Artifact {
#[must_use]
pub fn is_current(&self) -> bool {
self.previous_sha256.as_deref() == Some(self.sha256.as_str())
}
}
#[derive(Debug)]
pub enum AssetError {
Definitions(PathBuf),
Generate(String),
Io(std::io::Error),
}
impl std::fmt::Display for AssetError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Definitions(p) => write!(f, "no FHIR definitions at {}", p.display()),
Self::Generate(m) => write!(f, "generate: {m}"),
Self::Io(e) => write!(f, "io: {e}"),
}
}
}
impl std::error::Error for AssetError {}
impl From<std::io::Error> for AssetError {
fn from(e: std::io::Error) -> Self {
Self::Io(e)
}
}
#[must_use]
pub fn definitions_root() -> Option<PathBuf> {
let candidates = [
std::env::var(ENV_SPEC_DIR).ok().map(PathBuf::from),
Some(PathBuf::from(concat!(
env!("CARGO_MANIFEST_DIR"),
"/../../../fhir/doc/fhir-specifications"
))),
];
candidates.into_iter().flatten().find(|p| p.exists())
}
#[must_use]
pub fn assets_root() -> PathBuf {
PathBuf::from(concat!(
env!("CARGO_MANIFEST_DIR"),
"/../fhir-sqlite-map/assets"
))
}
fn decompress(gz: &[u8]) -> Result<Vec<u8>, AssetError> {
use std::io::Read as _;
let mut out = Vec::new();
flate2::read::GzDecoder::new(gz)
.read_to_end(&mut out)
.map_err(AssetError::Io)?;
Ok(out)
}
fn hex(bytes: &[u8]) -> String {
use std::fmt::Write as _;
let mut s = String::with_capacity(bytes.len() * 2);
for b in bytes {
let _ = write!(s, "{b:02x}");
}
s
}
pub fn regenerate(
definitions: &Path,
assets: &Path,
write: bool,
) -> Result<Vec<Artifact>, AssetError> {
if !definitions.exists() {
return Err(AssetError::Definitions(definitions.to_path_buf()));
}
let mut out = Vec::new();
for ver in VERSIONS {
let defs = definitions.join(ver).join("fhir-definitions-json");
if !defs.exists() {
return Err(AssetError::Definitions(defs));
}
let map = crate::generate(&defs, ver).map_err(|e| AssetError::Generate(format!("{e}")))?;
let bytes = map
.to_gz_bytes()
.map_err(|e| AssetError::Generate(e.to_string()))?;
let content = decompress(&bytes)?;
let sha = hex(&Sha256::digest(&content));
let name = format!("{ASSET_PREFIX}-relmap-{ver}.json.gz");
let path = assets.join(&name);
let previous = std::fs::read(&path)
.ok()
.and_then(|b| decompress(&b).ok())
.map(|c| hex(&Sha256::digest(&c)));
let file_sha = hex(&Sha256::digest(&bytes));
let unchanged = previous.as_deref() == Some(sha.as_str());
if write && !unchanged {
std::fs::create_dir_all(assets)?;
std::fs::write(&path, &bytes)?;
}
out.push(Artifact {
name,
sha256: sha,
previous_sha256: previous,
file_sha256: file_sha,
rewritten: write && !unchanged,
});
}
if write {
let mut txt = String::new();
for a in &out {
use std::fmt::Write as _;
let _ = writeln!(txt, "{} {}", a.file_sha256, a.name);
}
std::fs::write(assets.join("CHECKSUMS.txt"), txt)?;
}
Ok(out)
}