1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
use anyhow::{Context, Result};
use std::path::PathBuf;
use std::process;
use crate::cli::pipeline::run_optional;
use crate::cli::{cache, commands, dispatch, pipeline};
use super::args::*;
use super::dispatch::DispatchContext;
use super::helpers::*;
pub(crate) fn handle(command: Commands, context: &DispatchContext) -> Result<Option<Commands>> {
let config_path = &context.config_path;
match command {
Commands::Init { lang, format } => {
eprintln!("Initializing alef project");
if let Some(langs) = &lang {
eprintln!(" Languages: {}", langs.join(", "));
}
pipeline::init(config_path, lang.clone())?;
eprintln!(" Created alef.toml");
// Load the generated config and bootstrap the project
let (_workspace, resolved) = load_config(config_path)?;
let resolved_cfg = &resolved[0];
let languages = resolve_languages(resolved_cfg, lang.as_deref())?;
let base_dir = std::env::current_dir()?;
// Extract API surface
let api = pipeline::extract(resolved_cfg, config_path, false)?;
let sources_hash = cache::sources_hash(&resolved_cfg.sources)?;
// Generate bindings
eprintln!(" Generating bindings...");
let bindings = pipeline::generate(&api, resolved_cfg, &languages, false, config_path)?;
let mut binding_count: usize = 0;
let mut all_paths = std::collections::HashSet::new();
for (lang_key, lang_files) in &bindings {
for file in lang_files {
all_paths.insert(base_dir.join(&file.path));
}
let single = vec![(*lang_key, lang_files.clone())];
binding_count += pipeline::write_files(&single, &base_dir)?;
}
// Scaffold package manifests and lint configs
eprintln!(" Generating scaffolding...");
let scaffold_files = pipeline::scaffold(&api, resolved_cfg, &languages)?;
let scaffold_count = pipeline::write_scaffold_files(&scaffold_files, &base_dir)?;
for file in &scaffold_files {
all_paths.insert(base_dir.join(&file.path));
}
// Format generated code only when --format is requested.
if format {
eprintln!(" Formatting...");
pipeline::fmt_post_generate(resolved_cfg, &languages);
}
// Finalise per-file hashes after formatting.
let alef_toml_bytes = cache::read_alef_toml_bytes(config_path);
pipeline::finalize_hashes(&all_paths, &sources_hash, &alef_toml_bytes)?;
println!("Initialized: {binding_count} binding files, {scaffold_count} scaffold files");
Ok(None)
}
Commands::Schema {
output,
schema_version,
check,
} => {
let version = schema_version.as_deref().unwrap_or(env!("CARGO_PKG_VERSION"));
if check {
crate::core::config::check_alef_config_schema(&output, version)?;
println!("Schema is up to date: {}", output.display());
} else {
crate::core::config::write_alef_config_schema(&output, version)?;
println!("Wrote schema to {}", output.display());
}
Ok(None)
}
Commands::Migrate { path, write } => {
let migrate_path = path.unwrap_or_else(|| context.config_path.clone());
let options = commands::migrate::MigrateOptions {
path: migrate_path,
write,
};
commands::migrate::run(options)?;
Ok(None)
}
Commands::E2e { action } => {
let (_workspace, resolved) = load_config(config_path)?;
let crates_to_process = dispatch::select_crates(&resolved, &context.crate_filter)?;
// E2e operates on per-crate e2e config. Use first crate that has an
// e2e section, or error if none has one. For multi-crate workspaces,
// all crates with an e2e section are processed in the loop below.
// The action dispatch still uses the first crate's e2e config for
// non-Generate actions (Init, Scaffold, List, Validate) since those
// are fixture-directory operations.
let resolved_cfg = crates_to_process
.iter()
.find(|c| c.e2e.is_some())
.copied()
.unwrap_or_else(|| crates_to_process[0]);
let e2e_config = resolved_cfg.e2e.as_ref().context("no [e2e] section in alef.toml")?;
match action {
E2eAction::Generate { lang, registry, format } => {
if registry {
eprintln!(
"warning: `alef e2e generate --registry` is deprecated. \
Use `alef test-apps generate` instead. \
`alef e2e generate` is local-mode only."
);
}
let config_toml = std::fs::read_to_string(config_path)?;
let base_dir = std::env::current_dir()?;
let mut grand_count: usize = 0;
for e2e_crate in &crates_to_process {
let Some(this_e2e_config) = e2e_crate.e2e.as_ref() else {
continue;
};
let fixtures_dir = std::path::Path::new(&this_e2e_config.fixtures);
let fixture_hash = cache::hash_directory(fixtures_dir).unwrap_or_default();
let api = pipeline::extract(e2e_crate, config_path, false)?;
let ir_json = serde_json::to_string(&api)?;
let cache_key = if registry { "e2e-registry" } else { "e2e" };
let stage_hash = cache::compute_stage_hash(&ir_json, cache_key, &config_toml, &fixture_hash);
if cache::is_stage_cached(&e2e_crate.name, cache_key, &stage_hash) {
println!("E2E tests up to date (cached)");
continue;
}
// When --registry is set (deprecated path), clone the e2e config
// and switch to registry dependency mode.
let effective_e2e_config;
let e2e_ref = if registry {
let mut cloned = this_e2e_config.clone();
cloned.dep_mode = crate::core::config::e2e::DependencyMode::Registry;
effective_e2e_config = cloned;
eprintln!("Generating e2e test apps (registry mode)...");
&effective_e2e_config
} else {
eprintln!("Generating e2e test suites...");
this_e2e_config
};
let languages = lang.as_deref();
let files = crate::e2e::generate_e2e(e2e_crate, e2e_ref, languages, &api.types, &api.enums)?;
let sources_hash = cache::sources_hash(&e2e_crate.sources)?;
let alef_toml_bytes = cache::read_alef_toml_bytes(config_path);
let count = pipeline::write_scaffold_files_with_overwrite(&files, &base_dir, true)?;
if format {
crate::e2e::format::run_formatters(&files, e2e_ref);
}
let output_paths: Vec<PathBuf> = files.iter().map(|f| base_dir.join(&f.path)).collect();
let path_set: std::collections::HashSet<PathBuf> = output_paths.iter().cloned().collect();
pipeline::finalize_hashes(&path_set, &sources_hash, &alef_toml_bytes)?;
// Sweep orphan alef-generated files scoped to effective_output() of
// the current mode — local mode sweeps e2e/, registry mode sweeps
// test_apps/. This prevents each mode from deleting the other's files.
let e2e_output_root = base_dir.join(e2e_ref.effective_output());
let sweep_roots: Vec<PathBuf> = if lang.is_some() {
// Derive sweep roots from the top-level subdirectories of the
// e2e output root that appear in the generated file set. Each
// generator writes into `<output>/<lang>/`, so taking the first
// two path components relative to the e2e root gives us the
// per-language directory.
let mut seen = std::collections::HashSet::new();
for path in &output_paths {
if let Ok(rel) = path.strip_prefix(&e2e_output_root) {
if let Some(top) = rel.components().next() {
let lang_dir = e2e_output_root.join(top.as_os_str());
seen.insert(lang_dir);
}
}
}
seen.into_iter().collect()
} else {
vec![e2e_output_root]
};
pipeline::sweep_orphans(&sweep_roots, &path_set)?;
cache::write_stage_hash(&e2e_crate.name, cache_key, &stage_hash, &output_paths)?;
grand_count += count;
}
println!("Generated {grand_count} e2e files");
Ok(None)
}
E2eAction::Init => {
eprintln!("Initializing e2e fixtures directory...");
let created = crate::e2e::scaffold::init_fixtures(e2e_config, resolved_cfg)?;
for path in &created {
println!(" created {path}");
}
println!("Initialized {} file(s)", created.len());
Ok(None)
}
E2eAction::Scaffold {
id,
category,
description,
} => {
let path =
crate::e2e::scaffold::scaffold_fixture(e2e_config, resolved_cfg, &id, &category, &description)?;
println!("Created {path}");
Ok(None)
}
E2eAction::List => {
let fixtures_dir = std::path::Path::new(&e2e_config.fixtures);
let fixtures = crate::e2e::fixture::load_fixtures(fixtures_dir)
.with_context(|| format!("failed to load fixtures from {}", fixtures_dir.display()))?;
let groups = crate::e2e::fixture::group_fixtures(&fixtures);
println!("Fixtures: {} total", fixtures.len());
for group in &groups {
println!(" {}: {} fixture(s)", group.category, group.fixtures.len());
}
Ok(None)
}
E2eAction::Validate => {
let fixtures_dir = std::path::Path::new(&e2e_config.fixtures);
eprintln!("Validating fixtures in {}...", fixtures_dir.display());
// Schema validation
let mut all_errors = crate::e2e::validate::validate_fixtures(fixtures_dir)
.with_context(|| format!("failed to validate fixtures from {}", fixtures_dir.display()))?;
// Semantic validation
let fixtures = crate::e2e::fixture::load_fixtures(fixtures_dir)
.with_context(|| format!("failed to load fixtures from {}", fixtures_dir.display()))?;
let semantic_errors =
crate::e2e::validate::validate_fixtures_semantic(&fixtures, e2e_config, &e2e_config.languages);
all_errors.extend(semantic_errors);
if all_errors.is_empty() {
println!("All fixtures are valid.");
Ok(None)
} else {
use crate::e2e::validate::Severity;
let error_count = all_errors.iter().filter(|e| e.severity == Severity::Error).count();
let warning_count = all_errors.iter().filter(|e| e.severity == Severity::Warning).count();
println!("Found {} error(s) and {} warning(s):", error_count, warning_count);
for err in &all_errors {
println!(" {err}");
}
if error_count > 0 {
process::exit(1);
}
Ok(None)
}
}
}
}
Commands::TestApps { action } => {
let (_workspace, resolved) = load_config(config_path)?;
let crates_to_process = dispatch::select_crates(&resolved, &context.crate_filter)?;
let _resolved_cfg = crates_to_process
.iter()
.find(|c| c.e2e.is_some())
.copied()
.unwrap_or_else(|| crates_to_process[0]);
// Validate that at least one crate has an [e2e] section.
let _ = _resolved_cfg.e2e.as_ref().context("no [e2e] section in alef.toml")?;
match action {
TestAppsAction::Generate {
lang,
clean,
format,
jobs: _,
} => {
let config_toml = std::fs::read_to_string(config_path)?;
let base_dir = std::env::current_dir()?;
let mut grand_count: usize = 0;
for e2e_crate in &crates_to_process {
let Some(this_e2e_config) = e2e_crate.e2e.as_ref() else {
continue;
};
// Build a registry-mode clone of the e2e config.
let mut registry_config = this_e2e_config.clone();
registry_config.dep_mode = crate::core::config::e2e::DependencyMode::Registry;
let e2e_ref = ®istry_config;
let output_root = base_dir.join(e2e_ref.effective_output());
// --clean: delete the per-language directories before regen.
// Preserve lock files (go.sum, go.mod is regenerated, etc.) — generators
// should not own dependency lock files.
if clean {
let langs_to_clean: Vec<String> = lang
.as_deref()
.map(|ls| ls.iter().map(|s| s.to_string()).collect())
.unwrap_or_else(|| e2e_ref.languages.clone());
let lock_files = [
"go.sum",
"go.mod",
"package-lock.json",
"pnpm-lock.yaml",
"yarn.lock",
"Gemfile.lock",
"composer.lock",
"uv.lock",
"pubspec.lock",
];
for lang_name in &langs_to_clean {
let lang_dir = output_root.join(lang_name);
if lang_dir.exists() {
// Save lock files before deletion
let mut saved_locks = std::collections::HashMap::new();
for lock_file in &lock_files {
let lock_path = lang_dir.join(lock_file);
if lock_path.exists() {
if let Ok(content) = std::fs::read(&lock_path) {
saved_locks.insert(lock_path.clone(), content);
}
}
}
std::fs::remove_dir_all(&lang_dir)
.with_context(|| format!("failed to remove {}", lang_dir.display()))?;
// Restore lock files after deletion
std::fs::create_dir_all(&lang_dir)
.with_context(|| format!("failed to recreate {}", lang_dir.display()))?;
for (lock_path, content) in saved_locks {
std::fs::write(&lock_path, content).with_context(|| {
format!("failed to restore lock file {}", lock_path.display())
})?;
}
}
}
}
let fixtures_dir = std::path::Path::new(&this_e2e_config.fixtures);
let fixture_hash = cache::hash_directory(fixtures_dir).unwrap_or_default();
let api = pipeline::extract(e2e_crate, config_path, false)?;
let ir_json = serde_json::to_string(&api)?;
let cache_key = "test-apps";
let stage_hash = cache::compute_stage_hash(&ir_json, cache_key, &config_toml, &fixture_hash);
if !clean && cache::is_stage_cached(&e2e_crate.name, cache_key, &stage_hash) {
println!("Test apps up to date (cached)");
continue;
}
eprintln!("Generating registry-mode test apps...");
let languages = lang.as_deref();
let files = crate::e2e::generate_e2e(e2e_crate, e2e_ref, languages, &api.types, &api.enums)?;
let sources_hash = cache::sources_hash(&e2e_crate.sources)?;
let alef_toml_bytes = cache::read_alef_toml_bytes(config_path);
let count = pipeline::write_scaffold_files_with_overwrite(&files, &base_dir, true)?;
// Regenerate pnpm-lock.yaml for each language's test app if
// package.json was written in registry mode (Node.js ecosystem).
// This ensures the lockfile contains the current version pin and
// won't fail `pnpm install` with ERR_PNPM_MINIMUM_RELEASE_AGE_VIOLATION
// when the RC is < 24h old (observed on rc.60).
let generated_langs: Vec<String> = languages
.map(|ls| ls.iter().map(|s| s.to_string()).collect())
.unwrap_or_else(|| e2e_ref.languages.clone());
for lang_name in &generated_langs {
if lang_name == "node" || lang_name == "wasm" {
let test_app_dir = output_root.join(lang_name);
let package_json = test_app_dir.join("package.json");
if package_json.exists() {
eprintln!("Regenerating {}/pnpm-lock.yaml...", lang_name);
// run_optional gracefully handles missing pnpm and logs on failure.
// Not all environments have pnpm, but CI and local dev setups do.
run_optional(
"pnpm",
&[
"install",
"--lockfile-only",
"-C",
test_app_dir.to_string_lossy().as_ref(),
],
);
}
}
}
if format {
crate::e2e::format::run_formatters(&files, e2e_ref);
}
let output_paths: Vec<PathBuf> = files.iter().map(|f| base_dir.join(&f.path)).collect();
let path_set: std::collections::HashSet<PathBuf> = output_paths.iter().cloned().collect();
pipeline::finalize_hashes(&path_set, &sources_hash, &alef_toml_bytes)?;
// Sweep orphans scoped to test_apps/ only — never touches e2e/.
let sweep_roots: Vec<PathBuf> = if lang.is_some() {
let mut seen = std::collections::HashSet::new();
for path in &output_paths {
if let Ok(rel) = path.strip_prefix(&output_root) {
if let Some(top) = rel.components().next() {
seen.insert(output_root.join(top.as_os_str()));
}
}
}
seen.into_iter().collect()
} else {
vec![output_root]
};
pipeline::sweep_orphans(&sweep_roots, &path_set)?;
cache::write_stage_hash(&e2e_crate.name, cache_key, &stage_hash, &output_paths)?;
grand_count += count;
}
println!("Generated {grand_count} test-app files");
Ok(None)
}
TestAppsAction::Run { lang } => {
for e2e_crate in &crates_to_process {
let Some(this_e2e_config) = e2e_crate.e2e.as_ref() else {
continue;
};
let all_names: Vec<String> = if this_e2e_config.languages.is_empty() {
crate::e2e::default_e2e_languages(&e2e_crate.languages)
} else {
this_e2e_config.languages.clone()
};
let names: Vec<String> = match lang.as_deref() {
Some(filter) => all_names
.into_iter()
.filter(|n| filter.iter().any(|f| f == n))
.collect(),
None => all_names,
};
if names.is_empty() {
continue;
}
eprintln!("Running test apps for: {}", names.join(", "));
pipeline::test_apps_run(e2e_crate, &names)?;
}
Ok(None)
}
}
}
other => Ok(Some(other)),
}
}