fallow-graph 3.36.0

Module graph construction and import resolution for fallow codebase intelligence
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

//! Dependency aliases of workspace packages.
//!
//! pnpm installs `"vite": "workspace:@scope/core@*"` as the workspace package
//! `@scope/core` under the name `vite`. An import of `vite/pack` from that
//! package then reaches `@scope/core/pack`, also when another workspace member
//! has the name `vite`.

use std::path::Path;

use super::fallbacks::{nearest_package_manifest, try_workspace_package_fallback};
use super::path_info::extract_package_name;
use super::types::{ResolveContext, ResolveResult};

/// The specifier with the dependency alias replaced by the name of the
/// aliased project package.
///
/// The nearest `package.json` of `from_file` must declare the package name of
/// `specifier` as a `workspace:<name>@<range>` dependency, and `<name>` must be
/// a project package. Otherwise the result is `None`.
pub(super) fn aliased_specifier(
    ctx: &ResolveContext<'_>,
    from_file: &Path,
    specifier: &str,
) -> Option<String> {
    let alias = extract_package_name(specifier);
    let target = nearest_package_manifest(ctx.package_manifests, from_file)?
        .package_json
        .workspace_alias_target(&alias)?;
    let is_project_package = ctx.workspace_roots.contains_key(target)
        || ctx
            .package_manifests
            .iter()
            .any(|manifest| manifest.name.as_deref() == Some(target));
    if target == alias || !is_project_package {
        return None;
    }
    Some(format!("{target}{}", &specifier[alias.len()..]))
}

/// [`try_workspace_package_fallback`] through the dependency alias of
/// `from_file`, when it has one.
///
/// A result keeps the alias as its package name, because the importer declares
/// the alias, not the aliased package.
pub(super) fn try_aliased_workspace_package_fallback(
    ctx: &ResolveContext<'_>,
    from_file: &Path,
    specifier: &str,
    style_context: bool,
) -> Option<ResolveResult> {
    let aliased = aliased_specifier(ctx, from_file, specifier);
    workspace_fallback_through_alias(ctx, specifier, aliased.as_deref(), style_context)
}

fn workspace_fallback_through_alias(
    ctx: &ResolveContext<'_>,
    specifier: &str,
    aliased: Option<&str>,
    style_context: bool,
) -> Option<ResolveResult> {
    let Some(aliased) = aliased else {
        return try_workspace_package_fallback(ctx, specifier, style_context);
    };
    let alias = extract_package_name(specifier);
    let result = try_workspace_package_fallback(ctx, aliased, style_context)?;
    Some(match result {
        ResolveResult::InternalPackageModule { file_id, .. } => {
            ResolveResult::InternalPackageModule {
                file_id,
                package_name: alias,
            }
        }
        ResolveResult::CommonJsInternalPackageModule { file_id, .. } => {
            ResolveResult::CommonJsInternalPackageModule {
                file_id,
                package_name: alias,
            }
        }
        ResolveResult::NpmPackage(_) => ResolveResult::NpmPackage(alias),
        ResolveResult::CommonJsNpmPackage(_) => ResolveResult::CommonJsNpmPackage(alias),
        other => other,
    })
}

/// Classify a bare package specifier that the resolver and the earlier
/// fallbacks could not resolve.
///
/// A project package (or the project package that a dependency alias names)
/// gives an unresolved import. Any other package is an npm package.
pub(super) fn resolve_failed_bare_package_specifier(
    ctx: &ResolveContext<'_>,
    from_file: &Path,
    specifier: &str,
    style_context: bool,
    matches_tsconfig_path_alias: bool,
) -> ResolveResult {
    let aliased = aliased_specifier(ctx, from_file, specifier);
    if let Some(result) =
        workspace_fallback_through_alias(ctx, specifier, aliased.as_deref(), style_context)
    {
        return result;
    }
    if matches_tsconfig_path_alias {
        return ResolveResult::Unresolvable(specifier.to_string());
    }
    let pkg_name = extract_package_name(specifier);
    let lookup = aliased.map_or_else(
        || pkg_name.clone(),
        |aliased| extract_package_name(&aliased),
    );
    if ctx.workspace_roots.contains_key(lookup.as_str())
        || ctx
            .package_manifests
            .iter()
            .any(|manifest| manifest.name.as_deref() == Some(lookup.as_str()))
    {
        ResolveResult::Unresolvable(specifier.to_string())
    } else {
        ResolveResult::NpmPackage(pkg_name)
    }
}