pharos_runtime_static/

route_map.rs

#![allow(clippy::result_unit_err)]

use std::fs;
use std::path::Path;

use serde_json::Value;

/// Performs manifest value.
fn manifest_value(root: &Path) -> Result<Value, ()> {
    let text = fs::read_to_string(root.join("pharos.app.json")).map_err(|_| ())?;
    serde_json::from_str(&text).map_err(|_| ())
}

/// Performs manifest string.
fn manifest_string<'a>(manifest: &'a Value, path: &[&str]) -> Option<&'a str> {
    let mut value = manifest;
    for key in path {
        value = value.get(*key)?;
    }
    value.as_str().filter(|text| !text.is_empty())
}

/// Generates the bounded static route map for one built app artifact.
///
/// # Parameters
///
/// - `root`: Input consumed by [`crate::route_map::write_route_map`].
///
/// # Returns
///
/// Returns the successful value produced by [`crate::route_map::write_route_map`] or an error when the operation fails.
///
/// # Errors
///
/// Returns an error value when [`crate::route_map::write_route_map`] cannot complete successfully.
///
/// # Performance
///
/// Performance is proportional to the size of the supplied inputs and any parsed or loaded data consumed by [`crate::route_map::write_route_map`].
///
/// # Examples
///
/// ```rust,ignore
/// let _result = pharos_runtime_static::route_map::write_route_map(std::path::Path::new("."));
/// ```
///
/// # Related
///
/// - [`crate::route_map`] for adjacent helpers that share the same runtime surface.
pub fn write_route_map(root: &Path) -> Result<(), ()> {
    if root.as_os_str().is_empty() || !root.is_dir() {
        return Err(());
    }
    let manifest = manifest_value(root)?;
    let routes_path = root.join("data/contracts/routes.json");
    let routes_text = fs::read_to_string(routes_path).map_err(|_| ())?;
    let routes = serde_json::from_str::<Value>(&routes_text)
        .map_err(|_| ())?
        .get("routes")
        .and_then(Value::as_array)
        .cloned()
        .ok_or(())?;
    let host_profile = manifest_string(&manifest, &["runtime", "host_profile"]);
    let mut lines = Vec::new();
    for route in routes {
        if route.get("kind").and_then(Value::as_str) != Some("page") {
            continue;
        }
        let path = route.get("path").and_then(Value::as_str).ok_or(())?;
        let Some(artifact) = route.get("artifact").and_then(Value::as_str) else {
            if host_profile == Some("static-pages") {
                return Err(());
            }
            continue;
        };
        let (artifact, content_type) = resolve_declared_page_artifact(root, artifact).ok_or(())?;
        lines.push(format!("GET\t{path}\t{artifact}\t{content_type}\t200"));
        if path == "/" && artifact == "index.html" {
            lines.push(format!("GET\t/index.html\t{artifact}\t{content_type}\t200"));
        }
    }
    append_html_subtree_routes(root, "html", 0, &mut lines)?;
    if host_profile == Some("static-pages") && lines.is_empty() {
        return Err(());
    }
    lines.sort();
    let map_path = root.join("runtime-route-map.tsv");
    pharos_runtime_core::fs::write_file_within(
        root,
        &map_path,
        format!("{}\n", lines.join("\n")).as_bytes(),
        0o644,
    )
    .map_err(|_| ())
}

fn append_html_subtree_routes(
    root: &Path,
    relative_dir: &str,
    depth: usize,
    lines: &mut Vec<String>,
) -> Result<(), ()> {
    if depth > 16 || relative_dir.is_empty() || relative_dir.contains("..") {
        return Err(());
    }
    let dir = root.join(relative_dir);
    if !dir.is_dir() {
        return Ok(());
    }
    for entry in fs::read_dir(&dir).map_err(|_| ())? {
        let entry = entry.map_err(|_| ())?;
        let name = entry.file_name();
        let name = name.to_str().ok_or(())?;
        if name.starts_with('.') {
            continue;
        }
        let child_relative = format!("{relative_dir}/{name}");
        let metadata = entry.metadata().map_err(|_| ())?;
        if metadata.is_dir() {
            append_html_subtree_routes(root, &child_relative, depth + 1, lines)?;
            continue;
        }
        if !metadata.is_file() {
            continue;
        }
        let route_path = format!("/{child_relative}");
        let content_type = content_type_for_artifact(&child_relative);
        lines.push(format!(
            "GET\t{route_path}\t{child_relative}\t{content_type}\t200"
        ));
    }
    Ok(())
}

/// Resolves one explicitly declared page artifact under the app root.
fn resolve_declared_page_artifact(root: &Path, artifact: &str) -> Option<(String, &'static str)> {
    if artifact.is_empty() || Path::new(artifact).is_absolute() || artifact.contains("..") {
        return None;
    }
    let path = root.join(artifact);
    path.is_file()
        .then(|| (artifact.to_owned(), "text/html; charset=utf-8"))
}

fn content_type_for_artifact(artifact: &str) -> &'static str {
    if artifact.ends_with(".html") {
        "text/html; charset=utf-8"
    } else if artifact.ends_with(".css") {
        "text/css; charset=utf-8"
    } else if artifact.ends_with(".js") {
        "application/javascript; charset=utf-8"
    } else if artifact.ends_with(".svg") {
        "image/svg+xml"
    } else if artifact.ends_with(".png") {
        "image/png"
    } else if artifact.ends_with(".woff2") {
        "font/woff2"
    } else if artifact.ends_with(".woff") {
        "font/woff"
    } else {
        "application/octet-stream"
    }
}

#[cfg(test)]
mod tests {
    use super::write_route_map;

    fn root(label: &str) -> std::path::PathBuf {
        let nonce = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .expect("clock")
            .as_nanos();
        std::env::temp_dir().join(format!(
            "pharos-route-map-{label}-{}-{nonce}",
            std::process::id()
        ))
    }

    #[test]
    /// Emits a concrete /index.html alias for the mounted root page artifact.
    fn write_route_map_includes_root_index_alias() {
        let root = root("index-alias");
        std::fs::create_dir_all(root.join("data/contracts")).expect("contracts dir");
        std::fs::write(root.join("index.html"), "<html></html>").expect("index");
        std::fs::write(
            root.join("pharos.app.json"),
            r#"{"runtime":{"host_profile":"static-pages"}}"#,
        )
        .expect("manifest");
        std::fs::write(
            root.join("data/contracts/routes.json"),
            r#"{"routes":[{"kind":"page","path":"/","artifact":"index.html"}]}"#,
        )
        .expect("routes");
        write_route_map(&root).expect("write route map");
        let text = std::fs::read_to_string(root.join("runtime-route-map.tsv")).expect("route map");
        assert!(text.contains("GET\t/\tindex.html\ttext/html; charset=utf-8\t200"));
        assert!(text.contains("GET\t/index.html\tindex.html\ttext/html; charset=utf-8\t200"));
        std::fs::remove_dir_all(root).expect("cleanup");
    }
}