Skip to main content

appstruct_compiler/preset/
lock.rs

1use super::{MODULE_VERSION, preset_info};
2use crate::loading::synthetic_span;
3use crate::module::LoadedModule;
4use crate::surface::SurfaceRoot;
5use appstruct_ir::Diagnostic;
6use serde::Deserialize;
7use std::collections::BTreeMap;
8use std::fmt::Write;
9use std::fs;
10use std::path::Path;
11
12#[derive(Clone, Copy, Debug, PartialEq, Eq)]
13pub enum ProjectLayout {
14    CompositionRoot = 2,
15}
16
17pub(super) fn source(
18    template: &str,
19    preset: Option<(&str, u64)>,
20    layout: ProjectLayout,
21    local_modules: &[LoadedModule],
22) -> Option<String> {
23    let mut output = format!(
24        "lock_version = 1\nproject_layout_version = {}\nappstruct = {:?}\n\n[template]\nname = {template:?}\nversion = {:?}\n",
25        layout as u64,
26        env!("CARGO_PKG_VERSION"),
27        env!("CARGO_PKG_VERSION"),
28    );
29    if let Some((name, version)) = preset {
30        let info = preset_info(name, version)?;
31        let _ = write!(
32            output,
33            "\n[preset]\nname = {:?}\nversion = {}\ndigest = {:?}\n\n[modules]\n",
34            info.name, info.version, info.digest,
35        );
36        for module in info.modules {
37            let _ = writeln!(output, "{module} = {MODULE_VERSION:?}");
38        }
39    }
40    append_local_modules(&mut output, local_modules);
41    Some(output)
42}
43
44fn append_local_modules(output: &mut String, modules: &[LoadedModule]) {
45    let mut modules = modules.iter().collect::<Vec<_>>();
46    modules.sort_by(|left, right| {
47        left.manifest
48            .name
49            .cmp(&right.manifest.name)
50            .then(left.manifest_path.cmp(&right.manifest_path))
51    });
52    for module in modules {
53        let _ = write!(
54            output,
55            "\n[[local_modules]]\nname = {:?}\nversion = {:?}\nmanifest_path = {:?}\nmanifest_sha256 = {:?}\n",
56            module.manifest.name,
57            module.manifest.version,
58            module.manifest_path,
59            module.content_sha256,
60        );
61        for artifact in &module.artifacts {
62            let _ = write!(
63                output,
64                "\n[[local_modules.artifacts]]\npath = {:?}\nsource = {:?}\nsha256 = {:?}\nbyte_len = {}\n",
65                artifact.path,
66                artifact.source.as_deref().unwrap_or_default(),
67                artifact.sha256,
68                artifact.byte_len,
69            );
70        }
71    }
72}
73
74pub(super) fn layout(project: &Path) -> Result<ProjectLayout, Diagnostic> {
75    let path = project.join("appstruct.lock");
76    let source = match fs::read_to_string(path) {
77        Ok(source) => source,
78        Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
79            return Ok(ProjectLayout::CompositionRoot);
80        }
81        Err(error) => {
82            return Err(lock_error(
83                "AS3064",
84                format!("cannot read project layout from `appstruct.lock`: {error}"),
85            ));
86        }
87    };
88    let lock = toml::from_str::<ProjectLock>(&source).map_err(|error| {
89        lock_error(
90            "AS3064",
91            format!("invalid project lock `appstruct.lock`: {error}"),
92        )
93    })?;
94    if lock.lock_version != 1 || lock.appstruct != env!("CARGO_PKG_VERSION") {
95        return Err(lock_error(
96            "AS3064",
97            "project lock version or AppStruct version does not match this compiler; run `appstruct update`",
98        ));
99    }
100    parse_layout(lock.project_layout_version).ok_or_else(|| {
101        lock_error(
102            "AS3064",
103            "project lock has no supported `project_layout_version`; run `appstruct update`",
104        )
105    })
106}
107
108pub(super) fn validate(project: &Path, root: &SurfaceRoot) -> Vec<Diagnostic> {
109    if let Err(diagnostic) = layout(project) {
110        return vec![diagnostic];
111    }
112    let Some(selected) = &root.preset else {
113        return Vec::new();
114    };
115    let Some(info) = preset_info(&selected.name.value, selected.version.value) else {
116        return vec![
117            Diagnostic::error(
118                "AS3058",
119                format!(
120                    "unsupported preset `{}@{}`",
121                    selected.name.value, selected.version.value
122                ),
123                selected.name.span.clone(),
124            )
125            .with_help("this compiler supports `appstruct/saas` version 1"),
126        ];
127    };
128    let path = project.join("appstruct.lock");
129    let source = match fs::read_to_string(&path) {
130        Ok(source) => source,
131        Err(error) => {
132            return vec![lock_error(
133                "AS3059",
134                format!("cannot read preset lock `appstruct.lock`: {error}"),
135            )];
136        }
137    };
138    let lock = match toml::from_str::<ProjectLock>(&source) {
139        Ok(lock) => lock,
140        Err(error) => {
141            return vec![lock_error(
142                "AS3059",
143                format!("invalid preset lock `appstruct.lock`: {error}"),
144            )];
145        }
146    };
147    validate_contract(&lock, &info)
148}
149
150pub(super) fn validate_local_modules(
151    project: &Path,
152    local_modules: &[LoadedModule],
153) -> Vec<Diagnostic> {
154    let path = project.join("appstruct.lock");
155    let source = match fs::read_to_string(path) {
156        Ok(source) => source,
157        Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
158            if local_modules.is_empty() {
159                return Vec::new();
160            }
161            return vec![local_module_lock_error(
162                "local module provenance is not locked",
163            )];
164        }
165        Err(error) => {
166            return vec![local_module_lock_error(format!(
167                "cannot read local module provenance: {error}"
168            ))];
169        }
170    };
171    let Ok(lock) = toml::from_str::<ProjectLock>(&source) else {
172        return Vec::new();
173    };
174    let actual = local_modules
175        .iter()
176        .map(LockedLocalModule::from)
177        .collect::<Vec<_>>();
178    let mut actual = actual;
179    actual.sort_by(|left, right| {
180        left.name
181            .cmp(&right.name)
182            .then(left.manifest_path.cmp(&right.manifest_path))
183    });
184    if lock.local_modules == actual {
185        Vec::new()
186    } else {
187        vec![local_module_lock_error(
188            "local module manifest or artifact provenance has drifted",
189        )]
190    }
191}
192
193pub(super) fn updated_source(
194    project: &Path,
195    root: &SurfaceRoot,
196    local_modules: &[LoadedModule],
197) -> Result<String, Diagnostic> {
198    let (template, layout) = read_update_metadata(project)?;
199    let selected = root
200        .preset
201        .as_ref()
202        .map(|preset| (preset.name.value.as_str(), preset.version.value));
203    source(&template, selected, layout, local_modules).ok_or_else(|| {
204        let preset = root
205            .preset
206            .as_ref()
207            .expect("only presets can be unsupported");
208        Diagnostic::error(
209            "AS3058",
210            format!(
211                "unsupported preset `{}@{}`",
212                preset.name.value, preset.version.value
213            ),
214            preset.name.span.clone(),
215        )
216        .with_help("this compiler supports `appstruct/saas` version 1")
217    })
218}
219
220fn read_update_metadata(project: &Path) -> Result<(String, ProjectLayout), Diagnostic> {
221    let path = project.join("appstruct.lock");
222    let source = match fs::read_to_string(path) {
223        Ok(source) => source,
224        Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
225            return Ok(("custom".to_owned(), ProjectLayout::CompositionRoot));
226        }
227        Err(error) => {
228            return Err(lock_error(
229                "AS3059",
230                format!("cannot read preset lock `appstruct.lock`: {error}"),
231            ));
232        }
233    };
234    let lock = toml::from_str::<ProjectLock>(&source).map_err(|error| {
235        lock_error(
236            "AS3059",
237            format!("invalid preset lock `appstruct.lock`: {error}"),
238        )
239    })?;
240    let template = lock
241        .template
242        .map_or_else(|| "custom".to_owned(), |template| template.name);
243    let layout = match lock.project_layout_version {
244        Some(version) => parse_layout(Some(version)).ok_or_else(|| {
245            lock_error(
246                "AS3064",
247                format!("unsupported project layout version `{version}`"),
248            )
249        })?,
250        None => {
251            return Err(lock_error(
252                "AS3064",
253                "project lock is missing `project_layout_version`; recreate the lock for the current composition-root layout",
254            ));
255        }
256    };
257    Ok((template, layout))
258}
259
260fn parse_layout(version: Option<u64>) -> Option<ProjectLayout> {
261    match version {
262        Some(2) => Some(ProjectLayout::CompositionRoot),
263        Some(_) | None => None,
264    }
265}
266
267fn validate_contract(lock: &ProjectLock, info: &super::PresetInfo) -> Vec<Diagnostic> {
268    let mut diagnostics = Vec::new();
269    if lock.lock_version != 1 || lock.appstruct != env!("CARGO_PKG_VERSION") {
270        diagnostics.push(lock_error(
271            "AS3060",
272            "preset lock version or AppStruct version does not match this compiler",
273        ));
274    }
275    if lock.preset.as_ref().is_none_or(|preset| {
276        preset.name != info.name || preset.version != info.version || preset.digest != info.digest
277    }) {
278        diagnostics.push(lock_error(
279            "AS3060",
280            format!(
281                "locked preset name, version, or digest does not match `{}@{}`",
282                info.name, info.version
283            ),
284        ));
285    }
286    let expected_modules = info
287        .modules
288        .iter()
289        .map(|name| ((*name).to_owned(), MODULE_VERSION.to_owned()))
290        .collect::<BTreeMap<_, _>>();
291    if lock.modules != expected_modules {
292        diagnostics.push(lock_error(
293            "AS3061",
294            "locked preset module set or version is incomplete",
295        ));
296    }
297    diagnostics
298}
299
300fn lock_error(code: &str, message: impl Into<String>) -> Diagnostic {
301    Diagnostic::error(code, message, synthetic_span("appstruct.lock"))
302}
303
304fn local_module_lock_error(message: impl Into<String>) -> Diagnostic {
305    Diagnostic::error("AS3065", message, synthetic_span("appstruct.lock"))
306        .with_help("run `appstruct update` to refresh locked local module provenance")
307}
308
309#[derive(Debug, Deserialize)]
310struct ProjectLock {
311    lock_version: u64,
312    project_layout_version: Option<u64>,
313    appstruct: String,
314    template: Option<LockedTemplate>,
315    preset: Option<LockedPreset>,
316    #[serde(default)]
317    modules: BTreeMap<String, String>,
318    #[serde(default)]
319    local_modules: Vec<LockedLocalModule>,
320}
321
322#[derive(Debug, Deserialize, PartialEq, Eq)]
323struct LockedLocalModule {
324    name: String,
325    version: String,
326    manifest_path: String,
327    manifest_sha256: String,
328    #[serde(default)]
329    artifacts: Vec<LockedModuleArtifact>,
330}
331
332impl From<&LoadedModule> for LockedLocalModule {
333    fn from(module: &LoadedModule) -> Self {
334        Self {
335            name: module.manifest.name.clone(),
336            version: module.manifest.version.clone(),
337            manifest_path: module.manifest_path.clone(),
338            manifest_sha256: module.content_sha256.clone(),
339            artifacts: module
340                .artifacts
341                .iter()
342                .map(|artifact| LockedModuleArtifact {
343                    path: artifact.path.clone(),
344                    source: artifact.source.clone().unwrap_or_default(),
345                    sha256: artifact.sha256.clone(),
346                    byte_len: artifact.byte_len,
347                })
348                .collect(),
349        }
350    }
351}
352
353#[derive(Debug, Deserialize, PartialEq, Eq)]
354struct LockedModuleArtifact {
355    path: String,
356    source: String,
357    sha256: String,
358    byte_len: u64,
359}
360
361#[derive(Debug, Deserialize)]
362struct LockedTemplate {
363    name: String,
364}
365
366#[derive(Debug, Deserialize)]
367struct LockedPreset {
368    name: String,
369    version: u64,
370    digest: String,
371}