appstruct-compiler 0.2.0

Parser, validator, and typed IR compiler for AppStruct application specifications
Documentation
use super::{MODULE_VERSION, preset_info};
use crate::loading::synthetic_span;
use crate::module::LoadedModule;
use crate::surface::SurfaceRoot;
use appstruct_ir::Diagnostic;
use serde::Deserialize;
use std::collections::BTreeMap;
use std::fmt::Write;
use std::fs;
use std::path::Path;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ProjectLayout {
    CompositionRoot = 2,
}

pub(super) fn source(
    template: &str,
    preset: Option<(&str, u64)>,
    layout: ProjectLayout,
    local_modules: &[LoadedModule],
) -> Option<String> {
    let mut output = format!(
        "lock_version = 1\nproject_layout_version = {}\nappstruct = {:?}\n\n[template]\nname = {template:?}\nversion = {:?}\n",
        layout as u64,
        env!("CARGO_PKG_VERSION"),
        env!("CARGO_PKG_VERSION"),
    );
    if let Some((name, version)) = preset {
        let info = preset_info(name, version)?;
        let _ = write!(
            output,
            "\n[preset]\nname = {:?}\nversion = {}\ndigest = {:?}\n\n[modules]\n",
            info.name, info.version, info.digest,
        );
        for module in info.modules {
            let _ = writeln!(output, "{module} = {MODULE_VERSION:?}");
        }
    }
    append_local_modules(&mut output, local_modules);
    Some(output)
}

fn append_local_modules(output: &mut String, modules: &[LoadedModule]) {
    let mut modules = modules.iter().collect::<Vec<_>>();
    modules.sort_by(|left, right| {
        left.manifest
            .name
            .cmp(&right.manifest.name)
            .then(left.manifest_path.cmp(&right.manifest_path))
    });
    for module in modules {
        let _ = write!(
            output,
            "\n[[local_modules]]\nname = {:?}\nversion = {:?}\nmanifest_path = {:?}\nmanifest_sha256 = {:?}\n",
            module.manifest.name,
            module.manifest.version,
            module.manifest_path,
            module.content_sha256,
        );
        for artifact in &module.artifacts {
            let _ = write!(
                output,
                "\n[[local_modules.artifacts]]\npath = {:?}\nsource = {:?}\nsha256 = {:?}\nbyte_len = {}\n",
                artifact.path,
                artifact.source.as_deref().unwrap_or_default(),
                artifact.sha256,
                artifact.byte_len,
            );
        }
    }
}

pub(super) fn layout(project: &Path) -> Result<ProjectLayout, Diagnostic> {
    let path = project.join("appstruct.lock");
    let source = match fs::read_to_string(path) {
        Ok(source) => source,
        Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
            return Ok(ProjectLayout::CompositionRoot);
        }
        Err(error) => {
            return Err(lock_error(
                "AS3064",
                format!("cannot read project layout from `appstruct.lock`: {error}"),
            ));
        }
    };
    let lock = toml::from_str::<ProjectLock>(&source).map_err(|error| {
        lock_error(
            "AS3064",
            format!("invalid project lock `appstruct.lock`: {error}"),
        )
    })?;
    if lock.lock_version != 1 || lock.appstruct != env!("CARGO_PKG_VERSION") {
        return Err(lock_error(
            "AS3064",
            "project lock version or AppStruct version does not match this compiler; run `appstruct update`",
        ));
    }
    parse_layout(lock.project_layout_version).ok_or_else(|| {
        lock_error(
            "AS3064",
            "project lock has no supported `project_layout_version`; run `appstruct update`",
        )
    })
}

pub(super) fn validate(project: &Path, root: &SurfaceRoot) -> Vec<Diagnostic> {
    if let Err(diagnostic) = layout(project) {
        return vec![diagnostic];
    }
    let Some(selected) = &root.preset else {
        return Vec::new();
    };
    let Some(info) = preset_info(&selected.name.value, selected.version.value) else {
        return vec![
            Diagnostic::error(
                "AS3058",
                format!(
                    "unsupported preset `{}@{}`",
                    selected.name.value, selected.version.value
                ),
                selected.name.span.clone(),
            )
            .with_help("this compiler supports `appstruct/saas` version 1"),
        ];
    };
    let path = project.join("appstruct.lock");
    let source = match fs::read_to_string(&path) {
        Ok(source) => source,
        Err(error) => {
            return vec![lock_error(
                "AS3059",
                format!("cannot read preset lock `appstruct.lock`: {error}"),
            )];
        }
    };
    let lock = match toml::from_str::<ProjectLock>(&source) {
        Ok(lock) => lock,
        Err(error) => {
            return vec![lock_error(
                "AS3059",
                format!("invalid preset lock `appstruct.lock`: {error}"),
            )];
        }
    };
    validate_contract(&lock, &info)
}

pub(super) fn validate_local_modules(
    project: &Path,
    local_modules: &[LoadedModule],
) -> Vec<Diagnostic> {
    let path = project.join("appstruct.lock");
    let source = match fs::read_to_string(path) {
        Ok(source) => source,
        Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
            if local_modules.is_empty() {
                return Vec::new();
            }
            return vec![local_module_lock_error(
                "local module provenance is not locked",
            )];
        }
        Err(error) => {
            return vec![local_module_lock_error(format!(
                "cannot read local module provenance: {error}"
            ))];
        }
    };
    let Ok(lock) = toml::from_str::<ProjectLock>(&source) else {
        return Vec::new();
    };
    let actual = local_modules
        .iter()
        .map(LockedLocalModule::from)
        .collect::<Vec<_>>();
    let mut actual = actual;
    actual.sort_by(|left, right| {
        left.name
            .cmp(&right.name)
            .then(left.manifest_path.cmp(&right.manifest_path))
    });
    if lock.local_modules == actual {
        Vec::new()
    } else {
        vec![local_module_lock_error(
            "local module manifest or artifact provenance has drifted",
        )]
    }
}

pub(super) fn updated_source(
    project: &Path,
    root: &SurfaceRoot,
    local_modules: &[LoadedModule],
) -> Result<String, Diagnostic> {
    let (template, layout) = read_update_metadata(project)?;
    let selected = root
        .preset
        .as_ref()
        .map(|preset| (preset.name.value.as_str(), preset.version.value));
    source(&template, selected, layout, local_modules).ok_or_else(|| {
        let preset = root
            .preset
            .as_ref()
            .expect("only presets can be unsupported");
        Diagnostic::error(
            "AS3058",
            format!(
                "unsupported preset `{}@{}`",
                preset.name.value, preset.version.value
            ),
            preset.name.span.clone(),
        )
        .with_help("this compiler supports `appstruct/saas` version 1")
    })
}

fn read_update_metadata(project: &Path) -> Result<(String, ProjectLayout), Diagnostic> {
    let path = project.join("appstruct.lock");
    let source = match fs::read_to_string(path) {
        Ok(source) => source,
        Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
            return Ok(("custom".to_owned(), ProjectLayout::CompositionRoot));
        }
        Err(error) => {
            return Err(lock_error(
                "AS3059",
                format!("cannot read preset lock `appstruct.lock`: {error}"),
            ));
        }
    };
    let lock = toml::from_str::<ProjectLock>(&source).map_err(|error| {
        lock_error(
            "AS3059",
            format!("invalid preset lock `appstruct.lock`: {error}"),
        )
    })?;
    let template = lock
        .template
        .map_or_else(|| "custom".to_owned(), |template| template.name);
    let layout = match lock.project_layout_version {
        Some(version) => parse_layout(Some(version)).ok_or_else(|| {
            lock_error(
                "AS3064",
                format!("unsupported project layout version `{version}`"),
            )
        })?,
        None => {
            return Err(lock_error(
                "AS3064",
                "project lock is missing `project_layout_version`; recreate the lock for the current composition-root layout",
            ));
        }
    };
    Ok((template, layout))
}

fn parse_layout(version: Option<u64>) -> Option<ProjectLayout> {
    match version {
        Some(2) => Some(ProjectLayout::CompositionRoot),
        Some(_) | None => None,
    }
}

fn validate_contract(lock: &ProjectLock, info: &super::PresetInfo) -> Vec<Diagnostic> {
    let mut diagnostics = Vec::new();
    if lock.lock_version != 1 || lock.appstruct != env!("CARGO_PKG_VERSION") {
        diagnostics.push(lock_error(
            "AS3060",
            "preset lock version or AppStruct version does not match this compiler",
        ));
    }
    if lock.preset.as_ref().is_none_or(|preset| {
        preset.name != info.name || preset.version != info.version || preset.digest != info.digest
    }) {
        diagnostics.push(lock_error(
            "AS3060",
            format!(
                "locked preset name, version, or digest does not match `{}@{}`",
                info.name, info.version
            ),
        ));
    }
    let expected_modules = info
        .modules
        .iter()
        .map(|name| ((*name).to_owned(), MODULE_VERSION.to_owned()))
        .collect::<BTreeMap<_, _>>();
    if lock.modules != expected_modules {
        diagnostics.push(lock_error(
            "AS3061",
            "locked preset module set or version is incomplete",
        ));
    }
    diagnostics
}

fn lock_error(code: &str, message: impl Into<String>) -> Diagnostic {
    Diagnostic::error(code, message, synthetic_span("appstruct.lock"))
}

fn local_module_lock_error(message: impl Into<String>) -> Diagnostic {
    Diagnostic::error("AS3065", message, synthetic_span("appstruct.lock"))
        .with_help("run `appstruct update` to refresh locked local module provenance")
}

#[derive(Debug, Deserialize)]
struct ProjectLock {
    lock_version: u64,
    project_layout_version: Option<u64>,
    appstruct: String,
    template: Option<LockedTemplate>,
    preset: Option<LockedPreset>,
    #[serde(default)]
    modules: BTreeMap<String, String>,
    #[serde(default)]
    local_modules: Vec<LockedLocalModule>,
}

#[derive(Debug, Deserialize, PartialEq, Eq)]
struct LockedLocalModule {
    name: String,
    version: String,
    manifest_path: String,
    manifest_sha256: String,
    #[serde(default)]
    artifacts: Vec<LockedModuleArtifact>,
}

impl From<&LoadedModule> for LockedLocalModule {
    fn from(module: &LoadedModule) -> Self {
        Self {
            name: module.manifest.name.clone(),
            version: module.manifest.version.clone(),
            manifest_path: module.manifest_path.clone(),
            manifest_sha256: module.content_sha256.clone(),
            artifacts: module
                .artifacts
                .iter()
                .map(|artifact| LockedModuleArtifact {
                    path: artifact.path.clone(),
                    source: artifact.source.clone().unwrap_or_default(),
                    sha256: artifact.sha256.clone(),
                    byte_len: artifact.byte_len,
                })
                .collect(),
        }
    }
}

#[derive(Debug, Deserialize, PartialEq, Eq)]
struct LockedModuleArtifact {
    path: String,
    source: String,
    sha256: String,
    byte_len: u64,
}

#[derive(Debug, Deserialize)]
struct LockedTemplate {
    name: String,
}

#[derive(Debug, Deserialize)]
struct LockedPreset {
    name: String,
    version: u64,
    digest: String,
}