appstruct_compiler/preset/
lock.rs1use 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}