From 93d7296c19c7cfd5a22cfab599aecee4372d4ad0 Mon Sep 17 00:00:00 2001 From: Liang Date: Tue, 17 Nov 2026 20:44:26 +0800 Subject: [PATCH] fix(global): keep npm aliases through list, outdated, and update --- .../command_global_npm_alias/package.json | 3 + .../command_global_npm_alias/snapshots.toml | 16 +++++ .../snapshots/command_global_npm_alias.md | 67 +++++++++++++++++ crates/vp_global_cli/src/cli.rs | 22 ++++-- .../src/commands/env/package_metadata.rs | 46 +++++++++++- .../vp_global_cli/src/commands/global/mod.rs | 70 ++++++++++++++++-- .../src/commands/global/outdated.rs | 71 ++++++++++++------- .../src/commands/global/packages.rs | 12 +++- 8 files changed, 265 insertions(+), 42 deletions(-) create mode 100644 crates/vp_cli_snapshots/tests/cli_snapshots/fixtures/command_global_npm_alias/package.json create mode 100644 crates/vp_cli_snapshots/tests/cli_snapshots/fixtures/command_global_npm_alias/snapshots.toml create mode 100644 crates/vp_cli_snapshots/tests/cli_snapshots/fixtures/command_global_npm_alias/snapshots/command_global_npm_alias.md diff --git a/crates/vp_cli_snapshots/tests/cli_snapshots/fixtures/command_global_npm_alias/package.json b/crates/vp_cli_snapshots/tests/cli_snapshots/fixtures/command_global_npm_alias/package.json new file mode 100644 index 0000000000..8540f04a92 --- /dev/null +++ b/crates/vp_cli_snapshots/tests/cli_snapshots/fixtures/command_global_npm_alias/package.json @@ -0,0 +1,3 @@ +{ + "name": "command-global-npm-alias" +} diff --git a/crates/vp_cli_snapshots/tests/cli_snapshots/fixtures/command_global_npm_alias/snapshots.toml b/crates/vp_cli_snapshots/tests/cli_snapshots/fixtures/command_global_npm_alias/snapshots.toml new file mode 100644 index 0000000000..1f7122f865 --- /dev/null +++ b/crates/vp_cli_snapshots/tests/cli_snapshots/fixtures/command_global_npm_alias/snapshots.toml @@ -0,0 +1,16 @@ +[[case]] +name = "command_global_npm_alias" +vp = "global" +skip-platforms = ["windows"] +steps = [ + { argv = ["vp", "install", "-g", "testnpm2-alias@npm:testnpm2@1.0.0"], comment = "should prepare a version-pinned npm alias", snapshot = false }, + { argv = ["vp", "list", "-g"], comment = "should list the alias with its aliased package" }, + { argv = ["vp", "outdated", "testnpm2-alias", "-g", "--format", "json"], comment = "should resolve versions of the aliased package", continue-on-failure = true }, + { tty = false, argv = ["vp", "update", "-g"], comment = "should keep a pinned alias in place" }, + { tty = false, argv = ["vp", "update", "-g", "testnpm2-alias", "--latest"], comment = "should update the aliased package instead of a package named after the alias" }, + { argv = ["vpt", "grep-file", "$VP_HOME/packages/testnpm2-alias.json", 'versionSpec": "npm:testnpm2"'], comment = "should keep the alias after --latest drops the pin" }, + { argv = ["vp", "list", "-g"] }, +] +after = [ + { argv = ["vp", "remove", "-g", "testnpm2-alias"], continue-on-failure = true }, +] diff --git a/crates/vp_cli_snapshots/tests/cli_snapshots/fixtures/command_global_npm_alias/snapshots/command_global_npm_alias.md b/crates/vp_cli_snapshots/tests/cli_snapshots/fixtures/command_global_npm_alias/snapshots/command_global_npm_alias.md new file mode 100644 index 0000000000..8b83e02aa1 --- /dev/null +++ b/crates/vp_cli_snapshots/tests/cli_snapshots/fixtures/command_global_npm_alias/snapshots/command_global_npm_alias.md @@ -0,0 +1,67 @@ +# command_global_npm_alias + +## `vp install -g testnpm2-alias@npm:testnpm2@1.0.0` + +should prepare a version-pinned npm alias + + +## `vp list -g` + +should list the alias with its aliased package + +``` +Package Node version Binaries +--- --- --- +testnpm2-alias@npm:testnpm2@1.0.0 +``` + +## `vp outdated testnpm2-alias -g --format json` + +should resolve versions of the aliased package + +**Exit code:** 1 + +``` +{ + "testnpm2-alias": { + "current": "testnpm2@1.0.0", + "wanted": "testnpm2@1.0.0", + "latest": "testnpm2@1.0.1", + "dependent": "global", + "location": "/.vite-plus/packages/testnpm2-alias//lib/node_modules/testnpm2-alias" + } +} +``` + +## `vp update -g` + +should keep a pinned alias in place + +``` +All global packages are up to date. +``` + +## `vp update -g testnpm2-alias --latest` + +should update the aliased package instead of a package named after the alias + +``` +info: Updating 1 global package with Node.js + Updated testnpm2-alias to 1.0.1 +``` + +## `vpt grep-file $VP_HOME/packages/testnpm2-alias.json 'versionSpec": "npm:testnpm2"'` + +should keep the alias after --latest drops the pin + +``` +/.vite-plus/packages/testnpm2-alias.json: found "versionSpec\": \"npm:testnpm2\"" +``` + +## `vp list -g` + +``` +Package Node version Binaries +--- --- --- +testnpm2-alias@npm:testnpm2@1.0.1 +``` diff --git a/crates/vp_global_cli/src/cli.rs b/crates/vp_global_cli/src/cli.rs index d2bed7a410..7109df2156 100644 --- a/crates/vp_global_cli/src/cli.rs +++ b/crates/vp_global_cli/src/cli.rs @@ -888,13 +888,17 @@ async fn managed_update( current_node_version = get_current_node_version().await?; for metadata in &all { - if latest && metadata.version_spec.is_some() { - spec_rewrites.push((metadata.name.clone(), None, metadata.name.clone())); + if latest && metadata.version_spec != metadata.latest_version_spec() { + spec_rewrites.push(( + metadata.name.clone(), + metadata.latest_version_spec(), + metadata.latest_spec(), + )); } if !is_same_node_version(&metadata.platform.node, ¤t_node_version) { node_mismatches.push(NodeMismatchPackage { name: metadata.name.clone(), - spec: if latest { metadata.name.clone() } else { metadata.update_spec() }, + spec: if latest { metadata.latest_spec() } else { metadata.update_spec() }, installed_node: metadata.platform.node.clone(), }); } @@ -922,9 +926,13 @@ async fn managed_update( if new_spec != metadata.version_spec { spec_rewrites.push((package_name.clone(), new_spec, package.clone())); } - } else if latest && metadata.version_spec.is_some() { + } else if latest && metadata.version_spec != metadata.latest_version_spec() { // `--latest` applies to bare names only; explicit specs win. - spec_rewrites.push((package_name.clone(), None, package_name.clone())); + spec_rewrites.push(( + package_name.clone(), + metadata.latest_version_spec(), + metadata.latest_spec(), + )); } if !is_same_node_version(&metadata.platform.node, ¤t_node_version) { // Match the spec `get_outdated_packages` resolves for this @@ -932,7 +940,7 @@ async fn managed_update( let spec = if version_spec.is_some() { package.clone() } else if latest { - package_name.clone() + metadata.latest_spec() } else { metadata.update_spec() }; @@ -971,7 +979,7 @@ async fn managed_update( // A newer `latest` alone (e.g. a version-pinned package) is not // updatable; only a newer wanted version is. .filter(|package| package.wanted != package.current) - .map(|package| package.spec.unwrap_or(package.name)), + .map(|package| package.spec), ); let outdated_specs = to_update.iter().map(String::as_str).collect::>(); diff --git a/crates/vp_global_cli/src/commands/env/package_metadata.rs b/crates/vp_global_cli/src/commands/env/package_metadata.rs index c17b035f6a..4f04af58d7 100644 --- a/crates/vp_global_cli/src/commands/env/package_metadata.rs +++ b/crates/vp_global_cli/src/commands/env/package_metadata.rs @@ -8,7 +8,7 @@ use uuid::{Uuid, Version}; use vt_path::AbsolutePathBuf; use super::config::get_packages_dir; -use crate::error::Error; +use crate::{commands::global, error::Error}; // This is legacy, for old Vite+ version's compatibility const LEGACY_INSTALL_ID_PREFIX: char = '#'; @@ -42,8 +42,9 @@ pub struct PackageMetadata { #[serde(default)] pub js_bins: HashSet, /// Version spec the package was installed with (a dist-tag like - /// `nightly`, a range, or an exact version), so `vp update -g` keeps - /// resolving within it. `None` means the implicit `latest` tag. + /// `nightly`, a range, an exact version, or an npm alias like + /// `npm:other@^1`), so `vp update -g` keeps resolving within it. + /// `None` means the implicit `latest` tag. #[serde(default, skip_serializing_if = "Option::is_none")] pub version_spec: Option, /// Package manager used for installation (npm, yarn, pnpm) @@ -96,6 +97,25 @@ impl PackageMetadata { } } + /// Registry package installed under this name, when it is an npm alias. + pub fn alias_target(&self) -> Option { + self.version_spec.as_deref().and_then(global::alias_target) + } + + /// Version spec that remains once `--latest` drops the recorded one: + /// an npm alias keeps its target, everything else falls back to `latest`. + pub fn latest_version_spec(&self) -> Option { + self.alias_target().map(|target| format!("npm:{target}")) + } + + /// Registry spec for the `latest` dist-tag of the installed package. + pub fn latest_spec(&self) -> String { + match self.latest_version_spec() { + Some(spec) => format!("{}@{spec}", self.name), + None => self.name.clone(), + } + } + /// Check if a binary requires Node.js to run. pub fn is_js_binary(&self, bin_name: &str) -> bool { self.js_bins.contains(bin_name) @@ -293,6 +313,26 @@ mod tests { metadata.version_spec = Some("^1.0.0".to_string()); assert_eq!(metadata.update_spec(), "some-pkg@^1.0.0"); + assert_eq!(metadata.latest_spec(), "some-pkg"); + } + + #[test] + fn test_npm_alias_specs_keep_the_alias_target() { + let mut metadata = PackageMetadata::new( + "typescript".to_string(), + "1.5.0".to_string(), + "22.0.0".to_string(), + None, + vec![], + HashSet::new(), + "npm".to_string(), + ); + metadata.version_spec = Some("npm:cowsay@^1.5".to_string()); + + assert_eq!(metadata.alias_target().as_deref(), Some("cowsay")); + assert_eq!(metadata.update_spec(), "typescript@npm:cowsay@^1.5"); + assert_eq!(metadata.latest_version_spec().as_deref(), Some("npm:cowsay")); + assert_eq!(metadata.latest_spec(), "typescript@npm:cowsay"); } #[test] diff --git a/crates/vp_global_cli/src/commands/global/mod.rs b/crates/vp_global_cli/src/commands/global/mod.rs index 43d7d73381..e5d78d821b 100644 --- a/crates/vp_global_cli/src/commands/global/mod.rs +++ b/crates/vp_global_cli/src/commands/global/mod.rs @@ -48,7 +48,13 @@ impl NpmRegistry { } async fn latest_package_version(&self, package_spec: &str) -> Result { - let output = npm_view(&self.npm_path, &self.node_bin_dir, package_spec, "version").await?; + let output = npm_view( + &self.npm_path, + &self.node_bin_dir, + ®istry_query_spec(package_spec), + "version", + ) + .await?; parse_npm_view_version(&output) } @@ -170,14 +176,23 @@ pub(crate) fn parse_package_spec(spec: &str) -> Result<(String, Option), /// Return the version part of a registry package spec that update flows /// should keep resolving within: a dist-tag (e.g. `nightly` in -/// `some-pkg@nightly`), a range, or an exact version. The implicit `latest` -/// tag and non-registry version parts (URLs, aliases) yield `None`. +/// `some-pkg@nightly`), a range, an exact version, or an npm alias +/// (`npm:other` / `npm:other@^1`). The implicit `latest` tag and other +/// non-registry version parts (URLs, git, tarballs) yield `None`. pub(crate) fn update_version_spec(spec: &str) -> Option { if is_local_package_spec(spec) { return None; } let (_, version_spec) = parse_package_spec(spec).ok()?; let version_spec = version_spec?; + // Keep the alias so updates reinstall the aliased package, not one named after the alias. + if let Some(target) = version_spec.strip_prefix("npm:") { + let target_name = alias_target(&version_spec)?; + return Some(match update_version_spec(target) { + Some(target_spec) => format!("npm:{target_name}@{target_spec}"), + None => format!("npm:{target_name}"), + }); + } if version_spec.is_empty() || version_spec == "latest" || version_spec.contains(':') @@ -193,6 +208,26 @@ pub(crate) fn update_version_spec(spec: &str) -> Option { } } +/// Package name behind an npm alias version part (`npm:[@]`). +pub(crate) fn alias_target(version_spec: &str) -> Option { + let target = version_spec.strip_prefix("npm:")?; + if is_local_package_spec(target) { + return None; + } + parse_package_spec(target).ok().map(|(name, _)| name).filter(|name| !name.is_empty()) +} + +/// `npm view` rejects alias specs, so query the aliased package itself. +fn registry_query_spec(spec: &str) -> String { + if !is_local_package_spec(spec) + && let Ok((_, Some(version_spec))) = parse_package_spec(spec) + && let Some(target) = version_spec.strip_prefix("npm:") + { + return target.to_string(); + } + spec.to_string() +} + fn resolve_local_package_path(spec: &str) -> Result { let path_spec = spec.strip_prefix("file:").unwrap_or(spec); let path = std::path::Path::new(path_spec); @@ -371,10 +406,37 @@ mod tests { fn update_version_spec_ignores_non_registry_specs() { assert_eq!(update_version_spec("./local-pkg"), None); assert_eq!(update_version_spec("file:../pkg"), None); - assert_eq!(update_version_spec("some-pkg@npm:other@1.0.0"), None); assert_eq!(update_version_spec("some-pkg@github:user/repo"), None); assert_eq!(update_version_spec("some-pkg@archive.tgz"), None); assert_eq!(update_version_spec("some-pkg@archive.tar.gz"), None); assert_eq!(update_version_spec("some-pkg@archive.tar"), None); } + + #[test] + fn update_version_spec_keeps_npm_aliases() { + assert_eq!(update_version_spec("typescript@npm:cowsay"), Some("npm:cowsay".to_string())); + assert_eq!( + update_version_spec("typescript@npm:cowsay@latest"), + Some("npm:cowsay".to_string()) + ); + assert_eq!( + update_version_spec("typescript@npm:cowsay@^1.5"), + Some("npm:cowsay@^1.5".to_string()) + ); + assert_eq!( + update_version_spec("@scope/alias@npm:@types/node@20"), + Some("npm:@types/node@20".to_string()) + ); + assert_eq!(update_version_spec("some-pkg@npm:"), None); + assert_eq!(update_version_spec("some-pkg@npm:./local"), None); + } + + #[test] + fn registry_query_spec_resolves_npm_aliases() { + assert_eq!(registry_query_spec("typescript@npm:cowsay"), "cowsay"); + assert_eq!(registry_query_spec("typescript@npm:cowsay@^1.5"), "cowsay@^1.5"); + assert_eq!(registry_query_spec("@scope/alias@npm:@types/node@20"), "@types/node@20"); + assert_eq!(registry_query_spec("typescript@^5"), "typescript@^5"); + assert_eq!(registry_query_spec("typescript"), "typescript"); + } } diff --git a/crates/vp_global_cli/src/commands/global/outdated.rs b/crates/vp_global_cli/src/commands/global/outdated.rs index 65a58acc10..c242588a58 100644 --- a/crates/vp_global_cli/src/commands/global/outdated.rs +++ b/crates/vp_global_cli/src/commands/global/outdated.rs @@ -9,7 +9,7 @@ use console::style; use serde::Serialize; use vp_pm_cli::OutdatedFormat; -use super::{latest_package_versions, parse_package_spec}; +use super::{alias_target, latest_package_versions, parse_package_spec, update_version_spec}; use crate::{ cli::exit_status, commands::env::{config::get_node_modules_dir, package_metadata::PackageMetadata}, @@ -19,13 +19,15 @@ use crate::{ #[derive(Debug)] pub struct OutdatedPackage { pub name: String, + /// Versions of npm aliases carry the aliased package name (`other@1.0.0`). pub current: String, /// Newest version within the version spec recorded at install time (or /// given on the command line); what an update would install. pub wanted: String, /// Newest version on the registry's `latest` dist-tag. pub latest: String, - pub spec: Option, + /// Spec an update reinstalls the package with. + pub spec: String, install_id: String, node: String, bins: Vec, @@ -49,21 +51,18 @@ pub enum LookupMode { WantedAndLatest, } -fn registry_specs( - installed: &[(PackageMetadata, Option)], - mode: LookupMode, -) -> Vec { +fn registry_specs(installed: &[(PackageMetadata, String)], mode: LookupMode) -> Vec { let mut specs = Vec::new(); let mut seen = HashSet::new(); - for (package, spec) in installed { - let wanted_query = spec.as_deref().unwrap_or(&package.name); - let queries = std::iter::once(wanted_query).chain( - (mode == LookupMode::WantedAndLatest && wanted_query != package.name) - .then_some(package.name.as_str()), + for (package, wanted_query) in installed { + let latest_query = package.latest_spec(); + let queries = std::iter::once(wanted_query.clone()).chain( + (mode == LookupMode::WantedAndLatest && *wanted_query != latest_query) + .then_some(latest_query), ); for query in queries { - if seen.insert(query.to_string()) { - specs.push(query.to_string()); + if seen.insert(query.clone()) { + specs.push(query); } } } @@ -87,7 +86,7 @@ fn resolve_registry_version( fn resolve_package_versions( versions: &HashMap>, - package_name: &str, + latest_key: &str, wanted_key: &str, mode: LookupMode, ) -> Result<(String, String), (String, String)> { @@ -95,12 +94,19 @@ fn resolve_package_versions( .map_err(|error| (wanted_key.to_string(), error))?; let latest = match mode { LookupMode::WantedOnly => wanted.clone(), - LookupMode::WantedAndLatest => resolve_registry_version(versions, package_name) - .map_err(|error| (package_name.to_string(), error))?, + LookupMode::WantedAndLatest => resolve_registry_version(versions, latest_key) + .map_err(|error| (latest_key.to_string(), error))?, }; Ok((wanted, latest)) } +fn aliased_version(alias_target: Option<&str>, version: &str) -> String { + match alias_target { + Some(target) => format!("{target}@{version}"), + None => version.to_string(), + } +} + /// For json output in `vp outdated` command /// Use `npm outdated --json`'s data structure #[derive(Debug, Serialize)] @@ -133,11 +139,11 @@ pub async fn get_outdated_packages( // time (unless `--latest` overrides it); explicit versions // and tags win over both. let query_spec = if version_spec.is_some() { - Some(package.clone()) + package.clone() } else if latest { - None + metadata.latest_spec() } else { - Some(metadata.update_spec()) + metadata.update_spec() }; installed.push((metadata, query_spec)); } @@ -148,8 +154,7 @@ pub async fn get_outdated_packages( .await? .into_iter() .map(|package| { - let spec = - (!latest && package.version_spec.is_some()).then(|| package.update_spec()); + let spec = if latest { package.latest_spec() } else { package.update_spec() }; (package, spec) }) .collect() @@ -180,16 +185,20 @@ pub async fn get_outdated_packages( let mut outdated = Vec::new(); let mut failures = Vec::new(); for (package, spec) in installed { - let wanted_key = spec.clone().unwrap_or_else(|| package.name.clone()); let (wanted, latest) = - match resolve_package_versions(&versions, &package.name, &wanted_key, mode) { + match resolve_package_versions(&versions, &package.latest_spec(), &spec, mode) { Ok(versions) => versions, Err(failure) => { failures.push(failure); continue; } }; - let current = package.version.trim().to_string(); + // Label alias versions like `npm outdated`, so switching the aliased package is a change too. + let installed_alias = package.alias_target(); + let wanted_alias = update_version_spec(&spec).as_deref().and_then(alias_target); + let current = aliased_version(installed_alias.as_deref(), package.version.trim()); + let wanted = aliased_version(wanted_alias.as_deref(), &wanted); + let latest = aliased_version(installed_alias.as_deref(), &latest); if current == wanted && current == latest { continue; } @@ -407,7 +416,7 @@ fn print_table(packages: &[OutdatedPackage], long: bool) { mod tests { use super::*; - fn installed(version_spec: Option<&str>) -> Vec<(PackageMetadata, Option)> { + fn installed(version_spec: Option<&str>) -> Vec<(PackageMetadata, String)> { let mut package = PackageMetadata::new( "some-pkg".into(), "1.0.0".into(), @@ -418,7 +427,7 @@ mod tests { "npm".into(), ); package.version_spec = version_spec.map(str::to_string); - let query_spec = package.version_spec.is_some().then(|| package.update_spec()); + let query_spec = package.update_spec(); vec![(package, query_spec)] } @@ -440,6 +449,16 @@ mod tests { assert_eq!(specs, ["some-pkg"]); } + #[test] + fn npm_aliases_query_the_latest_alias_target() { + let specs = + registry_specs(&installed(Some("npm:other@^1.0.0")), LookupMode::WantedAndLatest); + assert_eq!(specs, ["some-pkg@npm:other@^1.0.0", "some-pkg@npm:other"]); + + let specs = registry_specs(&installed(Some("npm:other")), LookupMode::WantedAndLatest); + assert_eq!(specs, ["some-pkg@npm:other"]); + } + #[test] fn wanted_and_latest_reports_a_failed_latest_lookup() { let versions = HashMap::from([ diff --git a/crates/vp_global_cli/src/commands/global/packages.rs b/crates/vp_global_cli/src/commands/global/packages.rs index 1c11686058..9c97f0b238 100644 --- a/crates/vp_global_cli/src/commands/global/packages.rs +++ b/crates/vp_global_cli/src/commands/global/packages.rs @@ -51,7 +51,7 @@ pub async fn execute(json: bool, pattern: Option<&str>) -> Result) -> Resultgap$}{:gap$}{}", @@ -82,3 +82,11 @@ pub async fn execute(json: bool, pattern: Option<&str>) -> Result@npm:@`. +fn package_label(package: &PackageMetadata) -> String { + match package.alias_target() { + Some(target) => format!("{}@npm:{target}@{}", package.name, package.version), + None => format!("{}@{}", package.name, package.version), + } +}