1use std::path::{Component, Path, PathBuf};
2
3use super::walk::SOURCE_EXTENSIONS;
4use fallow_config::{PackageJson, ResolvedConfig, TsconfigOutputMap, TsconfigOutputResolution};
5use fallow_graph::resolve::{OUTPUT_DIRS, directory_index_entry, output_entry_to_source_path};
6use fallow_types::discover::{DiscoveredFile, EntryPoint, EntryPointSource};
7use rustc_hash::{FxHashMap, FxHashSet};
8
9use crate::plugins::config_parser::lexical_normalize;
10use crate::scripts::{IgnoredCommandEntries, ScriptCatalog, WorkspacePackages};
11
12#[path = "manual_entries.rs"]
13mod manual_entries;
14#[path = "plugin_entries.rs"]
15mod plugin_entries;
16#[path = "wildcard_entries.rs"]
17mod wildcard_entries;
18use manual_entries::{push_manual_entry_matches, push_support_entry_matches};
19#[cfg(test)]
20use plugin_entries::discover_plugin_entry_point_sets;
21pub use plugin_entries::{discover_plugin_entry_point_sets_timed, discover_plugin_entry_points};
22use wildcard_entries::expand_wildcard_entries;
23
24const SKIPPED_ENTRY_WARNING_PREVIEW: usize = 5;
25
26fn format_skipped_entry_warning(skipped_entries: &FxHashMap<String, usize>) -> Option<String> {
27 if skipped_entries.is_empty() {
28 return None;
29 }
30
31 let mut entries = skipped_entries
32 .iter()
33 .map(|(path, count)| (path.as_str(), *count))
34 .collect::<Vec<_>>();
35 entries.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(b.0)));
36
37 let preview = entries
38 .iter()
39 .take(SKIPPED_ENTRY_WARNING_PREVIEW)
40 .map(|(path, count)| {
41 if *count > 1 {
42 format!("{path} ({count}x)")
43 } else {
44 (*path).to_owned()
45 }
46 })
47 .collect::<Vec<_>>();
48
49 let omitted = entries.len().saturating_sub(SKIPPED_ENTRY_WARNING_PREVIEW);
50 let tail = if omitted > 0 {
51 format!(" (and {omitted} more)")
52 } else {
53 String::new()
54 };
55 let total = entries.iter().map(|(_, count)| *count).sum::<usize>();
56 let noun = if total == 1 {
57 "package.json entry point"
58 } else {
59 "package.json entry points"
60 };
61
62 Some(format!(
63 "Skipped {total} {noun} outside project root or containing parent directory traversal: {}{tail}",
64 preview.join(", ")
65 ))
66}
67
68pub fn warn_skipped_entry_summary(skipped_entries: &FxHashMap<String, usize>) {
69 let Some(message) = format_skipped_entry_warning(skipped_entries) else {
70 return;
71 };
72 if should_warn_skipped_entry(&message) {
73 tracing::warn!(target: fallow_types::ANALYSIS_DIAGNOSTIC_LOG_TARGET, "{message}");
74 }
75}
76
77fn should_warn_skipped_entry(message: &str) -> bool {
81 static WARNED: std::sync::OnceLock<std::sync::Mutex<FxHashSet<String>>> =
82 std::sync::OnceLock::new();
83 let warned = WARNED.get_or_init(|| std::sync::Mutex::new(FxHashSet::default()));
84 warned
85 .lock()
86 .map_or(true, |mut set| set.insert(message.to_owned()))
87}
88
89#[derive(Debug, Clone, Default)]
91pub struct CategorizedEntryPoints {
92 pub(crate) all: Vec<EntryPoint>,
93 pub(crate) runtime: Vec<EntryPoint>,
94 pub(crate) test: Vec<EntryPoint>,
95 pub(crate) production_excluded: Vec<PathBuf>,
100}
101
102impl CategorizedEntryPoints {
103 fn push_runtime(&mut self, entry: EntryPoint) {
104 self.runtime.push(entry.clone());
105 self.all.push(entry);
106 }
107
108 fn push_test(&mut self, entry: EntryPoint) {
109 self.test.push(entry.clone());
110 self.all.push(entry);
111 }
112
113 fn push_support(&mut self, entry: EntryPoint) {
114 self.all.push(entry);
115 }
116
117 pub(crate) fn extend_runtime<I>(&mut self, entries: I)
118 where
119 I: IntoIterator<Item = EntryPoint>,
120 {
121 for entry in entries {
122 self.push_runtime(entry);
123 }
124 }
125
126 pub(crate) fn extend_support<I>(&mut self, entries: I)
127 where
128 I: IntoIterator<Item = EntryPoint>,
129 {
130 for entry in entries {
131 self.push_support(entry);
132 }
133 }
134
135 pub(crate) fn extend_root(
138 &mut self,
139 root: EntryPointDiscovery,
140 ) -> (FxHashSet<PathBuf>, FxHashMap<String, usize>) {
141 self.extend_runtime(root.entries);
142 self.extend_support(root.support_entries);
143 self.production_excluded.extend(root.production_excluded);
144 (root.non_manual_runtime_paths, root.skipped_entries)
145 }
146
147 pub(crate) fn extend(&mut self, other: Self) {
148 self.all.extend(other.all);
149 self.runtime.extend(other.runtime);
150 self.test.extend(other.test);
151 self.production_excluded.extend(other.production_excluded);
152 }
153
154 #[must_use]
155 pub(crate) fn dedup(mut self) -> Self {
156 dedup_entry_paths(&mut self.all);
157 dedup_entry_paths(&mut self.runtime);
158 dedup_entry_paths(&mut self.test);
159 if !self.production_excluded.is_empty() {
160 let seeded: FxHashSet<&Path> = self.all.iter().map(|ep| ep.path.as_path()).collect();
161 self.production_excluded
162 .retain(|path| !seeded.contains(path.as_path()));
163 self.production_excluded.sort_unstable();
164 self.production_excluded.dedup();
165 }
166 self
167 }
168
169 #[must_use]
172 pub fn production_excluded(&self) -> &[PathBuf] {
173 &self.production_excluded
174 }
175}
176
177fn dedup_entry_paths(entries: &mut Vec<EntryPoint>) {
178 entries.sort_by(|a, b| a.path.cmp(&b.path));
179 entries.dedup_by(|a, b| a.path == b.path);
180}
181
182#[derive(Debug, Default)]
183pub struct EntryPointDiscovery {
184 pub entries: Vec<EntryPoint>,
186 pub support_entries: Vec<EntryPoint>,
188 pub skipped_entries: FxHashMap<String, usize>,
189 pub non_manual_runtime_paths: FxHashSet<PathBuf>,
191 pub production_excluded: Vec<PathBuf>,
194}
195
196impl EntryPointDiscovery {
197 fn into_all_entries(mut self) -> Vec<EntryPoint> {
198 self.entries.append(&mut self.support_entries);
199 dedup_entry_paths(&mut self.entries);
200 self.entries
201 }
202}
203
204pub fn resolve_entry_path_with_tracking(
211 base: &Path,
212 entry: &str,
213 canonical_root: &Path,
214 source: EntryPointSource,
215 skipped_entries: Option<&mut FxHashMap<String, usize>>,
216 discovered: Option<IsDiscovered<'_>>,
217) -> Option<EntryPoint> {
218 let output_map = TsconfigOutputMap::from_project(base);
219 resolve_entry_path_with_output_map(
220 base,
221 entry,
222 canonical_root,
223 source,
224 skipped_entries,
225 EntryTargets {
226 output_map: &output_map,
227 discovered,
228 },
229 )
230}
231
232pub type IsDiscovered<'a> = &'a (dyn Fn(&Path) -> bool + Sync);
235
236pub struct DiscoveredPaths<'a> {
243 files: &'a [DiscoveredFile],
244 by_path: std::sync::OnceLock<Vec<usize>>,
247}
248
249impl<'a> DiscoveredPaths<'a> {
250 #[must_use]
252 pub const fn new(files: &'a [DiscoveredFile]) -> Self {
253 Self {
254 files,
255 by_path: std::sync::OnceLock::new(),
256 }
257 }
258
259 #[must_use]
262 pub fn contains(&self, path: &Path) -> bool {
263 let by_path = self.by_path.get_or_init(|| {
264 let mut indexes: Vec<usize> = (0..self.files.len()).collect();
265 indexes.sort_unstable_by(|a, b| self.files[*a].path.cmp(&self.files[*b].path));
266 indexes
267 });
268 let has = |candidate: &Path| {
269 by_path
270 .binary_search_by(|index| self.files[*index].path.as_path().cmp(candidate))
271 .is_ok()
272 };
273 has(path) || dunce::canonicalize(path).is_ok_and(|canonical| has(&canonical))
274 }
275}
276
277#[derive(Clone, Copy)]
280pub(super) struct EntryTargets<'a> {
281 pub(super) output_map: &'a TsconfigOutputMap,
282 pub(super) discovered: Option<IsDiscovered<'a>>,
284}
285
286fn resolve_entry_path_with_output_map(
287 base: &Path,
288 entry: &str,
289 canonical_root: &Path,
290 source: EntryPointSource,
291 mut skipped_entries: Option<&mut FxHashMap<String, usize>>,
292 targets: EntryTargets<'_>,
293) -> Option<EntryPoint> {
294 if entry.contains('*') {
295 return None;
296 }
297
298 if entry_has_parent_dir(entry) {
299 record_or_warn_skipped_entry(
300 skipped_entries.as_deref_mut(),
301 entry,
302 "Skipping entry point containing parent directory traversal",
303 );
304 return None;
305 }
306
307 if let OutputDirEntry::ShortCircuit(result) = resolve_entry_via_output_dir(
308 base,
309 entry,
310 canonical_root,
311 source.clone(),
312 skipped_entries.as_deref_mut(),
313 targets,
314 ) {
315 return result;
316 }
317
318 resolve_entry_via_filesystem_probe(base, entry, canonical_root, source, skipped_entries)
319}
320
321fn record_or_warn_skipped_entry(
323 skipped_entries: Option<&mut FxHashMap<String, usize>>,
324 entry: &str,
325 warning: &str,
326) {
327 if let Some(skipped_entries) = skipped_entries {
328 *skipped_entries.entry(entry.to_owned()).or_default() += 1;
329 } else {
330 tracing::warn!(path = %entry, "{warning}");
331 }
332}
333
334pub(super) enum OutputDirEntry {
340 ShortCircuit(Option<EntryPoint>),
341 Continue,
342}
343
344pub(super) fn resolve_entry_via_output_dir(
346 base: &Path,
347 entry: &str,
348 canonical_root: &Path,
349 source: EntryPointSource,
350 mut skipped_entries: Option<&mut FxHashMap<String, usize>>,
351 targets: EntryTargets<'_>,
352) -> OutputDirEntry {
353 let resolution = targets
354 .output_map
355 .resolve_source_for_entry(entry, SOURCE_EXTENSIONS);
356 match &resolution {
357 TsconfigOutputResolution::Resolved(source_path) => {
358 return OutputDirEntry::ShortCircuit(validated_entry_point(
359 source_path,
360 canonical_root,
361 entry,
362 source,
363 skipped_entries.as_deref_mut(),
364 ));
365 }
366 TsconfigOutputResolution::ConfiguredButUnresolved => return OutputDirEntry::Continue,
367 TsconfigOutputResolution::ConfiguredWithoutSource
368 | TsconfigOutputResolution::Unconfigured => {}
369 }
370
371 let is_discovered = |path: &Path| {
372 targets
373 .discovered
374 .is_none_or(|is_discovered| is_discovered(path))
375 };
376 if matches!(
377 resolution,
378 TsconfigOutputResolution::ConfiguredWithoutSource
379 ) {
380 return match output_entry_to_source_path(base, entry, SOURCE_EXTENSIONS, is_discovered)
383 .filter(|source_path| is_discovered(source_path))
384 {
385 Some(source_path) => OutputDirEntry::ShortCircuit(validated_entry_point(
386 &source_path,
387 canonical_root,
388 entry,
389 source,
390 skipped_entries,
391 )),
392 None => OutputDirEntry::Continue,
393 };
394 }
395 if let Some(source_path) =
396 output_entry_to_source_path(base, entry, SOURCE_EXTENSIONS, is_discovered)
397 {
398 return OutputDirEntry::ShortCircuit(validated_entry_point(
399 &source_path,
400 canonical_root,
401 entry,
402 source,
403 skipped_entries.as_deref_mut(),
404 ));
405 }
406
407 if is_entry_in_output_dir(entry)
408 && let Some(source_path) = try_source_index_fallback(base)
409 {
410 tracing::info!(
411 entry = %entry,
412 fallback = %source_path.display(),
413 "package.json entry resolves to an ignored output directory; falling back to source index"
414 );
415 return OutputDirEntry::ShortCircuit(validated_entry_point(
416 &source_path,
417 canonical_root,
418 entry,
419 source,
420 skipped_entries,
421 ));
422 }
423
424 OutputDirEntry::Continue
425}
426
427fn resolve_entry_via_filesystem_probe(
430 base: &Path,
431 entry: &str,
432 canonical_root: &Path,
433 source: EntryPointSource,
434 mut skipped_entries: Option<&mut FxHashMap<String, usize>>,
435) -> Option<EntryPoint> {
436 let resolved = base.join(entry);
437
438 if resolved.is_file() {
439 return validated_entry_point(
440 &resolved,
441 canonical_root,
442 entry,
443 source,
444 skipped_entries.as_deref_mut(),
445 );
446 }
447
448 for ext in SOURCE_EXTENSIONS {
449 let with_ext = resolved.with_extension(ext);
450 if with_ext.is_file() {
451 return validated_entry_point(
452 &with_ext,
453 canonical_root,
454 entry,
455 source,
456 skipped_entries.as_deref_mut(),
457 );
458 }
459 }
460
461 if let Some(index_entry) = directory_index_entry(&resolved, SOURCE_EXTENSIONS) {
462 return validated_entry_point(
463 &index_entry,
464 canonical_root,
465 entry,
466 source,
467 skipped_entries.as_deref_mut(),
468 );
469 }
470
471 if is_package_root_index_entry(entry)
472 && let Some(source_path) = try_source_index_fallback(base)
473 {
474 tracing::info!(
475 entry = %entry,
476 fallback = %source_path.display(),
477 "package.json root index entry is missing; falling back to source index"
478 );
479 return validated_entry_point(&source_path, canonical_root, entry, source, skipped_entries);
480 }
481 None
482}
483
484pub(super) fn entry_has_parent_dir(entry: &str) -> bool {
485 Path::new(entry)
486 .components()
487 .any(|component| matches!(component, Component::ParentDir))
488}
489
490fn is_package_root_index_entry(entry: &str) -> bool {
491 let mut components = Path::new(entry)
492 .components()
493 .filter(|component| !matches!(component, Component::CurDir));
494
495 let Some(Component::Normal(file_name)) = components.next() else {
496 return false;
497 };
498 if components.next().is_some() {
499 return false;
500 }
501
502 file_name
503 .to_str()
504 .is_some_and(|name| name == "index" || name.starts_with("index."))
505}
506
507fn validated_entry_point(
508 candidate: &Path,
509 canonical_root: &Path,
510 entry: &str,
511 source: EntryPointSource,
512 mut skipped_entries: Option<&mut FxHashMap<String, usize>>,
513) -> Option<EntryPoint> {
514 let canonical_candidate = match dunce::canonicalize(candidate) {
515 Ok(path) => path,
516 Err(err) => {
517 tracing::warn!(
518 path = %candidate.display(),
519 %entry,
520 error = %err,
521 "Skipping entry point that could not be canonicalized"
522 );
523 return None;
524 }
525 };
526
527 if !canonical_candidate.starts_with(canonical_root) {
528 if let Some(skipped_entries) = skipped_entries.as_mut() {
529 *skipped_entries.entry(entry.to_owned()).or_default() += 1;
530 } else {
531 tracing::warn!(
532 path = %candidate.display(),
533 %entry,
534 "Skipping entry point outside project root"
535 );
536 }
537 return None;
538 }
539
540 Some(EntryPoint {
543 path: lexical_normalize(candidate),
544 source,
545 })
546}
547
548pub fn resolve_entry_path(
554 base: &Path,
555 entry: &str,
556 canonical_root: &Path,
557 source: EntryPointSource,
558) -> Option<EntryPoint> {
559 resolve_entry_path_with_tracking(base, entry, canonical_root, source, None, None)
560}
561
562pub fn resolve_entry_path_with_discovered(
567 base: &Path,
568 entry: &str,
569 canonical_root: &Path,
570 source: EntryPointSource,
571 is_discovered: IsDiscovered<'_>,
572) -> Option<EntryPoint> {
573 resolve_entry_path_with_tracking(
574 base,
575 entry,
576 canonical_root,
577 source,
578 None,
579 Some(is_discovered),
580 )
581}
582const SOURCE_INDEX_FALLBACK_STEMS: &[&str] = &["src/index", "src/main", "index", "main"];
585
586fn is_entry_in_output_dir(entry: &str) -> bool {
591 Path::new(entry).components().any(|c| {
592 matches!(
593 c,
594 std::path::Component::Normal(s)
595 if s.to_str().is_some_and(|name| OUTPUT_DIRS.contains(&name))
596 )
597 })
598}
599
600fn try_source_index_fallback(base: &Path) -> Option<PathBuf> {
607 for stem in SOURCE_INDEX_FALLBACK_STEMS {
608 for ext in SOURCE_EXTENSIONS {
609 let candidate = base.join(format!("{stem}.{ext}"));
610 if candidate.is_file() {
611 return Some(candidate);
612 }
613 }
614 }
615 None
616}
617
618const DEFAULT_INDEX_PATTERNS: &[&str] = &[
620 "src/index.{ts,tsx,js,jsx}",
621 "src/main.{ts,tsx,js,jsx}",
622 "index.{ts,tsx,js,jsx}",
623 "main.{ts,tsx,js,jsx}",
624];
625
626fn default_index_matchers() -> &'static globset::GlobSet {
628 static MATCHERS: std::sync::OnceLock<globset::GlobSet> = std::sync::OnceLock::new();
629 MATCHERS.get_or_init(|| {
630 let mut builder = globset::GlobSetBuilder::new();
631 for pattern in DEFAULT_INDEX_PATTERNS {
632 if let Ok(glob) = globset::Glob::new(pattern) {
633 builder.add(glob);
634 }
635 }
636 builder.build().unwrap_or_default()
637 })
638}
639
640fn apply_default_fallback(
645 files: &[DiscoveredFile],
646 root: &Path,
647 ws_filter: Option<&Path>,
648) -> Vec<EntryPoint> {
649 let default_matchers = default_index_matchers();
650
651 let mut entries = Vec::new();
652 for file in files {
653 if let Some(ws_root) = ws_filter
654 && file.path.strip_prefix(ws_root).is_err()
655 {
656 continue;
657 }
658 let relative = file.path.strip_prefix(root).unwrap_or(&file.path);
659 let relative_str = relative.to_string_lossy();
660 if default_matchers.is_match(relative_str.as_ref()) {
661 entries.push(EntryPoint {
662 path: file.path.clone(),
663 source: EntryPointSource::DefaultIndex,
664 });
665 }
666 }
667 entries
668}
669
670pub(super) fn relative_paths_for(files: &[DiscoveredFile], root: &Path) -> Vec<String> {
672 files
673 .iter()
674 .map(|f| {
675 f.path
676 .strip_prefix(root)
677 .unwrap_or(&f.path)
678 .to_string_lossy()
679 .into_owned()
680 })
681 .collect()
682}
683
684fn push_package_json_entries(
686 discovery: &mut EntryPointDiscovery,
687 root: &Path,
688 pkg: &PackageJson,
689 canonical_root: &Path,
690 ignored: IgnoredCommandEntries<'_>,
691 workspaces: ScriptWorkspaces<'_>,
692) {
693 let output_map = TsconfigOutputMap::from_project(root);
694 for entry_path in pkg.entry_points() {
695 if let Some(ep) = resolve_entry_path_with_output_map(
696 root,
697 &entry_path,
698 canonical_root,
699 EntryPointSource::PackageJsonMain,
700 Some(&mut discovery.skipped_entries),
701 EntryTargets {
702 output_map: &output_map,
703 discovered: workspaces.discovered,
704 },
705 ) {
706 discovery.entries.push(ep);
707 }
708 }
709
710 let Some(scripts) = &pkg.scripts else {
711 return;
712 };
713 let package = ScriptPackage {
714 root,
715 canonical_root,
716 output_map: &output_map,
717 workspaces,
718 };
719 push_script_entries(
720 &package,
721 scripts,
722 ignored,
723 &mut PackageEntryBuckets {
724 runtime: &mut discovery.entries,
725 support: &mut discovery.support_entries,
726 },
727 &mut discovery.skipped_entries,
728 );
729}
730
731#[derive(Clone, Copy)]
737pub struct ScriptWorkspaces<'a> {
738 pub packages: &'a std::sync::Arc<WorkspacePackages>,
740 pub project_root: &'a Path,
742 pub runtime_seeds: &'a RuntimeScriptSeeds,
745 pub discovered: Option<IsDiscovered<'a>>,
753}
754
755pub type RuntimeScriptSeeds = FxHashMap<String, FxHashSet<String>>;
759
760struct ScriptPackage<'a> {
762 root: &'a Path,
763 canonical_root: &'a Path,
764 output_map: &'a TsconfigOutputMap,
765 workspaces: ScriptWorkspaces<'a>,
766}
767
768impl ScriptPackage<'_> {
769 fn dir(&self) -> Option<String> {
772 self.root
773 .strip_prefix(self.workspaces.project_root)
774 .ok()
775 .map(|dir| dir.to_string_lossy().replace('\\', "/"))
776 }
777
778 fn resolve(
783 &self,
784 file_ref: &str,
785 script: &str,
786 dir: Option<&str>,
787 skipped_entries: &mut FxHashMap<String, usize>,
788 ) -> Option<EntryPoint> {
789 if entry_has_parent_dir(file_ref)
790 && let Some(project_ref) =
791 dir.and_then(|dir| crate::scripts::normalize_script_entry_pattern(dir, file_ref))
792 {
793 let project_root = self.workspaces.project_root;
794 let canonical_project_root =
795 dunce::canonicalize(project_root).unwrap_or_else(|_| project_root.to_path_buf());
796 return resolve_entry_path_with_tracking(
797 project_root,
798 &project_ref,
799 &canonical_project_root,
800 EntryPointSource::package_json_script(script),
801 Some(skipped_entries),
802 self.workspaces.discovered,
803 );
804 }
805 resolve_entry_path_with_output_map(
806 self.root,
807 file_ref,
808 self.canonical_root,
809 EntryPointSource::package_json_script(script),
810 Some(skipped_entries),
811 EntryTargets {
812 output_map: self.output_map,
813 discovered: self.workspaces.discovered,
814 },
815 )
816 }
817}
818
819#[expect(
824 clippy::disallowed_types,
825 reason = "API matches serde-deserialized package.json scripts map"
826)]
827fn push_script_entries(
828 package: &ScriptPackage<'_>,
829 scripts: &std::collections::HashMap<String, String>,
830 ignored: IgnoredCommandEntries<'_>,
831 entries: &mut PackageEntryBuckets<'_>,
832 skipped_entries: &mut FxHashMap<String, usize>,
833) {
834 let dir_buf = package.dir();
835 let dir = dir_buf.as_deref();
836 let no_seeds = FxHashSet::default();
837 let seeds = dir
838 .and_then(|dir| package.workspaces.runtime_seeds.get(dir))
839 .unwrap_or(&no_seeds);
840 let runtime_scripts = runtime_package_script_names_with_seeds(scripts, seeds);
841 let catalog = ScriptCatalog::from_scripts(scripts).with_workspaces(
842 std::sync::Arc::clone(package.workspaces.packages),
843 dir.unwrap_or_default(),
844 );
845 let sorted: std::collections::BTreeMap<_, _> = scripts.iter().collect();
847 for (script_name, script_value) in sorted {
848 let refs = package_script_refs(script_value, &catalog, ignored);
849 for file_ref in refs.inheritable {
850 if let Some(ep) = package.resolve(&file_ref, script_name, dir, skipped_entries) {
851 if runtime_scripts.contains(script_name) {
852 entries.runtime.push(ep);
853 } else {
854 entries.support.push(ep);
855 }
856 }
857 }
858 for config_ref in refs.support {
859 if let Some(ep) = package.resolve(&config_ref, script_name, dir, skipped_entries) {
860 entries.support.push(ep);
861 }
862 }
863 }
864}
865
866struct PackageScriptRefs {
867 inheritable: Vec<String>,
868 support: Vec<String>,
869}
870
871fn package_script_refs(
875 script: &str,
876 catalog: &ScriptCatalog,
877 ignored: IgnoredCommandEntries<'_>,
878) -> PackageScriptRefs {
879 let mut inheritable = Vec::new();
880 let mut support = Vec::new();
881 for command in crate::scripts::parse_script_with_catalog(script, catalog) {
882 inheritable.extend_from_slice(command.entry_files(ignored));
883 support.extend(command.config_args);
884 }
885 inheritable.extend(super::parse_scripts::extract_script_file_refs(
886 script,
887 super::parse_scripts::CommandRefContext {
888 ignored,
889 scripts: catalog,
890 },
891 ));
892 support.sort_unstable();
893 support.dedup();
894 inheritable.retain(|path| support.binary_search(path).is_err());
895 inheritable.sort_unstable();
896 inheritable.dedup();
897 PackageScriptRefs {
898 inheritable,
899 support,
900 }
901}
902
903#[expect(
907 clippy::disallowed_types,
908 reason = "API matches serde-deserialized package.json scripts map"
909)]
910fn runtime_package_script_names(
911 scripts: &std::collections::HashMap<String, String>,
912) -> FxHashSet<String> {
913 runtime_package_script_names_with_seeds(scripts, &FxHashSet::default())
914}
915
916#[expect(
917 clippy::disallowed_types,
918 reason = "API matches serde-deserialized package.json scripts map"
919)]
920fn runtime_package_script_names_with_seeds(
921 scripts: &std::collections::HashMap<String, String>,
922 seeds: &FxHashSet<String>,
923) -> FxHashSet<String> {
924 let catalog = ScriptCatalog::from_scripts(scripts);
925 let mut runtime = FxHashSet::default();
926 let mut pending = Vec::new();
927
928 enqueue_runtime_script("start", scripts, &mut runtime, &mut pending);
929 for seed in seeds {
930 enqueue_runtime_script(seed, scripts, &mut runtime, &mut pending);
931 }
932
933 while let Some(name) = pending.pop() {
934 let Some(body) = scripts.get(&name) else {
935 continue;
936 };
937 for referenced in crate::scripts::referenced_package_scripts(body, &catalog) {
938 enqueue_runtime_script(&referenced, scripts, &mut runtime, &mut pending);
939 }
940 }
941
942 runtime
943}
944
945pub fn collect_workspace_packages(
949 project_root: &Path,
950 root_pkg: Option<&PackageJson>,
951 workspace_pkgs: &[(fallow_config::WorkspaceInfo, PackageJson)],
952) -> std::sync::Arc<WorkspacePackages> {
953 let mut packages = WorkspacePackages::default();
954 if let Some(pkg) = root_pkg {
955 packages.add_root(
956 pkg.name.as_deref().unwrap_or_default(),
957 pkg.scripts.as_ref(),
958 );
959 }
960 for (ws, ws_pkg) in workspace_pkgs {
961 let dir = ws
962 .root
963 .strip_prefix(project_root)
964 .unwrap_or(&ws.root)
965 .to_string_lossy()
966 .replace('\\', "/");
967 packages.add(&ws.name, &dir, ws_pkg.scripts.as_ref());
968 }
969 std::sync::Arc::new(packages.with_project_root(project_root))
970}
971
972pub fn workspace_runtime_script_seeds(
977 packages: &std::sync::Arc<WorkspacePackages>,
978) -> RuntimeScriptSeeds {
979 let mut seeds = RuntimeScriptSeeds::default();
980 let mut pending: Vec<(String, String)> = packages
981 .iter()
982 .flat_map(|package| {
983 runtime_package_script_names(package.scripts())
984 .into_iter()
985 .map(|name| (package.dir().to_string(), name))
986 })
987 .collect();
988
989 let mut visited = FxHashSet::default();
990 while let Some((dir, name)) = pending.pop() {
991 if !visited.insert((dir.clone(), name.clone())) {
992 continue;
993 }
994 let Some(package) = packages.find_dir(&dir) else {
995 continue;
996 };
997 let Some(body) = package.scripts().get(&name) else {
998 continue;
999 };
1000 let catalog = ScriptCatalog::from_scripts(package.scripts())
1001 .with_workspaces(std::sync::Arc::clone(packages), &dir);
1002 for (target_dir, script) in crate::scripts::referenced_workspace_scripts(body, &catalog) {
1003 let Some(target) = packages.find_dir(&target_dir) else {
1004 continue;
1005 };
1006 let target_seeds = FxHashSet::from_iter([script]);
1007 for runtime_name in
1008 runtime_package_script_names_with_seeds(target.scripts(), &target_seeds)
1009 {
1010 if seeds
1011 .entry(target_dir.clone())
1012 .or_default()
1013 .insert(runtime_name.clone())
1014 {
1015 pending.push((target_dir.clone(), runtime_name));
1016 }
1017 }
1018 }
1019 }
1020 seeds
1021}
1022
1023#[expect(
1024 clippy::disallowed_types,
1025 reason = "API matches serde-deserialized package.json scripts map"
1026)]
1027fn enqueue_runtime_script(
1028 name: &str,
1029 scripts: &std::collections::HashMap<String, String>,
1030 runtime: &mut FxHashSet<String>,
1031 pending: &mut Vec<String>,
1032) {
1033 for candidate in [
1034 format!("pre{name}"),
1035 name.to_string(),
1036 format!("post{name}"),
1037 ] {
1038 if scripts.contains_key(&candidate) && runtime.insert(candidate.clone()) {
1039 pending.push(candidate);
1040 }
1041 }
1042}
1043
1044pub fn discover_root_entry_points(
1048 config: &ResolvedConfig,
1049 files: &[DiscoveredFile],
1050 root_pkg: Option<&PackageJson>,
1051 include_nested_package_entries: bool,
1052 workspaces: ScriptWorkspaces<'_>,
1053) -> EntryPointDiscovery {
1054 let _span = tracing::info_span!("discover_entry_points").entered();
1055 let mut discovery = EntryPointDiscovery::default();
1056
1057 let relative_paths = relative_paths_for(files, &config.root);
1058 push_manual_entry_matches(&mut discovery.entries, config, &relative_paths, files);
1059 push_support_entry_matches(&mut discovery, config, &relative_paths, files);
1060
1061 let canonical_root = dunce::canonicalize(&config.root).unwrap_or_else(|_| config.root.clone());
1062 if let Some(pkg) = root_pkg {
1063 push_package_json_entries(
1064 &mut discovery,
1065 &config.root,
1066 pkg,
1067 &canonical_root,
1068 IgnoredCommandEntries::new(&config.ignore_command_entries),
1069 workspaces,
1070 );
1071 for entry_path in pkg.entry_points() {
1072 if entry_path.contains('*') {
1073 expand_wildcard_entries(&config.root, &entry_path, files, &mut discovery.entries);
1074 }
1075 }
1076 }
1077
1078 if include_nested_package_entries {
1079 let exports_dirs = root_pkg
1080 .map(PackageJson::exports_subdirectories)
1081 .unwrap_or_default();
1082 let mut nested_entries = PackageEntryBuckets {
1083 runtime: &mut discovery.entries,
1084 support: &mut discovery.support_entries,
1085 };
1086 discover_nested_package_entries(
1087 &mut nested_entries,
1088 &NestedPackageSearch {
1089 canonical_root: &canonical_root,
1090 files,
1091 exports_subdirectories: &exports_dirs,
1092 ignored: IgnoredCommandEntries::new(&config.ignore_command_entries),
1093 workspaces,
1094 },
1095 &mut discovery.skipped_entries,
1096 );
1097 }
1098
1099 if discovery.entries.is_empty() {
1100 discovery.entries = apply_default_fallback(files, &config.root, None);
1101 }
1102
1103 discovery.non_manual_runtime_paths = super::entry_report::non_manual_paths(&discovery.entries);
1104 dedup_entry_paths(&mut discovery.entries);
1105 dedup_entry_paths(&mut discovery.support_entries);
1106
1107 discovery
1108}
1109
1110#[must_use]
1116pub fn discover_entry_points(
1117 config: &ResolvedConfig,
1118 files: &[DiscoveredFile],
1119 workspaces: &[fallow_config::WorkspaceInfo],
1120) -> Vec<EntryPoint> {
1121 use rayon::prelude::*;
1122
1123 let root_pkg = fallow_config::load_dir_package_json(&config.root);
1124 let workspace_pkgs: Vec<(fallow_config::WorkspaceInfo, PackageJson)> = workspaces
1125 .iter()
1126 .filter_map(|ws| {
1127 fallow_config::load_dir_package_json(&ws.root).map(|pkg| (ws.clone(), pkg))
1128 })
1129 .collect();
1130 let packages = collect_workspace_packages(&config.root, root_pkg.as_ref(), &workspace_pkgs);
1131 let runtime_seeds = workspace_runtime_script_seeds(&packages);
1132 let discovered = DiscoveredPaths::new(files);
1133 let is_discovered = |path: &Path| discovered.contains(path);
1134 let script_workspaces = ScriptWorkspaces {
1135 packages: &packages,
1136 project_root: &config.root,
1137 runtime_seeds: &runtime_seeds,
1138 discovered: Some(&is_discovered),
1139 };
1140 let mut discovery = discover_root_entry_points(
1141 config,
1142 files,
1143 root_pkg.as_ref(),
1144 workspaces.is_empty(),
1145 script_workspaces,
1146 );
1147 let pkg_by_root: FxHashMap<&Path, &PackageJson> = workspace_pkgs
1148 .iter()
1149 .map(|(ws, pkg)| (ws.root.as_path(), pkg))
1150 .collect();
1151 let workspace_discovery: Vec<EntryPointDiscovery> = workspaces
1152 .par_iter()
1153 .map(|ws| {
1154 discover_workspace_package_entry_points(
1155 &ws.root,
1156 files,
1157 pkg_by_root.get(ws.root.as_path()).copied(),
1158 IgnoredCommandEntries::new(&config.ignore_command_entries),
1159 script_workspaces,
1160 )
1161 })
1162 .collect();
1163 for workspace in workspace_discovery {
1164 discovery.entries.extend(workspace.entries);
1165 discovery.support_entries.extend(workspace.support_entries);
1166 for (path, count) in workspace.skipped_entries {
1167 *discovery.skipped_entries.entry(path).or_insert(0) += count;
1168 }
1169 }
1170 warn_skipped_entry_summary(&discovery.skipped_entries);
1171 discovery.into_all_entries()
1172}
1173
1174struct PackageEntryBuckets<'a> {
1184 runtime: &'a mut Vec<EntryPoint>,
1185 support: &'a mut Vec<EntryPoint>,
1186}
1187
1188struct NestedPackageSearch<'a> {
1190 canonical_root: &'a Path,
1191 files: &'a [DiscoveredFile],
1192 exports_subdirectories: &'a [String],
1193 ignored: IgnoredCommandEntries<'a>,
1194 workspaces: ScriptWorkspaces<'a>,
1195}
1196
1197fn discover_nested_package_entries(
1198 entries: &mut PackageEntryBuckets<'_>,
1199 search: &NestedPackageSearch<'_>,
1200 skipped_entries: &mut FxHashMap<String, usize>,
1201) {
1202 let root = search.workspaces.project_root;
1203 let mut visited = rustc_hash::FxHashSet::default();
1204
1205 let search_dirs = [
1206 "packages", "apps", "libs", "modules", "plugins", "services", "tools", "utils",
1207 ];
1208 for dir_name in &search_dirs {
1209 let search_dir = root.join(dir_name);
1210 if !search_dir.is_dir() {
1211 continue;
1212 }
1213 let Ok(read_dir) = std::fs::read_dir(&search_dir) else {
1214 continue;
1215 };
1216 for entry in read_dir.flatten() {
1217 let pkg_dir = entry.path();
1218 if visited.insert(pkg_dir.clone()) {
1219 collect_nested_package_entries(&pkg_dir, entries, search, skipped_entries);
1220 }
1221 }
1222 }
1223
1224 for dir_name in search.exports_subdirectories {
1225 let pkg_dir = root.join(dir_name);
1226 if pkg_dir.is_dir() && visited.insert(pkg_dir.clone()) {
1227 collect_nested_package_entries(&pkg_dir, entries, search, skipped_entries);
1228 }
1229 }
1230}
1231
1232fn collect_nested_package_entries(
1234 pkg_dir: &Path,
1235 entries: &mut PackageEntryBuckets<'_>,
1236 search: &NestedPackageSearch<'_>,
1237 skipped_entries: &mut FxHashMap<String, usize>,
1238) {
1239 let Some(pkg) = fallow_config::load_dir_package_json(pkg_dir) else {
1240 return;
1241 };
1242 let output_map = TsconfigOutputMap::from_project(pkg_dir);
1243 for entry_path in pkg.entry_points() {
1244 if entry_path.contains('*') {
1245 expand_wildcard_entries(pkg_dir, &entry_path, search.files, entries.runtime);
1246 } else if let Some(ep) = resolve_entry_path_with_output_map(
1247 pkg_dir,
1248 &entry_path,
1249 search.canonical_root,
1250 EntryPointSource::PackageJsonExports,
1251 Some(&mut *skipped_entries),
1252 EntryTargets {
1253 output_map: &output_map,
1254 discovered: search.workspaces.discovered,
1255 },
1256 ) {
1257 entries.runtime.push(ep);
1258 }
1259 }
1260 if let Some(scripts) = &pkg.scripts {
1261 let package = ScriptPackage {
1262 root: pkg_dir,
1263 canonical_root: search.canonical_root,
1264 output_map: &output_map,
1265 workspaces: search.workspaces,
1266 };
1267 push_script_entries(&package, scripts, search.ignored, entries, skipped_entries);
1268 }
1269}
1270
1271#[must_use]
1273pub fn discover_workspace_package_entry_points(
1274 ws_root: &Path,
1275 all_files: &[DiscoveredFile],
1276 pkg: Option<&PackageJson>,
1277 ignored: IgnoredCommandEntries<'_>,
1278 workspaces: ScriptWorkspaces<'_>,
1279) -> EntryPointDiscovery {
1280 let mut discovery = EntryPointDiscovery::default();
1281
1282 if let Some(pkg) = pkg {
1283 let canonical_ws_root =
1284 dunce::canonicalize(ws_root).unwrap_or_else(|_| ws_root.to_path_buf());
1285 let output_map = TsconfigOutputMap::from_project(ws_root);
1286 for entry_path in pkg.entry_points() {
1287 if entry_path.contains('*') {
1288 expand_wildcard_entries(ws_root, &entry_path, all_files, &mut discovery.entries);
1289 } else if let Some(ep) = resolve_entry_path_with_output_map(
1290 ws_root,
1291 &entry_path,
1292 &canonical_ws_root,
1293 EntryPointSource::PackageJsonMain,
1294 Some(&mut discovery.skipped_entries),
1295 EntryTargets {
1296 output_map: &output_map,
1297 discovered: workspaces.discovered,
1298 },
1299 ) {
1300 discovery.entries.push(ep);
1301 }
1302 }
1303
1304 if let Some(scripts) = &pkg.scripts {
1305 let package = ScriptPackage {
1306 root: ws_root,
1307 canonical_root: &canonical_ws_root,
1308 output_map: &output_map,
1309 workspaces,
1310 };
1311 push_script_entries(
1312 &package,
1313 scripts,
1314 ignored,
1315 &mut PackageEntryBuckets {
1316 runtime: &mut discovery.entries,
1317 support: &mut discovery.support_entries,
1318 },
1319 &mut discovery.skipped_entries,
1320 );
1321 }
1322 }
1323
1324 if discovery.entries.is_empty() {
1325 discovery.entries = apply_default_fallback(all_files, ws_root, Some(ws_root));
1326 }
1327
1328 discovery.entries.sort_by(|a, b| a.path.cmp(&b.path));
1329 discovery.entries.dedup_by(|a, b| a.path == b.path);
1330 discovery
1331 .support_entries
1332 .sort_by(|a, b| a.path.cmp(&b.path));
1333 discovery.support_entries.dedup_by(|a, b| a.path == b.path);
1334 discovery
1335}
1336
1337#[expect(
1347 clippy::expect_used,
1348 reason = "dynamicallyLoaded glob patterns are validated before entry point discovery"
1349)]
1350#[must_use]
1351pub fn discover_dynamically_loaded_entry_points(
1352 config: &ResolvedConfig,
1353 files: &[DiscoveredFile],
1354) -> Vec<EntryPoint> {
1355 if config.dynamically_loaded.is_empty() {
1356 return Vec::new();
1357 }
1358
1359 let mut builder = globset::GlobSetBuilder::new();
1360 for pattern in &config.dynamically_loaded {
1361 builder.add(
1362 fallow_config::compile_path_glob(pattern)
1363 .expect("dynamicallyLoaded pattern was validated at config load time"),
1364 );
1365 }
1366 let Ok(glob_set) = builder.build() else {
1367 return Vec::new();
1368 };
1369 if glob_set.is_empty() {
1370 return Vec::new();
1371 }
1372
1373 let mut entries = Vec::new();
1374 for file in files {
1375 let rel = file
1376 .path
1377 .strip_prefix(&config.root)
1378 .unwrap_or(&file.path)
1379 .to_string_lossy();
1380 if glob_set.is_match(rel.as_ref()) {
1381 entries.push(EntryPoint {
1382 path: file.path.clone(),
1383 source: EntryPointSource::DynamicallyLoaded,
1384 });
1385 }
1386 }
1387 entries
1388}
1389
1390#[cfg(test)]
1391mod tests {
1392 use super::*;
1393 use fallow_config::{EntryPointRole, FallowConfig, OutputFormat, RulesConfig};
1394 use fallow_types::discover::FileId;
1395 use proptest::prelude::*;
1396
1397 proptest! {
1398 #[test]
1400 fn glob_patterns_never_panic_on_compile(
1401 prefix in "[a-zA-Z0-9_]{1,20}",
1402 ext in prop::sample::select(vec!["ts", "tsx", "js", "jsx", "vue", "svelte", "astro", "mdx"]),
1403 ) {
1404 let pattern = format!("**/{prefix}*.{ext}");
1405 let result = globset::Glob::new(&pattern);
1406 prop_assert!(result.is_ok(), "Glob::new should not fail for well-formed patterns");
1407 }
1408
1409 #[test]
1411 fn non_source_extensions_not_in_list(
1412 ext in prop::sample::select(vec!["py", "rb", "rs", "go", "java", "xml", "yaml", "toml", "md", "txt", "png", "jpg", "wasm", "lock"]),
1413 ) {
1414 prop_assert!(
1415 !SOURCE_EXTENSIONS.contains(&ext),
1416 "Extension '{ext}' should NOT be in SOURCE_EXTENSIONS"
1417 );
1418 }
1419
1420 }
1421
1422 #[test]
1423 #[expect(
1424 clippy::too_many_lines,
1425 reason = "test fixture; linear setup/assert, length is not a maintainability concern"
1426 )]
1427 fn plugin_entry_point_sets_preserve_runtime_test_and_support_roles() {
1428 let dir = tempfile::tempdir().expect("create temp dir");
1429 let root = dir.path();
1430 std::fs::create_dir_all(root.join("src")).unwrap();
1431 std::fs::create_dir_all(root.join("tests")).unwrap();
1432 std::fs::write(root.join("src/runtime.ts"), "export const runtime = 1;").unwrap();
1433 std::fs::write(root.join("src/setup.ts"), "export const setup = 1;").unwrap();
1434 std::fs::write(root.join("tests/app.test.ts"), "export const test = 1;").unwrap();
1435
1436 let config = FallowConfig {
1437 type_aware: fallow_config::TypeAwareConfig::default(),
1438 schema: None,
1439 minimum_version: None,
1440 extends: vec![],
1441 entry: vec![],
1442 ignore_patterns: vec![],
1443 ignore_findings: vec![],
1444 framework: vec![],
1445 workspaces: None,
1446 ignore_dependencies: vec![],
1447 ignore_command_entries: vec![],
1448 ignore_unresolved_imports: vec![],
1449 ignore_exports: vec![],
1450 ignore_catalog_references: vec![],
1451 ignore_dependency_overrides: vec![],
1452 ignore_exports_used_in_file: fallow_config::IgnoreExportsUsedInFileConfig::default(),
1453 used_class_members: vec![],
1454 ignore_decorators: vec![],
1455 unused_component_props: fallow_config::UnusedComponentPropsConfig::default(),
1456 circular_dependencies: fallow_config::CircularDependenciesConfig::default(),
1457 duplicates: fallow_config::DuplicatesConfig::default(),
1458 similar_code: fallow_config::SimilarCodeConfig::default(),
1459 mutation: fallow_config::MutationConfig::default(),
1460 health: fallow_config::HealthConfig::default(),
1461 rules: RulesConfig::default(),
1462 boundaries: fallow_config::BoundaryConfig::default(),
1463 production: false.into(),
1464 plugins: vec![],
1465 rule_packs: vec![],
1466 overrides: vec![],
1467 regression: None,
1468 audit: fallow_config::AuditConfig::default(),
1469 codeowners: None,
1470 public_packages: vec![],
1471 flags: fallow_config::FlagsConfig::default(),
1472 security: fallow_config::SecurityConfig::default(),
1473 fix: fallow_config::FixConfig::default(),
1474 resolve: fallow_config::ResolveConfig::default(),
1475 sealed: false,
1476 include_entry_exports: false,
1477 show_cascade: false,
1478 auto_imports: false,
1479 fail_on_parse_error: false,
1480 cache: fallow_config::CacheConfig::default(),
1481 ..Default::default()
1482 }
1483 .resolve(root.to_path_buf(), OutputFormat::Human, 4, true, true, None);
1484
1485 let files = vec![
1486 DiscoveredFile {
1487 id: FileId(0),
1488 path: root.join("src/runtime.ts"),
1489 size_bytes: 1,
1490 },
1491 DiscoveredFile {
1492 id: FileId(1),
1493 path: root.join("src/setup.ts"),
1494 size_bytes: 1,
1495 },
1496 DiscoveredFile {
1497 id: FileId(2),
1498 path: root.join("tests/app.test.ts"),
1499 size_bytes: 1,
1500 },
1501 ];
1502
1503 let mut plugin_result = crate::plugins::AggregatedPluginResult::default();
1504 plugin_result.entry_patterns.push((
1505 crate::plugins::PathRule::new("src/runtime.ts"),
1506 "runtime-plugin".to_string(),
1507 ));
1508 plugin_result.entry_patterns.push((
1509 crate::plugins::PathRule::new("tests/app.test.ts"),
1510 "test-plugin".to_string(),
1511 ));
1512 plugin_result
1513 .always_used
1514 .push(("src/setup.ts".to_string(), "support-plugin".to_string()));
1515 plugin_result
1516 .entry_point_roles
1517 .insert("runtime-plugin".to_string(), EntryPointRole::Runtime);
1518 plugin_result
1519 .entry_point_roles
1520 .insert("test-plugin".to_string(), EntryPointRole::Test);
1521 plugin_result
1522 .entry_point_roles
1523 .insert("support-plugin".to_string(), EntryPointRole::Support);
1524
1525 let entries = discover_plugin_entry_point_sets(&plugin_result, &config, &files);
1526
1527 assert_eq!(entries.runtime.len(), 1, "expected one runtime entry");
1528 assert!(
1529 entries.runtime[0].path.ends_with("src/runtime.ts"),
1530 "runtime entry should stay runtime-only"
1531 );
1532 assert_eq!(entries.test.len(), 1, "expected one test entry");
1533 assert!(
1534 entries.test[0].path.ends_with("tests/app.test.ts"),
1535 "test entry should stay test-only"
1536 );
1537 assert_eq!(
1538 entries.all.len(),
1539 3,
1540 "support entries should stay in all entries"
1541 );
1542 assert!(
1543 entries
1544 .all
1545 .iter()
1546 .any(|entry| entry.path.ends_with("src/setup.ts")),
1547 "support entries should remain in the overall entry-point set"
1548 );
1549 assert!(
1550 !entries
1551 .runtime
1552 .iter()
1553 .any(|entry| entry.path.ends_with("src/setup.ts")),
1554 "support entries should not bleed into runtime reachability"
1555 );
1556 assert!(
1557 !entries
1558 .test
1559 .iter()
1560 .any(|entry| entry.path.ends_with("src/setup.ts")),
1561 "support entries should not bleed into test reachability"
1562 );
1563 }
1564
1565 #[test]
1566 fn resolve_plugin_setup_file_preserves_windows_absolute_path_on_any_host() {
1567 let root = Path::new("/workspace/project");
1568 let setup_file = Path::new(r"C:\workspace\project\setup.ts");
1569
1570 assert_eq!(
1571 plugin_entries::resolve_plugin_setup_file(root, setup_file),
1572 setup_file.to_path_buf()
1573 );
1574 }
1575
1576 #[cfg(windows)]
1577 #[test]
1578 fn resolve_plugin_setup_file_preserves_posix_rooted_path_on_windows() {
1579 let root = Path::new(r"C:\workspace\project");
1580 let setup_file = Path::new(r"/workspace/project/setup.ts");
1581
1582 assert_eq!(
1583 plugin_entries::resolve_plugin_setup_file(root, setup_file),
1584 setup_file.to_path_buf()
1585 );
1586 }
1587
1588 #[test]
1589 fn plugin_entry_point_rules_respect_exclusions() {
1590 let dir = tempfile::tempdir().expect("create temp dir");
1591 let root = dir.path();
1592 std::fs::create_dir_all(root.join("app/pages")).unwrap();
1593 std::fs::write(
1594 root.join("app/pages/index.tsx"),
1595 "export default function Page() { return null; }",
1596 )
1597 .unwrap();
1598 std::fs::write(
1599 root.join("app/pages/-helper.ts"),
1600 "export const helper = 1;",
1601 )
1602 .unwrap();
1603
1604 let config = FallowConfig {
1605 type_aware: fallow_config::TypeAwareConfig::default(),
1606 schema: None,
1607 minimum_version: None,
1608 extends: vec![],
1609 entry: vec![],
1610 ignore_patterns: vec![],
1611 ignore_findings: vec![],
1612 framework: vec![],
1613 workspaces: None,
1614 ignore_dependencies: vec![],
1615 ignore_command_entries: vec![],
1616 ignore_unresolved_imports: vec![],
1617 ignore_exports: vec![],
1618 ignore_catalog_references: vec![],
1619 ignore_dependency_overrides: vec![],
1620 ignore_exports_used_in_file: fallow_config::IgnoreExportsUsedInFileConfig::default(),
1621 used_class_members: vec![],
1622 ignore_decorators: vec![],
1623 unused_component_props: fallow_config::UnusedComponentPropsConfig::default(),
1624 circular_dependencies: fallow_config::CircularDependenciesConfig::default(),
1625 duplicates: fallow_config::DuplicatesConfig::default(),
1626 similar_code: fallow_config::SimilarCodeConfig::default(),
1627 mutation: fallow_config::MutationConfig::default(),
1628 health: fallow_config::HealthConfig::default(),
1629 rules: RulesConfig::default(),
1630 boundaries: fallow_config::BoundaryConfig::default(),
1631 production: false.into(),
1632 plugins: vec![],
1633 rule_packs: vec![],
1634 overrides: vec![],
1635 regression: None,
1636 audit: fallow_config::AuditConfig::default(),
1637 codeowners: None,
1638 public_packages: vec![],
1639 flags: fallow_config::FlagsConfig::default(),
1640 security: fallow_config::SecurityConfig::default(),
1641 fix: fallow_config::FixConfig::default(),
1642 resolve: fallow_config::ResolveConfig::default(),
1643 sealed: false,
1644 include_entry_exports: false,
1645 show_cascade: false,
1646 auto_imports: false,
1647 fail_on_parse_error: false,
1648 cache: fallow_config::CacheConfig::default(),
1649 ..Default::default()
1650 }
1651 .resolve(root.to_path_buf(), OutputFormat::Human, 4, true, true, None);
1652
1653 let files = vec![
1654 DiscoveredFile {
1655 id: FileId(0),
1656 path: root.join("app/pages/index.tsx"),
1657 size_bytes: 1,
1658 },
1659 DiscoveredFile {
1660 id: FileId(1),
1661 path: root.join("app/pages/-helper.ts"),
1662 size_bytes: 1,
1663 },
1664 ];
1665
1666 let mut plugin_result = crate::plugins::AggregatedPluginResult::default();
1667 plugin_result.entry_patterns.push((
1668 crate::plugins::PathRule::new("app/pages/**/*.{ts,tsx,js,jsx}")
1669 .with_excluded_globs(["app/pages/**/-*", "app/pages/**/-*/**/*"]),
1670 "tanstack-router".to_string(),
1671 ));
1672 plugin_result
1673 .entry_point_roles
1674 .insert("tanstack-router".to_string(), EntryPointRole::Runtime);
1675
1676 let entries = discover_plugin_entry_point_sets(&plugin_result, &config, &files);
1677 let entry_paths: Vec<_> = entries
1678 .all
1679 .iter()
1680 .map(|entry| {
1681 entry
1682 .path
1683 .strip_prefix(root)
1684 .unwrap()
1685 .to_string_lossy()
1686 .into_owned()
1687 })
1688 .collect();
1689
1690 assert!(entry_paths.contains(&"app/pages/index.tsx".to_string()));
1691 assert!(!entry_paths.contains(&"app/pages/-helper.ts".to_string()));
1692 }
1693
1694 mod resolve_entry_path_tests {
1695 use super::*;
1696
1697 fn resolve_main(root: &Path, entry: &str) -> Option<PathBuf> {
1698 let canonical = dunce::canonicalize(root).unwrap();
1699 resolve_entry_path(
1700 &canonical,
1701 entry,
1702 &canonical,
1703 EntryPointSource::PackageJsonMain,
1704 )
1705 .map(|entry_point| entry_point.path)
1706 }
1707
1708 #[test]
1709 fn hand_written_lib_entry_wins_over_unrelated_source_index() {
1710 let dir = tempfile::tempdir().expect("create temp dir");
1711 let root = dunce::canonicalize(dir.path()).unwrap();
1712 std::fs::create_dir_all(root.join("lib")).unwrap();
1713 std::fs::create_dir_all(root.join("src")).unwrap();
1714 std::fs::write(root.join("lib/index.js"), "module.exports = {};").unwrap();
1715 std::fs::write(root.join("src/index.ts"), "export {};").unwrap();
1716
1717 assert_eq!(
1718 resolve_main(&root, "./lib/index.js"),
1719 Some(root.join("./lib/index.js"))
1720 );
1721 }
1722
1723 #[test]
1724 fn hand_written_lib_entry_does_not_fall_back_to_source_index() {
1725 let dir = tempfile::tempdir().expect("create temp dir");
1726 let root = dunce::canonicalize(dir.path()).unwrap();
1727 std::fs::create_dir_all(root.join("lib")).unwrap();
1728 std::fs::create_dir_all(root.join("src")).unwrap();
1729 std::fs::write(root.join("lib/foo.js"), "module.exports = {};").unwrap();
1730 std::fs::write(root.join("src/index.ts"), "export {};").unwrap();
1731 std::fs::write(root.join("index.js"), "module.exports = {};").unwrap();
1732
1733 assert_eq!(
1734 resolve_main(&root, "./lib/foo.js"),
1735 Some(root.join("./lib/foo.js"))
1736 );
1737 }
1738
1739 #[test]
1740 fn missing_lib_entry_without_same_stem_source_stays_unresolved() {
1741 let dir = tempfile::tempdir().expect("create temp dir");
1742 let root = dunce::canonicalize(dir.path()).unwrap();
1743 std::fs::create_dir_all(root.join("src")).unwrap();
1744 std::fs::write(root.join("src/index.ts"), "export {};").unwrap();
1745
1746 assert_eq!(resolve_main(&root, "./lib/foo.js"), None);
1747 }
1748
1749 #[test]
1750 fn missing_lib_entry_maps_to_same_stem_source() {
1751 let dir = tempfile::tempdir().expect("create temp dir");
1752 let root = dunce::canonicalize(dir.path()).unwrap();
1753 std::fs::create_dir_all(root.join("src")).unwrap();
1754 std::fs::write(root.join("src/index.ts"), "export {};").unwrap();
1755
1756 assert_eq!(
1757 resolve_main(&root, "./lib/index.mjs"),
1758 Some(root.join("src/index.ts"))
1759 );
1760 }
1761
1762 #[test]
1763 fn resolves_existing_file() {
1764 let dir = tempfile::tempdir().expect("create temp dir");
1765 let src = dir.path().join("src");
1766 std::fs::create_dir_all(&src).unwrap();
1767 std::fs::write(src.join("index.ts"), "export const a = 1;").unwrap();
1768
1769 let canonical = dunce::canonicalize(dir.path()).unwrap();
1770 let result = resolve_entry_path(
1771 dir.path(),
1772 "src/index.ts",
1773 &canonical,
1774 EntryPointSource::PackageJsonMain,
1775 );
1776 assert!(result.is_some(), "should resolve an existing file");
1777 assert!(result.unwrap().path.ends_with("src/index.ts"));
1778 }
1779
1780 #[test]
1781 fn resolves_with_extension_fallback() {
1782 let dir = tempfile::tempdir().expect("create temp dir");
1783 let canonical = dunce::canonicalize(dir.path()).unwrap();
1784 let src = canonical.join("src");
1785 std::fs::create_dir_all(&src).unwrap();
1786 std::fs::write(src.join("index.ts"), "export const a = 1;").unwrap();
1787
1788 let result = resolve_entry_path(
1789 &canonical,
1790 "src/index",
1791 &canonical,
1792 EntryPointSource::PackageJsonMain,
1793 );
1794 assert!(
1795 result.is_some(),
1796 "should resolve via extension fallback when exact path doesn't exist"
1797 );
1798 let ep = result.unwrap();
1799 assert!(
1800 ep.path.to_string_lossy().contains("index.ts"),
1801 "should find index.ts via extension fallback"
1802 );
1803 }
1804
1805 #[test]
1806 fn exact_file_wins_before_directory_index_fallback() {
1807 let dir = tempfile::tempdir().expect("create temp dir");
1808 let canonical = dunce::canonicalize(dir.path()).unwrap();
1809 let scripts = canonical.join("scripts");
1810 std::fs::create_dir_all(scripts.join("process-messages")).unwrap();
1811 std::fs::write(
1812 scripts.join("process-messages.js"),
1813 "export const direct = true;",
1814 )
1815 .unwrap();
1816 std::fs::write(
1817 scripts.join("process-messages").join("index.js"),
1818 "export const index = true;",
1819 )
1820 .unwrap();
1821
1822 let result = resolve_entry_path(
1823 &canonical,
1824 "scripts/process-messages.js",
1825 &canonical,
1826 EntryPointSource::package_json_script("build"),
1827 )
1828 .expect("exact file should resolve");
1829
1830 assert!(result.path.ends_with("scripts/process-messages.js"));
1831 }
1832
1833 #[test]
1834 fn extension_fallback_wins_before_directory_index_fallback() {
1835 let dir = tempfile::tempdir().expect("create temp dir");
1836 let canonical = dunce::canonicalize(dir.path()).unwrap();
1837 let scripts = canonical.join("scripts");
1838 std::fs::create_dir_all(scripts.join("process-messages")).unwrap();
1839 std::fs::write(
1840 scripts.join("process-messages.ts"),
1841 "export const withExt = true;",
1842 )
1843 .unwrap();
1844 std::fs::write(
1845 scripts.join("process-messages").join("index.js"),
1846 "export const index = true;",
1847 )
1848 .unwrap();
1849
1850 let result = resolve_entry_path(
1851 &canonical,
1852 "scripts/process-messages",
1853 &canonical,
1854 EntryPointSource::package_json_script("build"),
1855 )
1856 .expect("extension fallback should resolve");
1857
1858 assert!(result.path.ends_with("scripts/process-messages.ts"));
1859 }
1860
1861 #[test]
1862 fn resolves_directory_index_after_exact_and_extension_fallbacks() {
1863 let dir = tempfile::tempdir().expect("create temp dir");
1864 let canonical = dunce::canonicalize(dir.path()).unwrap();
1865 let scripts = canonical.join("scripts/process-messages");
1866 std::fs::create_dir_all(&scripts).unwrap();
1867 std::fs::write(scripts.join("index.js"), "export const index = true;").unwrap();
1868
1869 let result = resolve_entry_path(
1870 &canonical,
1871 "scripts/process-messages",
1872 &canonical,
1873 EntryPointSource::package_json_script("build"),
1874 )
1875 .expect("directory index should resolve");
1876
1877 assert!(result.path.ends_with("scripts/process-messages/index.js"));
1878 }
1879
1880 #[test]
1881 fn directory_index_fallback_ignores_wildcards_and_url_like_entries() {
1882 let dir = tempfile::tempdir().expect("create temp dir");
1883 let canonical = dunce::canonicalize(dir.path()).unwrap();
1884 std::fs::create_dir_all(canonical.join("scripts/process-messages")).unwrap();
1885 std::fs::write(
1886 canonical.join("scripts/process-messages/index.js"),
1887 "export const index = true;",
1888 )
1889 .unwrap();
1890
1891 for entry in [
1892 "scripts/*",
1893 "https://example.com/scripts/process-messages",
1894 "@scope/package/scripts/process-messages",
1895 ] {
1896 let result = resolve_entry_path(
1897 &canonical,
1898 entry,
1899 &canonical,
1900 EntryPointSource::package_json_script("build"),
1901 );
1902 assert!(result.is_none(), "{entry} should not resolve");
1903 }
1904 }
1905
1906 #[test]
1907 fn returns_none_for_nonexistent_file() {
1908 let dir = tempfile::tempdir().expect("create temp dir");
1909 let canonical = dunce::canonicalize(dir.path()).unwrap();
1910 let result = resolve_entry_path(
1911 dir.path(),
1912 "does/not/exist.ts",
1913 &canonical,
1914 EntryPointSource::PackageJsonMain,
1915 );
1916 assert!(result.is_none(), "should return None for nonexistent files");
1917 }
1918
1919 #[test]
1920 fn maps_dist_output_to_src() {
1921 let dir = tempfile::tempdir().expect("create temp dir");
1922 let src = dir.path().join("src");
1923 std::fs::create_dir_all(&src).unwrap();
1924 std::fs::write(src.join("utils.ts"), "export const u = 1;").unwrap();
1925
1926 let dist = dir.path().join("dist");
1927 std::fs::create_dir_all(&dist).unwrap();
1928 std::fs::write(dist.join("utils.js"), "// compiled").unwrap();
1929
1930 let canonical = dunce::canonicalize(dir.path()).unwrap();
1931 let result = resolve_entry_path(
1932 dir.path(),
1933 "./dist/utils.js",
1934 &canonical,
1935 EntryPointSource::PackageJsonExports,
1936 );
1937 assert!(result.is_some(), "should resolve dist/ path to src/");
1938 let ep = result.unwrap();
1939 assert!(
1940 ep.path
1941 .to_string_lossy()
1942 .replace('\\', "/")
1943 .contains("src/utils.ts"),
1944 "should map ./dist/utils.js to src/utils.ts"
1945 );
1946 }
1947
1948 #[test]
1949 fn maps_build_output_to_src() {
1950 let dir = tempfile::tempdir().expect("create temp dir");
1951 let canonical = dunce::canonicalize(dir.path()).unwrap();
1952 let src = canonical.join("src");
1953 std::fs::create_dir_all(&src).unwrap();
1954 std::fs::write(src.join("index.tsx"), "export default () => {};").unwrap();
1955
1956 let result = resolve_entry_path(
1957 &canonical,
1958 "./build/index.js",
1959 &canonical,
1960 EntryPointSource::PackageJsonExports,
1961 );
1962 assert!(result.is_some(), "should map build/ output to src/");
1963 let ep = result.unwrap();
1964 assert!(
1965 ep.path
1966 .to_string_lossy()
1967 .replace('\\', "/")
1968 .contains("src/index.tsx"),
1969 "should map ./build/index.js to src/index.tsx"
1970 );
1971 }
1972
1973 #[test]
1974 fn preserves_entry_point_source() {
1975 let dir = tempfile::tempdir().expect("create temp dir");
1976 std::fs::write(dir.path().join("index.ts"), "export const a = 1;").unwrap();
1977
1978 let canonical = dunce::canonicalize(dir.path()).unwrap();
1979 let result = resolve_entry_path(
1980 dir.path(),
1981 "index.ts",
1982 &canonical,
1983 EntryPointSource::package_json_script("build"),
1984 );
1985 assert!(result.is_some());
1986 assert_eq!(result.unwrap().source.script(), Some("build"));
1987 }
1988 #[test]
1989 fn tracks_skipped_entries_without_logging_each_repeat() {
1990 let dir = tempfile::tempdir().expect("create temp dir");
1991 let canonical = dunce::canonicalize(dir.path()).unwrap();
1992 let mut skipped_entries = FxHashMap::default();
1993
1994 let result = resolve_entry_path_with_tracking(
1995 dir.path(),
1996 "../scripts/build.js",
1997 &canonical,
1998 EntryPointSource::package_json_script("build"),
1999 Some(&mut skipped_entries),
2000 None,
2001 );
2002
2003 assert!(result.is_none(), "unsafe entry should be skipped");
2004 assert_eq!(
2005 skipped_entries.get("../scripts/build.js"),
2006 Some(&1),
2007 "warning tracker should count the skipped path"
2008 );
2009 }
2010
2011 #[test]
2012 fn formats_skipped_entry_warning_with_counts() {
2013 let mut skipped_entries = FxHashMap::default();
2014 skipped_entries.insert("../../scripts/rm.mjs".to_owned(), 8);
2015 skipped_entries.insert("../utils/bar.js".to_owned(), 2);
2016
2017 let warning =
2018 format_skipped_entry_warning(&skipped_entries).expect("warning should be rendered");
2019
2020 assert_eq!(
2021 warning,
2022 "Skipped 10 package.json entry points outside project root or containing parent directory traversal: ../../scripts/rm.mjs (8x), ../utils/bar.js (2x)"
2023 );
2024 }
2025
2026 #[test]
2027 fn skipped_entry_summary_dedupes_identical_messages() {
2028 let message = format!(
2029 "Skipped 1 package.json entry point outside project root: ../../pkg-{}/bin/x",
2030 std::process::id()
2031 );
2032 assert!(
2033 should_warn_skipped_entry(&message),
2034 "first occurrence of a message emits"
2035 );
2036 assert!(
2037 !should_warn_skipped_entry(&message),
2038 "identical repeat is suppressed"
2039 );
2040 }
2041
2042 #[test]
2043 fn rejects_parent_dir_escape_for_exact_file() {
2044 let sandbox = tempfile::tempdir().expect("create sandbox");
2045 let root = sandbox.path().join("project");
2046 std::fs::create_dir_all(&root).unwrap();
2047 std::fs::write(
2048 sandbox.path().join("escape.ts"),
2049 "export const escape = true;",
2050 )
2051 .unwrap();
2052
2053 let canonical = dunce::canonicalize(&root).unwrap();
2054 let result = resolve_entry_path(
2055 &root,
2056 "../escape.ts",
2057 &canonical,
2058 EntryPointSource::PackageJsonMain,
2059 );
2060
2061 assert!(
2062 result.is_none(),
2063 "should reject exact paths that escape the root"
2064 );
2065 }
2066
2067 #[test]
2068 fn rejects_parent_dir_escape_via_extension_fallback() {
2069 let sandbox = tempfile::tempdir().expect("create sandbox");
2070 let root = sandbox.path().join("project");
2071 std::fs::create_dir_all(&root).unwrap();
2072 std::fs::write(
2073 sandbox.path().join("escape.ts"),
2074 "export const escape = true;",
2075 )
2076 .unwrap();
2077
2078 let canonical = dunce::canonicalize(&root).unwrap();
2079 let result = resolve_entry_path(
2080 &root,
2081 "../escape",
2082 &canonical,
2083 EntryPointSource::PackageJsonMain,
2084 );
2085
2086 assert!(
2087 result.is_none(),
2088 "should reject extension fallback paths that escape the root"
2089 );
2090 }
2091 }
2092
2093 mod output_to_source_tests {
2094 use super::*;
2095
2096 fn try_legacy_output_to_source_path(base: &Path, entry: &str) -> Option<PathBuf> {
2099 output_entry_to_source_path(base, entry, SOURCE_EXTENSIONS, |_| true)
2100 }
2101
2102 #[test]
2103 fn maps_dist_to_src_with_ts_extension() {
2104 let dir = tempfile::tempdir().expect("create temp dir");
2105 let src = dir.path().join("src");
2106 std::fs::create_dir_all(&src).unwrap();
2107 std::fs::write(src.join("utils.ts"), "export const u = 1;").unwrap();
2108
2109 let result = try_legacy_output_to_source_path(dir.path(), "./dist/utils.js");
2110 assert!(result.is_some());
2111 assert!(
2112 result
2113 .unwrap()
2114 .to_string_lossy()
2115 .replace('\\', "/")
2116 .contains("src/utils.ts")
2117 );
2118 }
2119
2120 #[test]
2121 fn returns_none_when_no_source_file_exists() {
2122 let dir = tempfile::tempdir().expect("create temp dir");
2123 let result = try_legacy_output_to_source_path(dir.path(), "./dist/missing.js");
2124 assert!(result.is_none());
2125 }
2126
2127 #[test]
2128 fn ignores_non_output_directories() {
2129 let dir = tempfile::tempdir().expect("create temp dir");
2130 let src = dir.path().join("src");
2131 std::fs::create_dir_all(&src).unwrap();
2132 std::fs::write(src.join("foo.ts"), "export const f = 1;").unwrap();
2133
2134 let result = try_legacy_output_to_source_path(dir.path(), "./scripts/foo.js");
2135 assert!(result.is_none());
2136 }
2137
2138 #[test]
2139 fn maps_lib_entry_to_source_only_when_lib_target_is_missing() {
2140 let dir = tempfile::tempdir().expect("create temp dir");
2141 let src = dir.path().join("src");
2142 std::fs::create_dir_all(&src).unwrap();
2143 std::fs::write(src.join("foo.ts"), "export const f = 1;").unwrap();
2144
2145 assert_eq!(
2146 try_legacy_output_to_source_path(dir.path(), "./lib/foo.js"),
2147 Some(src.join("foo.ts")),
2148 "a missing lib/ build output maps to the same-stem source file"
2149 );
2150
2151 let lib = dir.path().join("lib");
2152 std::fs::create_dir_all(&lib).unwrap();
2153 std::fs::write(lib.join("foo.js"), "exports.f = 1;").unwrap();
2154 assert_eq!(
2155 try_legacy_output_to_source_path(dir.path(), "./lib/foo.js"),
2156 None,
2157 "a lib/ file on disk stays the entry"
2158 );
2159 }
2160
2161 #[test]
2162 fn lib_entry_without_extension_counts_as_present() {
2163 let dir = tempfile::tempdir().expect("create temp dir");
2164 std::fs::create_dir_all(dir.path().join("src")).unwrap();
2165 std::fs::write(dir.path().join("src/index.ts"), "export {};").unwrap();
2166 std::fs::create_dir_all(dir.path().join("lib")).unwrap();
2167 std::fs::write(dir.path().join("lib/index.js"), "module.exports = {};").unwrap();
2168
2169 assert_eq!(
2170 try_legacy_output_to_source_path(dir.path(), "./lib/index"),
2171 None
2172 );
2173 assert_eq!(try_legacy_output_to_source_path(dir.path(), "./lib"), None);
2174 }
2175
2176 #[test]
2177 fn maps_missing_lib_entry_with_nested_prefix() {
2178 let dir = tempfile::tempdir().expect("create temp dir");
2179 let modules_src = dir.path().join("modules/src");
2180 std::fs::create_dir_all(&modules_src).unwrap();
2181 std::fs::write(modules_src.join("x.ts"), "export const x = 1;").unwrap();
2182
2183 assert_eq!(
2184 try_legacy_output_to_source_path(dir.path(), "./modules/lib/x.mjs"),
2185 Some(modules_src.join("x.ts"))
2186 );
2187 }
2188
2189 #[test]
2190 fn bare_missing_lib_entry_does_not_map_to_source_directory() {
2191 let dir = tempfile::tempdir().expect("create temp dir");
2192 std::fs::create_dir_all(dir.path().join("src")).unwrap();
2193
2194 assert_eq!(try_legacy_output_to_source_path(dir.path(), "./lib"), None);
2195 }
2196
2197 #[test]
2198 fn lib_is_not_an_index_fallback_output_dir() {
2199 assert!(!is_entry_in_output_dir("./lib/foo.js"));
2200 }
2201
2202 #[test]
2203 fn maps_nested_output_path_preserving_prefix() {
2204 let dir = tempfile::tempdir().expect("create temp dir");
2205 let modules_src = dir.path().join("modules").join("src");
2206 std::fs::create_dir_all(&modules_src).unwrap();
2207 std::fs::write(modules_src.join("helper.ts"), "export const h = 1;").unwrap();
2208
2209 let result = try_legacy_output_to_source_path(dir.path(), "./modules/dist/helper.js");
2210 assert!(result.is_some());
2211 assert!(
2212 result
2213 .unwrap()
2214 .to_string_lossy()
2215 .replace('\\', "/")
2216 .contains("modules/src/helper.ts")
2217 );
2218 }
2219 }
2220
2221 mod source_index_fallback_tests {
2222 use super::*;
2223
2224 #[test]
2225 fn detects_dist_entry_in_output_dir() {
2226 assert!(is_entry_in_output_dir("./dist/esm2022/index.js"));
2227 assert!(is_entry_in_output_dir("dist/index.js"));
2228 assert!(is_entry_in_output_dir("./build/index.js"));
2229 assert!(is_entry_in_output_dir("./out/main.js"));
2230 assert!(is_entry_in_output_dir("./esm/index.js"));
2231 assert!(is_entry_in_output_dir("./cjs/index.js"));
2232 }
2233
2234 #[test]
2235 fn rejects_non_output_entry_paths() {
2236 assert!(!is_entry_in_output_dir("./src/index.ts"));
2237 assert!(!is_entry_in_output_dir("src/main.ts"));
2238 assert!(!is_entry_in_output_dir("./index.js"));
2239 assert!(!is_entry_in_output_dir(""));
2240 }
2241
2242 #[test]
2243 fn root_index_entries_are_recognized_for_source_fallback() {
2244 assert!(is_package_root_index_entry("./index.js"));
2245 assert!(is_package_root_index_entry("index.cjs"));
2246 assert!(is_package_root_index_entry("./index.d.ts"));
2247 assert!(!is_package_root_index_entry("./src/index.js"));
2248 assert!(!is_package_root_index_entry("./main.js"));
2249 assert!(!is_package_root_index_entry(""));
2250 }
2251
2252 #[test]
2253 fn rejects_substring_match_for_output_dir() {
2254 assert!(!is_entry_in_output_dir("./distro/index.js"));
2255 assert!(!is_entry_in_output_dir("./build-scripts/run.js"));
2256 }
2257
2258 #[test]
2259 fn finds_src_index_ts() {
2260 let dir = tempfile::tempdir().expect("create temp dir");
2261 let src = dir.path().join("src");
2262 std::fs::create_dir_all(&src).unwrap();
2263 let index_path = src.join("index.ts");
2264 std::fs::write(&index_path, "export const a = 1;").unwrap();
2265
2266 let result = try_source_index_fallback(dir.path());
2267 assert_eq!(result.as_deref(), Some(index_path.as_path()));
2268 }
2269
2270 #[test]
2271 fn finds_src_index_tsx_when_ts_missing() {
2272 let dir = tempfile::tempdir().expect("create temp dir");
2273 let src = dir.path().join("src");
2274 std::fs::create_dir_all(&src).unwrap();
2275 let index_path = src.join("index.tsx");
2276 std::fs::write(&index_path, "export default 1;").unwrap();
2277
2278 let result = try_source_index_fallback(dir.path());
2279 assert_eq!(result.as_deref(), Some(index_path.as_path()));
2280 }
2281
2282 #[test]
2283 fn prefers_src_index_over_root_index() {
2284 let dir = tempfile::tempdir().expect("create temp dir");
2285 let src = dir.path().join("src");
2286 std::fs::create_dir_all(&src).unwrap();
2287 let src_index = src.join("index.ts");
2288 std::fs::write(&src_index, "export const a = 1;").unwrap();
2289 let root_index = dir.path().join("index.ts");
2290 std::fs::write(&root_index, "export const b = 2;").unwrap();
2291
2292 let result = try_source_index_fallback(dir.path());
2293 assert_eq!(result.as_deref(), Some(src_index.as_path()));
2294 }
2295
2296 #[test]
2297 fn falls_back_to_src_main() {
2298 let dir = tempfile::tempdir().expect("create temp dir");
2299 let src = dir.path().join("src");
2300 std::fs::create_dir_all(&src).unwrap();
2301 let main_path = src.join("main.ts");
2302 std::fs::write(&main_path, "export const a = 1;").unwrap();
2303
2304 let result = try_source_index_fallback(dir.path());
2305 assert_eq!(result.as_deref(), Some(main_path.as_path()));
2306 }
2307
2308 #[test]
2309 fn falls_back_to_root_index_when_no_src() {
2310 let dir = tempfile::tempdir().expect("create temp dir");
2311 let index_path = dir.path().join("index.js");
2312 std::fs::write(&index_path, "module.exports = {};").unwrap();
2313
2314 let result = try_source_index_fallback(dir.path());
2315 assert_eq!(result.as_deref(), Some(index_path.as_path()));
2316 }
2317
2318 #[test]
2319 fn returns_none_when_nothing_matches() {
2320 let dir = tempfile::tempdir().expect("create temp dir");
2321 let result = try_source_index_fallback(dir.path());
2322 assert!(result.is_none());
2323 }
2324
2325 #[test]
2326 fn resolve_entry_path_falls_back_to_src_index_for_dist_entry() {
2327 let dir = tempfile::tempdir().expect("create temp dir");
2328 let canonical = dunce::canonicalize(dir.path()).unwrap();
2329
2330 let dist_dir = canonical.join("dist").join("esm2022");
2331 std::fs::create_dir_all(&dist_dir).unwrap();
2332 std::fs::write(dist_dir.join("index.js"), "export const x = 1;").unwrap();
2333
2334 let src = canonical.join("src");
2335 std::fs::create_dir_all(&src).unwrap();
2336 let src_index = src.join("index.ts");
2337 std::fs::write(&src_index, "export const x = 1;").unwrap();
2338
2339 let result = resolve_entry_path(
2340 &canonical,
2341 "./dist/esm2022/index.js",
2342 &canonical,
2343 EntryPointSource::PackageJsonMain,
2344 );
2345 assert!(result.is_some());
2346 let entry = result.unwrap();
2347 assert_eq!(entry.path, src_index);
2348 }
2349
2350 #[test]
2351 fn resolve_entry_path_uses_direct_src_mirror_when_available() {
2352 let dir = tempfile::tempdir().expect("create temp dir");
2353 let canonical = dunce::canonicalize(dir.path()).unwrap();
2354
2355 let src_mirror = canonical.join("src").join("esm2022");
2356 std::fs::create_dir_all(&src_mirror).unwrap();
2357 let mirror_index = src_mirror.join("index.ts");
2358 std::fs::write(&mirror_index, "export const x = 1;").unwrap();
2359
2360 let src_index = canonical.join("src").join("index.ts");
2361 std::fs::write(&src_index, "export const y = 2;").unwrap();
2362
2363 let result = resolve_entry_path(
2364 &canonical,
2365 "./dist/esm2022/index.js",
2366 &canonical,
2367 EntryPointSource::PackageJsonMain,
2368 );
2369 assert_eq!(result.map(|e| e.path), Some(mirror_index));
2370 }
2371
2372 #[test]
2375 fn configured_output_without_source_maps_to_an_analyzed_src_file() {
2376 let dir = tempfile::tempdir().expect("create temp dir");
2377 let canonical = dunce::canonicalize(dir.path()).unwrap();
2378 std::fs::write(
2379 canonical.join("tsconfig.build.json"),
2380 r#"{"compilerOptions":{"rootDir":".","outDir":"./dist"}}"#,
2381 )
2382 .unwrap();
2383 std::fs::create_dir_all(canonical.join("src/scripts")).unwrap();
2384 let script = canonical.join("src/scripts/setup.ts");
2385 std::fs::write(&script, "export {};").unwrap();
2386 let entry = "dist/scripts/setup.js";
2387
2388 let analyzed: &(dyn Fn(&Path) -> bool + Sync) = &|_| true;
2389 let result = resolve_entry_path_with_discovered(
2390 &canonical,
2391 entry,
2392 &canonical,
2393 EntryPointSource::package_json_script("build"),
2394 analyzed,
2395 );
2396 assert_eq!(result.map(|e| e.path), Some(script));
2397
2398 let not_analyzed: &(dyn Fn(&Path) -> bool + Sync) = &|_| false;
2399 let result = resolve_entry_path_with_discovered(
2400 &canonical,
2401 entry,
2402 &canonical,
2403 EntryPointSource::package_json_script("build"),
2404 not_analyzed,
2405 );
2406 assert_eq!(
2407 result.map(|e| e.path),
2408 None,
2409 "a source file outside the analyzed files must not become an entry"
2410 );
2411 }
2412
2413 #[test]
2414 fn resolve_entry_path_falls_back_to_src_index_for_missing_root_index() {
2415 let dir = tempfile::tempdir().expect("create temp dir");
2416 let canonical = dunce::canonicalize(dir.path()).unwrap();
2417
2418 let src = canonical.join("src");
2419 std::fs::create_dir_all(&src).unwrap();
2420 let src_index = src.join("index.ts");
2421 std::fs::write(&src_index, "export const x = 1;").unwrap();
2422
2423 let result = resolve_entry_path(
2424 &canonical,
2425 "./index.js",
2426 &canonical,
2427 EntryPointSource::PackageJsonMain,
2428 );
2429 assert_eq!(result.map(|entry| entry.path), Some(src_index));
2430 }
2431 }
2432
2433 mod default_fallback_tests {
2434 use super::*;
2435
2436 #[test]
2437 fn finds_src_index_ts_as_fallback() {
2438 let dir = tempfile::tempdir().expect("create temp dir");
2439 let src = dir.path().join("src");
2440 std::fs::create_dir_all(&src).unwrap();
2441 let index_path = src.join("index.ts");
2442 std::fs::write(&index_path, "export const a = 1;").unwrap();
2443
2444 let files = vec![DiscoveredFile {
2445 id: FileId(0),
2446 path: index_path.clone(),
2447 size_bytes: 20,
2448 }];
2449
2450 let entries = apply_default_fallback(&files, dir.path(), None);
2451 assert_eq!(entries.len(), 1);
2452 assert_eq!(entries[0].path, index_path);
2453 assert!(matches!(entries[0].source, EntryPointSource::DefaultIndex));
2454 }
2455
2456 #[test]
2457 fn finds_root_index_js_as_fallback() {
2458 let dir = tempfile::tempdir().expect("create temp dir");
2459 let index_path = dir.path().join("index.js");
2460 std::fs::write(&index_path, "module.exports = {};").unwrap();
2461
2462 let files = vec![DiscoveredFile {
2463 id: FileId(0),
2464 path: index_path.clone(),
2465 size_bytes: 21,
2466 }];
2467
2468 let entries = apply_default_fallback(&files, dir.path(), None);
2469 assert_eq!(entries.len(), 1);
2470 assert_eq!(entries[0].path, index_path);
2471 }
2472
2473 #[test]
2474 fn returns_empty_when_no_index_file() {
2475 let dir = tempfile::tempdir().expect("create temp dir");
2476 let other_path = dir.path().join("src").join("utils.ts");
2477
2478 let files = vec![DiscoveredFile {
2479 id: FileId(0),
2480 path: other_path,
2481 size_bytes: 10,
2482 }];
2483
2484 let entries = apply_default_fallback(&files, dir.path(), None);
2485 assert!(
2486 entries.is_empty(),
2487 "non-index files should not match default fallback"
2488 );
2489 }
2490
2491 #[test]
2492 fn workspace_filter_restricts_scope() {
2493 let dir = tempfile::tempdir().expect("create temp dir");
2494 let ws_a = dir.path().join("packages").join("a").join("src");
2495 std::fs::create_dir_all(&ws_a).unwrap();
2496 let ws_b = dir.path().join("packages").join("b").join("src");
2497 std::fs::create_dir_all(&ws_b).unwrap();
2498
2499 let index_a = ws_a.join("index.ts");
2500 let index_b = ws_b.join("index.ts");
2501
2502 let files = vec![
2503 DiscoveredFile {
2504 id: FileId(0),
2505 path: index_a.clone(),
2506 size_bytes: 10,
2507 },
2508 DiscoveredFile {
2509 id: FileId(1),
2510 path: index_b,
2511 size_bytes: 10,
2512 },
2513 ];
2514
2515 let ws_root = dir.path().join("packages").join("a");
2516 let entries = apply_default_fallback(&files, &ws_root, Some(&ws_root));
2517 assert_eq!(entries.len(), 1);
2518 assert_eq!(entries[0].path, index_a);
2519 }
2520 }
2521
2522 fn config_for(root: &Path) -> ResolvedConfig {
2523 FallowConfig::default().resolve(
2524 root.to_path_buf(),
2525 OutputFormat::Human,
2526 1,
2527 true,
2528 true,
2529 None,
2530 )
2531 }
2532
2533 fn discovered(root: &Path, rel: &str, id: u32) -> DiscoveredFile {
2534 DiscoveredFile {
2535 id: FileId(id),
2536 path: root.join(rel),
2537 size_bytes: 1,
2538 }
2539 }
2540
2541 fn discover_entry_points_with_warnings(
2543 config: &ResolvedConfig,
2544 files: &[DiscoveredFile],
2545 ) -> EntryPointDiscovery {
2546 let root_pkg = fallow_config::load_dir_package_json(&config.root);
2547 let packages = collect_workspace_packages(&config.root, root_pkg.as_ref(), &[]);
2548 let runtime_seeds = workspace_runtime_script_seeds(&packages);
2549 discover_root_entry_points(
2550 config,
2551 files,
2552 root_pkg.as_ref(),
2553 true,
2554 ScriptWorkspaces {
2555 packages: &packages,
2556 project_root: &config.root,
2557 runtime_seeds: &runtime_seeds,
2558 discovered: None,
2559 },
2560 )
2561 }
2562
2563 fn discover_workspace_entry_points_with_warnings(
2565 ws_root: &Path,
2566 config: &ResolvedConfig,
2567 files: &[DiscoveredFile],
2568 ) -> EntryPointDiscovery {
2569 let pkg = fallow_config::load_dir_package_json(ws_root);
2570 let packages = std::sync::Arc::default();
2571 discover_workspace_package_entry_points(
2572 ws_root,
2573 files,
2574 pkg.as_ref(),
2575 IgnoredCommandEntries::new(&config.ignore_command_entries),
2576 ScriptWorkspaces {
2577 packages: &packages,
2578 project_root: &config.root,
2579 runtime_seeds: &RuntimeScriptSeeds::default(),
2580 discovered: None,
2581 },
2582 )
2583 }
2584
2585 fn workspace(root: &Path, dir: &str, name: &str) -> fallow_config::WorkspaceInfo {
2586 fallow_config::WorkspaceInfo {
2587 root: root.join(dir),
2588 name: name.to_string(),
2589 is_internal_dependency: false,
2590 }
2591 }
2592
2593 #[test]
2594 fn root_entry_points_use_package_json_scripts() {
2595 let dir = tempfile::tempdir().expect("tempdir");
2596 let root = dir.path();
2597 std::fs::create_dir_all(root.join("scripts")).expect("scripts dir");
2598 std::fs::write(root.join("scripts/build.ts"), "export const build = true;")
2599 .expect("script file");
2600 std::fs::write(
2601 root.join("package.json"),
2602 r#"{"scripts":{"build":"tsx scripts/build.ts"}}"#,
2603 )
2604 .expect("package file");
2605 let config = config_for(root);
2606 let files = [discovered(root, "scripts/build.ts", 0)];
2607
2608 let entries = discover_entry_points(&config, &files, &[]);
2609
2610 assert_eq!(entries.len(), 1);
2611 assert!(entries[0].path.ends_with("scripts/build.ts"));
2612 assert!(matches!(
2613 entries[0].source,
2614 EntryPointSource::PackageJsonScript { .. }
2615 ));
2616 }
2617
2618 #[test]
2619 fn build_script_is_support_while_default_index_stays_runtime() {
2620 let dir = tempfile::tempdir().expect("tempdir");
2621 let root = dir.path();
2622 std::fs::create_dir_all(root.join("scripts")).expect("scripts dir");
2623 std::fs::create_dir_all(root.join("src")).expect("src dir");
2624 std::fs::write(root.join("scripts/build.ts"), "export const build = true;")
2625 .expect("script file");
2626 std::fs::write(root.join("src/index.ts"), "export const app = true;").expect("index file");
2627 std::fs::write(
2628 root.join("package.json"),
2629 r#"{"scripts":{"build":"tsx scripts/build.ts"}}"#,
2630 )
2631 .expect("package file");
2632 let config = config_for(root);
2633 let files = [
2634 discovered(root, "scripts/build.ts", 0),
2635 discovered(root, "src/index.ts", 1),
2636 ];
2637
2638 let discovery = discover_entry_points_with_warnings(&config, &files);
2639
2640 assert_eq!(discovery.entries.len(), 1);
2641 assert!(discovery.entries[0].path.ends_with("src/index.ts"));
2642 assert_eq!(discovery.support_entries.len(), 1);
2643 assert!(
2644 discovery.support_entries[0]
2645 .path
2646 .ends_with("scripts/build.ts")
2647 );
2648 }
2649
2650 #[test]
2651 fn indirect_quoted_start_script_stays_runtime() {
2652 let dir = tempfile::tempdir().expect("tempdir");
2653 let root = dir.path();
2654 std::fs::create_dir_all(root.join("src")).expect("src dir");
2655 std::fs::write(root.join("src/server.ts"), "export const server = true;")
2656 .expect("server file");
2657 std::fs::write(
2658 root.join("package.json"),
2659 r#"{"scripts":{"start":"npm run serve","serve":"node 'src/server.ts'"}}"#,
2660 )
2661 .expect("package file");
2662 let config = config_for(root);
2663 let files = [discovered(root, "src/server.ts", 0)];
2664
2665 let discovery = discover_entry_points_with_warnings(&config, &files);
2666
2667 assert_eq!(discovery.entries.len(), 1);
2668 assert!(discovery.entries[0].path.ends_with("src/server.ts"));
2669 assert!(discovery.support_entries.is_empty());
2670 }
2671
2672 #[test]
2673 fn indirect_start_script_includes_its_lifecycle_hooks() {
2674 let dir = tempfile::tempdir().expect("tempdir");
2675 let root = dir.path();
2676 std::fs::create_dir_all(root.join("src")).expect("src dir");
2677 for file in ["pre.ts", "server.ts", "post.ts"] {
2678 std::fs::write(root.join("src").join(file), "export const value = true;")
2679 .expect("runtime file");
2680 }
2681 std::fs::write(
2682 root.join("package.json"),
2683 r#"{"scripts":{"start":"npm run serve","preserve":"node src/pre.ts","serve":"node src/server.ts","postserve":"node src/post.ts"}}"#,
2684 )
2685 .expect("package file");
2686 let config = config_for(root);
2687 let files = [
2688 discovered(root, "src/pre.ts", 0),
2689 discovered(root, "src/server.ts", 1),
2690 discovered(root, "src/post.ts", 2),
2691 ];
2692
2693 let discovery = discover_entry_points_with_warnings(&config, &files);
2694
2695 assert_eq!(discovery.entries.len(), 3);
2696 assert!(discovery.support_entries.is_empty());
2697 }
2698
2699 #[test]
2700 #[expect(
2701 clippy::disallowed_types,
2702 reason = "test input matches the serde-deserialized package.json scripts map"
2703 )]
2704 fn start_does_not_recursively_invent_hooks_for_lifecycle_hooks() {
2705 let scripts = std::collections::HashMap::from([
2706 ("preprestart".to_string(), "node src/tool.ts".to_string()),
2707 ("prestart".to_string(), "node src/pre.ts".to_string()),
2708 ("start".to_string(), "node src/server.ts".to_string()),
2709 ("poststart".to_string(), "node src/post.ts".to_string()),
2710 ("postpoststart".to_string(), "node src/tool.ts".to_string()),
2711 ]);
2712
2713 let runtime = runtime_package_script_names(&scripts);
2714
2715 assert_eq!(
2716 runtime,
2717 FxHashSet::from_iter([
2718 "prestart".to_string(),
2719 "start".to_string(),
2720 "poststart".to_string(),
2721 ])
2722 );
2723 }
2724
2725 #[test]
2726 fn bun_build_script_remains_support_entry() {
2727 let dir = tempfile::tempdir().expect("tempdir");
2728 let root = dir.path();
2729 std::fs::create_dir_all(root.join("scripts")).expect("scripts dir");
2730 std::fs::write(root.join("scripts/build.ts"), "export const build = true;")
2731 .expect("build file");
2732 std::fs::write(
2733 root.join("package.json"),
2734 r#"{"scripts":{"build":"bun scripts/build.ts"}}"#,
2735 )
2736 .expect("package file");
2737 let config = config_for(root);
2738 let files = [discovered(root, "scripts/build.ts", 0)];
2739
2740 let discovery = discover_entry_points_with_warnings(&config, &files);
2741
2742 assert!(discovery.entries.is_empty());
2743 assert_eq!(discovery.support_entries.len(), 1);
2744 }
2745
2746 #[test]
2747 fn start_script_config_remains_support_only() {
2748 let dir = tempfile::tempdir().expect("tempdir");
2749 let root = dir.path();
2750 std::fs::write(root.join("vite.config.ts"), "export default {};").expect("config file");
2751 std::fs::write(
2752 root.join("package.json"),
2753 r#"{"scripts":{"start":"vite --config vite.config.ts"}}"#,
2754 )
2755 .expect("package file");
2756 let config = config_for(root);
2757 let files = [discovered(root, "vite.config.ts", 0)];
2758
2759 let discovery = discover_entry_points_with_warnings(&config, &files);
2760
2761 assert!(discovery.entries.is_empty());
2762 assert_eq!(discovery.support_entries.len(), 1);
2763 assert!(
2764 discovery.support_entries[0]
2765 .path
2766 .ends_with("vite.config.ts")
2767 );
2768 }
2769
2770 #[test]
2771 fn manifest_entry_remains_runtime_when_build_script_references_same_path() {
2772 let dir = tempfile::tempdir().expect("tempdir");
2773 let root = dir.path();
2774 std::fs::create_dir_all(root.join("src")).expect("src dir");
2775 std::fs::write(root.join("src/index.ts"), "export const app = true;").expect("index file");
2776 std::fs::write(
2777 root.join("package.json"),
2778 r#"{"main":"src/index.ts","scripts":{"build":"tsx src/index.ts"}}"#,
2779 )
2780 .expect("package file");
2781 let config = config_for(root);
2782 let files = [discovered(root, "src/index.ts", 0)];
2783
2784 let discovery = discover_entry_points_with_warnings(&config, &files);
2785
2786 assert_eq!(discovery.entries.len(), 1);
2787 assert!(discovery.entries[0].path.ends_with("src/index.ts"));
2788 }
2789
2790 #[test]
2791 fn workspace_build_script_is_support_with_runtime_fallback() {
2792 let dir = tempfile::tempdir().expect("tempdir");
2793 let root = dir.path();
2794 let workspace = root.join("packages/app");
2795 std::fs::create_dir_all(workspace.join("scripts")).expect("scripts dir");
2796 std::fs::create_dir_all(workspace.join("src")).expect("src dir");
2797 std::fs::write(
2798 workspace.join("scripts/build.ts"),
2799 "export const build = true;",
2800 )
2801 .expect("script file");
2802 std::fs::write(workspace.join("src/index.ts"), "export const app = true;")
2803 .expect("index file");
2804 std::fs::write(
2805 workspace.join("package.json"),
2806 r#"{"name":"app","scripts":{"build":"tsx scripts/build.ts"}}"#,
2807 )
2808 .expect("package file");
2809 let files = [
2810 discovered(root, "packages/app/scripts/build.ts", 0),
2811 discovered(root, "packages/app/src/index.ts", 1),
2812 ];
2813
2814 let discovery =
2815 discover_workspace_entry_points_with_warnings(&workspace, &config_for(root), &files);
2816
2817 assert_eq!(discovery.entries.len(), 1);
2818 assert!(discovery.entries[0].path.ends_with("src/index.ts"));
2819 assert_eq!(discovery.support_entries.len(), 1);
2820 assert!(
2821 discovery.support_entries[0]
2822 .path
2823 .ends_with("scripts/build.ts")
2824 );
2825 }
2826
2827 #[test]
2828 fn workspace_script_selected_by_root_start_is_runtime() {
2829 let dir = tempfile::tempdir().expect("tempdir");
2830 let root = dir.path();
2831 let workspace = root.join("packages/api");
2832 std::fs::create_dir_all(workspace.join("src")).expect("src dir");
2833 std::fs::write(workspace.join("src/server.ts"), "export const app = true;")
2834 .expect("server file");
2835 let workspace_pkg: PackageJson = serde_json::from_str(
2836 r#"{"name":"@scope/api","scripts":{"serve":"node src/server.ts"}}"#,
2837 )
2838 .expect("workspace package");
2839 let files = [discovered(root, "packages/api/src/server.ts", 0)];
2840 let runtime_seeds = RuntimeScriptSeeds::from_iter([(
2841 "packages/api".to_string(),
2842 FxHashSet::from_iter(["serve".to_string()]),
2843 )]);
2844
2845 let packages = std::sync::Arc::default();
2846 let discovery = discover_workspace_package_entry_points(
2847 &workspace,
2848 &files,
2849 Some(&workspace_pkg),
2850 IgnoredCommandEntries::NONE,
2851 ScriptWorkspaces {
2852 packages: &packages,
2853 project_root: root,
2854 runtime_seeds: &runtime_seeds,
2855 discovered: None,
2856 },
2857 );
2858
2859 assert_eq!(discovery.entries.len(), 1);
2860 assert!(discovery.entries[0].path.ends_with("src/server.ts"));
2861 assert!(discovery.support_entries.is_empty());
2862 }
2863
2864 #[test]
2865 fn scripts_that_select_workspace_packages_add_entries_in_each_pass() {
2866 let dir = tempfile::tempdir().expect("tempdir");
2867 let root = dir.path();
2868 for file in [
2869 "packages/web/scripts/root-start.ts",
2870 "packages/web/scripts/api-start.ts",
2871 "packages/web/scripts/gen.ts",
2872 ] {
2873 let path = root.join(file);
2874 std::fs::create_dir_all(path.parent().expect("parent")).expect("dir");
2875 std::fs::write(path, "export const run = true;").expect("script file");
2876 }
2877 let root_pkg: PackageJson = serde_json::from_str(
2878 r#"{"scripts":{"start":"yarn workspace web node scripts/root-start.ts"}}"#,
2879 )
2880 .expect("root package");
2881 let api_pkg: PackageJson = serde_json::from_str(
2882 r#"{
2883 "name": "api",
2884 "scripts": {
2885 "start": "yarn workspace web node scripts/api-start.ts",
2886 "gen": "pnpm -r exec tsx scripts/gen.ts"
2887 }
2888 }"#,
2889 )
2890 .expect("api package");
2891 let mut packages = crate::scripts::WorkspacePackages::default();
2892 packages.add("web", "packages/web", None);
2893 packages.add("api", "packages/api", api_pkg.scripts.as_ref());
2894 let packages = std::sync::Arc::new(packages);
2895 let runtime_seeds = RuntimeScriptSeeds::default();
2896 let workspaces = ScriptWorkspaces {
2897 packages: &packages,
2898 project_root: root,
2899 runtime_seeds: &runtime_seeds,
2900 discovered: None,
2901 };
2902 let config = config_for(root);
2903
2904 let root_discovery =
2905 discover_root_entry_points(&config, &[], Some(&root_pkg), false, workspaces);
2906 assert!(
2907 root_discovery
2908 .entries
2909 .iter()
2910 .any(|entry| entry.path.ends_with("packages/web/scripts/root-start.ts")),
2911 "a root start script that selects a package adds a runtime entry: {:?}",
2912 root_discovery.entries
2913 );
2914
2915 let api_discovery = discover_workspace_package_entry_points(
2916 &root.join("packages/api"),
2917 &[],
2918 Some(&api_pkg),
2919 IgnoredCommandEntries::NONE,
2920 workspaces,
2921 );
2922 assert!(
2923 api_discovery
2924 .entries
2925 .iter()
2926 .any(|entry| entry.path.ends_with("packages/web/scripts/api-start.ts")),
2927 "a package start script that selects another package adds a runtime entry: {:?}",
2928 api_discovery.entries
2929 );
2930 assert!(
2931 api_discovery
2932 .support_entries
2933 .iter()
2934 .any(|entry| entry.path.ends_with("packages/web/scripts/gen.ts")),
2935 "`pnpm -r exec` adds the file of each package where it exists: {:?}",
2936 api_discovery.support_entries
2937 );
2938 assert!(
2939 api_discovery.skipped_entries.is_empty(),
2940 "a file outside the calling package resolves from the project root: {:?}",
2941 api_discovery.skipped_entries
2942 );
2943 }
2944
2945 #[test]
2946 fn workspace_script_selection_does_not_promote_same_named_root_script() {
2947 let dir = tempfile::tempdir().expect("tempdir");
2948 let root = dir.path();
2949 let root_pkg: PackageJson = serde_json::from_str(
2950 r#"{
2951 "scripts": {
2952 "start": "pnpm --filter=@scope/api run serve",
2953 "serve": "node src/unrelated.ts"
2954 }
2955 }"#,
2956 )
2957 .expect("root package");
2958 let api_pkg: PackageJson = serde_json::from_str(
2959 r#"{"name":"@scope/api","scripts":{"serve":"node src/server.ts"}}"#,
2960 )
2961 .expect("api package");
2962 let workspace_pkgs = vec![(workspace(root, "packages/api", "@scope/api"), api_pkg)];
2963 let scripts = root_pkg.scripts.as_ref().expect("root scripts");
2964
2965 let runtime = runtime_package_script_names(scripts);
2966 let packages = collect_workspace_packages(root, Some(&root_pkg), &workspace_pkgs);
2967 let workspace_seeds = workspace_runtime_script_seeds(&packages);
2968
2969 assert_eq!(runtime, FxHashSet::from_iter(["start".to_string()]));
2970 assert_eq!(
2971 workspace_seeds,
2972 RuntimeScriptSeeds::from_iter([(
2973 "packages/api".to_string(),
2974 FxHashSet::from_iter(["serve".to_string()])
2975 )])
2976 );
2977 }
2978
2979 #[test]
2980 fn workspace_runtime_script_seeds_follow_transitive_workspace_calls() {
2981 let dir = tempfile::tempdir().expect("tempdir");
2982 let root = dir.path();
2983 let root_pkg: PackageJson =
2984 serde_json::from_str(r#"{"scripts":{"start":"pnpm --filter @scope/api run serve"}}"#)
2985 .expect("root package");
2986 let api_pkg: PackageJson = serde_json::from_str(
2987 r#"{"name":"@scope/api","scripts":{"serve":"npm --workspace ../worker run work"}}"#,
2988 )
2989 .expect("api package");
2990 let worker_pkg: PackageJson = serde_json::from_str(
2991 r#"{"name":"@scope/worker","scripts":{"prework":"node pre.ts","work":"node worker.ts"}}"#,
2992 )
2993 .expect("worker package");
2994 let workspace_pkgs = vec![
2995 (workspace(root, "packages/api", "@scope/api"), api_pkg),
2996 (
2997 workspace(root, "packages/worker", "@scope/worker"),
2998 worker_pkg,
2999 ),
3000 ];
3001
3002 let packages = collect_workspace_packages(root, Some(&root_pkg), &workspace_pkgs);
3003 let seeds = workspace_runtime_script_seeds(&packages);
3004
3005 assert_eq!(
3006 seeds.get("packages/api"),
3007 Some(&FxHashSet::from_iter(["serve".to_string()]))
3008 );
3009 assert_eq!(
3010 seeds.get("packages/worker"),
3011 Some(&FxHashSet::from_iter([
3012 "prework".to_string(),
3013 "work".to_string(),
3014 ]))
3015 );
3016 }
3017
3018 #[test]
3019 fn every_selection_form_seeds_the_runtime_scripts_of_the_selected_packages() {
3020 let dir = tempfile::tempdir().expect("tempdir");
3021 let root = dir.path();
3022 let web_pkg: PackageJson = serde_json::from_str(
3023 r#"{"name":"web","scripts":{"preserve":"node pre.ts","serve":"node web.ts"}}"#,
3024 )
3025 .expect("web package");
3026 let api_pkg: PackageJson =
3027 serde_json::from_str(r#"{"name":"api","scripts":{"serve":"node api.ts"}}"#)
3028 .expect("api package");
3029 let workspace_pkgs = vec![
3030 (workspace(root, "packages/web", "web"), web_pkg),
3031 (workspace(root, "packages/api", "api"), api_pkg),
3032 ];
3033 let web_serve = FxHashSet::from_iter(["preserve".to_string(), "serve".to_string()]);
3034 let api_serve = FxHashSet::from_iter(["serve".to_string()]);
3035 for (start, expected) in [
3036 (
3037 "pnpm -r run serve",
3038 vec![("packages/api", &api_serve), ("packages/web", &web_serve)],
3039 ),
3040 (
3041 "pnpm -C packages/web run serve",
3042 vec![("packages/web", &web_serve)],
3043 ),
3044 (
3045 "pnpm --dir=packages/web serve",
3046 vec![("packages/web", &web_serve)],
3047 ),
3048 (
3049 "npm --prefix packages/web run serve",
3050 vec![("packages/web", &web_serve)],
3051 ),
3052 (
3053 "yarn --cwd packages/web serve",
3054 vec![("packages/web", &web_serve)],
3055 ),
3056 (
3057 "yarn workspaces foreach -A run serve",
3058 vec![("packages/api", &api_serve), ("packages/web", &web_serve)],
3059 ),
3060 (
3061 "pnpm --filter './packages/*' --filter '!api' run serve",
3062 vec![("packages/web", &web_serve)],
3063 ),
3064 ] {
3065 let root_pkg: PackageJson =
3066 serde_json::from_str(&format!(r#"{{"scripts":{{"start":"{start}"}}}}"#))
3067 .expect("root package");
3068 let packages = collect_workspace_packages(root, Some(&root_pkg), &workspace_pkgs);
3069 let seeds = workspace_runtime_script_seeds(&packages);
3070 let expected: RuntimeScriptSeeds = expected
3071 .into_iter()
3072 .map(|(dir, names)| (dir.to_string(), names.clone()))
3073 .collect();
3074 assert_eq!(seeds, expected, "`{start}`");
3075 }
3076 }
3077
3078 #[test]
3079 fn a_workspace_start_script_seeds_a_script_of_the_root_package() {
3080 let dir = tempfile::tempdir().expect("tempdir");
3081 let root = dir.path();
3082 let root_pkg: PackageJson =
3083 serde_json::from_str(r#"{"name":"monorepo","scripts":{"serve":"node server.ts"}}"#)
3084 .expect("root package");
3085 let web_pkg: PackageJson =
3086 serde_json::from_str(r#"{"name":"web","scripts":{"start":"pnpm -w run serve"}}"#)
3087 .expect("web package");
3088 let workspace_pkgs = vec![(workspace(root, "packages/web", "web"), web_pkg)];
3089
3090 let packages = collect_workspace_packages(root, Some(&root_pkg), &workspace_pkgs);
3091 let seeds = workspace_runtime_script_seeds(&packages);
3092
3093 assert_eq!(
3094 seeds,
3095 RuntimeScriptSeeds::from_iter([(
3096 String::new(),
3097 FxHashSet::from_iter(["serve".to_string()])
3098 )])
3099 );
3100 }
3101
3102 #[test]
3103 fn root_entry_points_fall_back_to_default_index() {
3104 let dir = tempfile::tempdir().expect("tempdir");
3105 let root = dir.path();
3106 std::fs::create_dir_all(root.join("src")).expect("src dir");
3107 std::fs::write(root.join("src/index.ts"), "export const main = true;").expect("index file");
3108 let config = config_for(root);
3109 let files = [discovered(root, "src/index.ts", 0)];
3110
3111 let entries = discover_entry_points(&config, &files, &[]);
3112
3113 assert_eq!(entries.len(), 1);
3114 assert!(entries[0].path.ends_with("src/index.ts"));
3115 assert!(matches!(entries[0].source, EntryPointSource::DefaultIndex));
3116 }
3117
3118 #[test]
3119 fn default_index_matchers_preserve_patterns_and_are_shared() {
3120 let matchers = default_index_matchers();
3121 for path in [
3122 "src/index.ts",
3123 "src/index.tsx",
3124 "src/index.js",
3125 "src/index.jsx",
3126 "src/main.ts",
3127 "src/main.tsx",
3128 "src/main.js",
3129 "src/main.jsx",
3130 "index.ts",
3131 "index.tsx",
3132 "index.js",
3133 "index.jsx",
3134 "main.ts",
3135 "main.tsx",
3136 "main.js",
3137 "main.jsx",
3138 ] {
3139 assert!(
3140 matchers.is_match(path),
3141 "default index did not match {path}"
3142 );
3143 }
3144 for path in [
3145 "src/index.mts",
3146 "src/nested/index.ts",
3147 "packages/app/src/index.ts",
3148 "custom-entry.ts",
3149 ] {
3150 assert!(!matchers.is_match(path), "non-default index matched {path}");
3151 }
3152
3153 std::thread::scope(|scope| {
3154 let handles = std::iter::repeat_with(|| scope.spawn(default_index_matchers))
3155 .take(4)
3156 .collect::<Vec<_>>();
3157 for handle in handles {
3158 let from_thread = handle.join().expect("fallback matcher thread");
3159 assert!(std::ptr::eq(matchers, from_thread));
3160 }
3161 });
3162 }
3163
3164 #[test]
3165 fn workspace_entry_points_use_workspace_package_json() {
3166 let dir = tempfile::tempdir().expect("tempdir");
3167 let root = dir.path();
3168 let ws_root = root.join("packages/app");
3169 std::fs::create_dir_all(ws_root.join("src")).expect("workspace src dir");
3170 std::fs::write(ws_root.join("src/main.ts"), "export const main = true;")
3171 .expect("workspace main");
3172 std::fs::write(ws_root.join("package.json"), r#"{"main":"src/main.ts"}"#)
3173 .expect("workspace package file");
3174 let config = config_for(root);
3175 let files = [discovered(root, "packages/app/src/main.ts", 0)];
3176
3177 let entries =
3178 discover_entry_points(&config, &files, &[workspace(root, "packages/app", "app")]);
3179
3180 assert_eq!(entries.len(), 1);
3181 assert!(entries[0].path.ends_with("packages/app/src/main.ts"));
3182 assert!(matches!(
3183 entries[0].source,
3184 EntryPointSource::PackageJsonMain
3185 ));
3186 }
3187
3188 #[test]
3189 fn workspace_entry_paths_have_no_current_dir_segment() {
3190 let dir = tempfile::tempdir().expect("tempdir");
3191 let root = dir.path();
3192 let ws_root = root.join("packages/a");
3193 std::fs::create_dir_all(&ws_root).expect("workspace dir");
3194 std::fs::write(ws_root.join("index.js"), "exports.a = 1;").expect("index");
3195 std::fs::write(ws_root.join("wrapper.mjs"), "export const a = 1;").expect("wrapper");
3196 std::fs::write(
3197 ws_root.join("package.json"),
3198 r#"{"main":"./index.js","exports":{"import":"./wrapper.mjs","require":"./index.js"}}"#,
3199 )
3200 .expect("workspace package file");
3201 let config = config_for(root);
3202 let files = [
3203 discovered(root, "packages/a/index.js", 0),
3204 discovered(root, "packages/a/wrapper.mjs", 1),
3205 ];
3206
3207 let entries = discover_entry_points(&config, &files, &[workspace(root, "packages/a", "a")]);
3208
3209 let mut paths: Vec<String> = entries
3210 .iter()
3211 .map(|entry| {
3212 entry
3213 .path
3214 .strip_prefix(root)
3215 .expect("entry inside root")
3216 .to_string_lossy()
3217 .replace('\\', "/")
3218 })
3219 .collect();
3220 paths.sort();
3221 assert_eq!(paths, vec!["packages/a/index.js", "packages/a/wrapper.mjs"]);
3222 }
3223
3224 #[test]
3225 fn root_wildcard_export_skips_files_of_nested_packages() {
3226 let dir = tempfile::tempdir().expect("tempdir");
3227 let root = dir.path();
3228 std::fs::create_dir_all(root.join("src")).expect("src dir");
3229 std::fs::create_dir_all(root.join("examples/demo/src")).expect("example dir");
3230 std::fs::write(root.join("src/vanilla.ts"), "export const v = 1;").expect("source");
3231 std::fs::write(
3232 root.join("examples/demo/src/util.js"),
3233 "export const u = 1;",
3234 )
3235 .expect("example file");
3236 std::fs::write(
3237 root.join("examples/demo/package.json"),
3238 r#"{"name":"demo"}"#,
3239 )
3240 .expect("example package file");
3241 std::fs::write(root.join("package.json"), r#"{"exports":{"./*":"./*.js"}}"#)
3242 .expect("package file");
3243 let config = config_for(root);
3244 let files = [
3245 discovered(root, "examples/demo/src/util.js", 0),
3246 discovered(root, "src/vanilla.ts", 1),
3247 ];
3248
3249 let entries = discover_entry_points(&config, &files, &[]);
3250
3251 let paths: Vec<PathBuf> = entries.iter().map(|entry| entry.path.clone()).collect();
3252 assert_eq!(paths, vec![root.join("src/vanilla.ts")]);
3253 }
3254
3255 #[test]
3256 fn root_wildcard_export_of_build_output_maps_to_source() {
3257 let dir = tempfile::tempdir().expect("tempdir");
3258 let root = dir.path();
3259 std::fs::create_dir_all(root.join("src/middleware")).expect("src dir");
3260 for file in [
3261 "src/index.ts",
3262 "src/middleware.ts",
3263 "src/middleware/immer.ts",
3264 ] {
3265 std::fs::write(root.join(file), "export const value = 1;").expect("source file");
3266 }
3267 std::fs::write(
3268 root.join("package.json"),
3269 r#"{"main":"./index.js","exports":{".":{"default":"./index.js"},"./*":{"import":"./esm/*.mjs","default":"./*.js"}}}"#,
3270 )
3271 .expect("package file");
3272 let config = config_for(root);
3273 let files = [
3274 discovered(root, "src/index.ts", 0),
3275 discovered(root, "src/middleware.ts", 1),
3276 discovered(root, "src/middleware/immer.ts", 2),
3277 ];
3278
3279 let entries = discover_entry_points(&config, &files, &[]);
3280
3281 let mut paths: Vec<String> = entries
3282 .iter()
3283 .map(|entry| {
3284 entry
3285 .path
3286 .strip_prefix(root)
3287 .expect("entry inside root")
3288 .to_string_lossy()
3289 .replace('\\', "/")
3290 })
3291 .collect();
3292 paths.sort();
3293 paths.dedup();
3294 assert_eq!(
3295 paths,
3296 vec![
3297 "src/index.ts",
3298 "src/middleware.ts",
3299 "src/middleware/immer.ts"
3300 ]
3301 );
3302 }
3303}