diff --git a/resolver/local.go b/resolver/local.go index febf151..948096b 100644 --- a/resolver/local.go +++ b/resolver/local.go @@ -80,6 +80,12 @@ func ScanInstalled() []string { // spec (major only, e.g. "18", or major.minor, e.g. "18.1"). The second return // value is false when no match is found or spec is not a valid partial. // +// Non-prerelease installs always beat prereleases for the same partial spec, so +// `nvm use 27` prefers 27.0.x over 27.1.0-alpha even when the alpha is newer by +// plain semver. When no stable match exists, the newest matching prerelease is +// returned (alpha-only majors). The returned string is canonical (keeps +// prerelease tags when that is the only match). +// // An optional pre-scanned list may be passed to avoid a redundant disk scan; // if omitted, ScanInstalled() is called internally. func LatestInstalledMatch(spec string, installed ...[]string) (string, bool) { @@ -113,11 +119,13 @@ func LatestInstalledMatch(spec string, installed ...[]string) (string, bool) { minor = parts[1] } - // ScanInstalled returns versions in descending order, so the first match is - // the latest installed version satisfying the spec. + // ScanInstalled is descending semver. Prefer the first stable match; remember + // the first prerelease as fallback when no GA exists under the partial. + fallback := "" for _, version := range list { - v := NormalizeVersion(version) - vparts := strings.Split(v, ".") + canonical := CanonicalVersion(version) + core := NormalizeVersion(canonical) + vparts := strings.Split(core, ".") if len(vparts) < 3 { continue } @@ -127,9 +135,35 @@ func LatestInstalledMatch(spec string, installed ...[]string) (string, bool) { if minor != "" && vparts[1] != minor { continue } - return v, true + if !IsUnstableVersion(canonical) { + return canonical, true + } + if fallback == "" { + fallback = canonical + } + } + if fallback != "" { + return fallback, true } + return "", false +} +// LatestInstalledAlpha returns the newest installed Node.js alpha prerelease +// (canonical tag containing "-alpha"), or ("", false) when none are installed. +// Used so `alpha` stays restricted to alpha builds and never picks GA/rc. +func LatestInstalledAlpha(installed ...[]string) (string, bool) { + var list []string + if len(installed) > 0 { + list = installed[0] + } else { + list = ScanInstalled() + } + for _, version := range list { + canonical := CanonicalVersion(version) + if IsAlphaVersion(canonical) { + return canonical, true + } + } return "", false } diff --git a/resolver/resolver.go b/resolver/resolver.go index 09fc55b..2d43b27 100644 --- a/resolver/resolver.go +++ b/resolver/resolver.go @@ -105,24 +105,58 @@ func Find(version string) (string, string, error) { return "", "", fmt.Errorf("version %s not found", version) } - if minor != "" { - for _, row := range versions { - tag := CanonicalVersion(row[0]) - if strings.HasPrefix(tag, major+"."+minor+".") { - if patch == "" { - return tag, row[2], nil - } - if strings.EqualFold(NormalizeVersion(tag), major+"."+minor+"."+patch) && !IsUnstableVersion(tag) { - return tag, row[2], nil - } - if strings.EqualFold(tag, major+"."+minor+"."+patch) { - return tag, row[2], nil - } - } - } + if tag, npm, ok := bestPartialCatalogMatch(versions, major, minor, patch); ok { + return tag, npm, nil } + return "", "", fmt.Errorf("version %s not found", version) +} - return CanonicalVersion(versions[0][0]), versions[0][2], nil +// bestPartialCatalogMatch picks the best index.tab row for a partial/exact core +// spec. Non-prerelease rows always beat prereleases (so 27.0.x wins over +// 27.1.0-alpha for `Find("27")`). Catalog order is newest-first; within the +// winning stability class the first match wins. When no stable match exists, +// the newest matching prerelease is returned. +func bestPartialCatalogMatch(versions [][]string, major, minor, patch string) (string, string, bool) { + fallbackTag := "" + fallbackNpm := "" + for _, row := range versions { + if len(row) == 0 { + continue + } + tag := CanonicalVersion(row[0]) + if tag == "" { + continue + } + core := NormalizeVersion(tag) + parts := strings.Split(core, ".") + if len(parts) < 3 { + continue + } + if parts[0] != major { + continue + } + if minor != "" && parts[1] != minor { + continue + } + if patch != "" && parts[2] != patch { + continue + } + npm := "" + if len(row) > 2 { + npm = row[2] + } + if !IsUnstableVersion(tag) { + return tag, npm, true + } + if fallbackTag == "" { + fallbackTag = tag + fallbackNpm = npm + } + } + if fallbackTag != "" { + return fallbackTag, fallbackNpm, true + } + return "", "", false } // LTSName returns the LTS codename for the given version (e.g. "Jod", "Iron"), diff --git a/resolver/resolver_test.go b/resolver/resolver_test.go index 8012ec5..0e3e0aa 100644 --- a/resolver/resolver_test.go +++ b/resolver/resolver_test.go @@ -110,3 +110,102 @@ func TestCanonicalVersion(t *testing.T) { t.Fatalf("CanonicalVersion = %q", got) } } + +func TestBestPartialCatalogMatchPrefersStableOverNewerAlpha(t *testing.T) { + // Newer alpha first (index.tab tip), older GA second — partial "27" must pick GA. + rows := [][]string{ + {"27.1.0-alpha.0.0.0", "2027-05-01", "12.2.0", "", "-"}, + {"27.0.5", "2027-04-15", "12.1.0", "", "-"}, + {"27.0.0-alpha.0.1.0", "2027-01-10", "12.0.0", "", "-"}, + {"26.13.0", "2026-10-28", "11.20.0", "Lithium", "-"}, + } + got, npm, ok := bestPartialCatalogMatch(rows, "27", "", "") + if !ok { + t.Fatal("expected a match for major 27") + } + if got != "27.0.5" { + t.Fatalf("bestPartialCatalogMatch(27) = %q, want 27.0.5 (stable over newer alpha)", got) + } + if npm != "12.1.0" { + t.Fatalf("npm = %q, want 12.1.0", npm) + } +} + +func TestBestPartialCatalogMatchFallsBackToPrerelease(t *testing.T) { + rows := [][]string{ + {"27.0.0-alpha.0.1.0", "2027-01-10", "12.0.1", "", "-"}, + {"27.0.0-alpha.0.0.0", "2027-01-01", "12.0.0", "", "-"}, + {"26.13.0", "2026-10-28", "11.20.0", "Lithium", "-"}, + } + got, _, ok := bestPartialCatalogMatch(rows, "27", "", "") + if !ok { + t.Fatal("expected prerelease fallback for alpha-only major 27") + } + if got != "27.0.0-alpha.0.1.0" { + t.Fatalf("bestPartialCatalogMatch(27) = %q, want newest alpha", got) + } +} + +func TestBestPartialCatalogMatchMajorMinorPrefersStable(t *testing.T) { + rows := [][]string{ + {"27.0.1-alpha.1", "2027-02-01", "12.0.2", "", "-"}, + {"27.0.0", "2027-01-15", "12.0.0", "", "-"}, + {"27.0.0-alpha.0.0.0", "2027-01-01", "12.0.0", "", "-"}, + } + got, _, ok := bestPartialCatalogMatch(rows, "27", "0", "") + if !ok { + t.Fatal("expected match for 27.0") + } + if got != "27.0.0" { + t.Fatalf("bestPartialCatalogMatch(27.0) = %q, want 27.0.0", got) + } +} + +func TestLatestInstalledMatchPrefersStableOverNewerAlpha(t *testing.T) { + installed := []string{ + "27.1.0-alpha.0.0.0", + "27.0.5", + "27.0.0-alpha.0.1.0", + "26.13.0", + } + got, ok := LatestInstalledMatch("27", installed) + if !ok { + t.Fatal("expected installed match for 27") + } + if got != "27.0.5" { + t.Fatalf("LatestInstalledMatch(27) = %q, want 27.0.5", got) + } +} + +func TestLatestInstalledMatchFallsBackToPrerelease(t *testing.T) { + installed := []string{"27.0.0-alpha.0.1.0", "27.0.0-alpha.0.0.0", "26.13.0"} + got, ok := LatestInstalledMatch("27", installed) + if !ok { + t.Fatal("expected prerelease fallback") + } + if got != "27.0.0-alpha.0.1.0" { + t.Fatalf("LatestInstalledMatch(27) = %q, want newest alpha tag (canonical)", got) + } +} + +func TestLatestInstalledAlphaIgnoresStableAndRC(t *testing.T) { + installed := []string{ + "27.0.0", + "27.0.0-rc.1", + "27.0.0-alpha.0.1.0", + "26.0.0-alpha.1", + } + got, ok := LatestInstalledAlpha(installed) + if !ok { + t.Fatal("expected an installed alpha") + } + if got != "27.0.0-alpha.0.1.0" { + t.Fatalf("LatestInstalledAlpha = %q, want 27.0.0-alpha.0.1.0", got) + } +} + +func TestLatestInstalledAlphaNone(t *testing.T) { + if _, ok := LatestInstalledAlpha([]string{"27.0.0", "27.0.0-rc.1"}); ok { + t.Fatal("expected no alpha match") + } +} diff --git a/resolver/status.go b/resolver/status.go index 67c67f0..64e709e 100644 --- a/resolver/status.go +++ b/resolver/status.go @@ -92,6 +92,12 @@ func resolveInstalledVersion(requestedVersion string, resolvePartialRemotely boo if isNamedSpecifier(requestedVersion) { version, _, err := findVersionFn(requestedVersion) if err != nil { + // Offline / catalog failure: `alpha` may still resolve from disk. + if strings.EqualFold(strings.TrimSpace(requestedVersion), "alpha") { + if local, ok := LatestInstalledAlpha(); ok { + return true, local, nil + } + } return false, "", err } if v, ok := checkInstalledLocallyFn(version); ok {